diff --git a/README.md b/README.md
index d9d92e2..789fd94 100644
--- a/README.md
+++ b/README.md
@@ -120,6 +120,94 @@ protected function getHeaderActions(): array
 }
 ```
 
+4. Or directly in form schemas for Edit pages (Filament 4):
+
+```php
+use Filament\Forms\Components\ViewField;
+
+public static function configure(Schema $schema): Schema
+{
+    return $schema
+        ->components([
+            // Your other form fields...
+            
+            ViewField::make('comments_section')
+                ->view('commentions::filament.forms.comments-section')
+                ->viewData(fn ($livewire) => [
+                    'record' => $livewire->record ?? null
+                ])
+                ->columnSpanFull()
+                ->hiddenLabel(),
+        ]);
+}
+```
+
+To make the form comments readonly, pass the `readonly` flag in the viewData:
+
+```php
+ViewField::make('comments_section')
+    ->view('commentions::filament.forms.comments-section')
+    ->viewData(fn ($livewire) => [
+        'record' => $livewire->record ?? null,
+        'readonly' => true, // Enable readonly mode
+    ])
+    ->columnSpanFull()
+    ->hiddenLabel(),
+```
+
+**Note:** For View pages, continue using the infolist approach (option 1) as it works perfectly in that context.
+
+### Readonly Mode
+
+You can make comments readonly by chaining the `readonly()` method on the action. In readonly mode:
+- Users cannot add new comments
+- Users cannot edit existing comments
+- Users cannot delete comments
+- Users cannot react to comments (reactions are displayed but not interactive)
+
+```php
+// Make comments readonly for all actions
+CommentsAction::make()
+    ->readonly()
+    ->mentionables(User::all())
+
+CommentsTableAction::make()
+    ->readonly()
+    ->mentionables(User::all())
+
+// You can also conditionally enable readonly mode
+CommentsAction::make()
+    ->readonly(auth()->user()->cannot('create', Comment::class))
+    ->mentionables(User::all())
+```
+
+This is useful for scenarios like:
+- Archived or closed records where no further comments should be allowed
+- View-only access for certain user roles
+- Historical comment viewing
+- Audit trails where comments should be preserved but not modified
+
+#### Testing Readonly Functionality
+
+The package includes comprehensive tests for readonly functionality designed for Filament 4. To run the readonly-specific tests:
+
+```bash
+# Run all readonly tests
+./vendor/bin/pest tests/Livewire/Readonly* tests/Filament/ReadonlyActionsTest.php tests/Concerns/ReadonlyTraitsTest.php tests/Integration/ReadonlyIntegrationTest.php
+
+# Run specific test categories
+./vendor/bin/pest tests/Livewire/ReadonlyCommentsTest.php     # Comments component tests
+./vendor/bin/pest tests/Livewire/ReadonlyCommentTest.php      # Individual comment tests
+./vendor/bin/pest tests/Livewire/ReadonlyReactionsTest.php    # Reactions tests
+./vendor/bin/pest tests/Filament/ReadonlyActionsTest.php      # Filament 4 action tests
+./vendor/bin/pest tests/Integration/ReadonlyIntegrationTest.php # Integration tests
+
+# Run trait tests
+./vendor/bin/pest tests/Concerns/ReadonlyTraitsTest.php       # IsReadonly trait tests
+```
+
+**Note**: These tests are specifically designed for Filament 4 and may not be compatible with Filament 3.
+
 ### Subscription Management
 
 Commentions includes a subscription system that allows users to subscribe to receive notifications when new comments are added to a commentable resource.
diff --git a/phpstan.neon b/phpstan.neon
index f929f09..984c779 100644
--- a/phpstan.neon
+++ b/phpstan.neon
@@ -46,12 +46,6 @@ parameters:
             count: 1
             path: src/RenderableComment.php
 
-        -
-            message: '#^Call to an undefined method PHPUnit\\Framework\\TestCase::[a-zA-Z0-9_]+\(\)\.$#'
-            identifier: method.notFound
-            count: 3
-            path: tests/**/*.php
-
         -
             message: '#^Undefined variable\: \$this$#'
             identifier: variable.undefined
diff --git a/resources/lang/en/comments.php b/resources/lang/en/comments.php
index caba4d3..b6d5486 100644
--- a/resources/lang/en/comments.php
+++ b/resources/lang/en/comments.php
@@ -3,6 +3,7 @@
 return [
     'label' => 'Comments',
     'no_comments_yet' => 'No comments yet.',
+    'save_record_first' => 'Save the record first to enable comments.',
 
     'user_avatar_alt' => 'User Avatar',
 
diff --git a/resources/views/comment-list.blade.php b/resources/views/comment-list.blade.php
index a8c458a..1662e4c 100644
--- a/resources/views/comment-list.blade.php
+++ b/resources/views/comment-list.blade.php
@@ -19,6 +19,7 @@ class="comm:w-8 comm:h-8 comm:text-gray-400 comm:dark:text-gray-500"
             :key="$comment->getContentHash()"
             :comment="$comment"
             :mentionables="$mentionables"
+            :readonly="$this->isReadonly()"
         />
     @endforeach
 
diff --git a/resources/views/comment.blade.php b/resources/views/comment.blade.php
index d574332..51f96a1 100644
--- a/resources/views/comment.blade.php
+++ b/resources/views/comment.blade.php
@@ -34,7 +34,7 @@ class="comm:text-xs comm:text-gray-300 comm:ml-1"
                 @endif
             </div>
 
-            @if ($comment->isComment() && Config::resolveAuthenticatedUser()?->canAny(['update', 'delete'], $comment))
+            @if (!$this->isReadonly() && $comment->isComment() && Config::resolveAuthenticatedUser()?->canAny(['update', 'delete'], $comment))
                 <div class="comm:flex comm:gap-x-1">
                     @if (Config::resolveAuthenticatedUser()?->can('update', $comment))
                         <x-filament::icon-button
@@ -120,6 +120,7 @@ class="comm:text-xs comm:text-gray-300 comm:ml-1"
             @if ($comment->isComment())
                 <livewire:commentions::reactions
                     :comment="$comment"
+                    :readonly="$this->isReadonly()"
                     :wire:key="'reaction-manager-' . $comment->getId()"
                 />
             @endif
diff --git a/resources/views/comments-modal.blade.php b/resources/views/comments-modal.blade.php
index 83c12d5..bb85d3c 100644
--- a/resources/views/comments-modal.blade.php
+++ b/resources/views/comments-modal.blade.php
@@ -10,5 +10,6 @@
         :per-page-increment="$perPageIncrement ?? null"
         :sidebar-enabled="$sidebarEnabled ?? true"
         :show-subscribers="$showSubscribers ?? true"
+        :readonly="$readonly ?? false"
     />
 </div>
diff --git a/resources/views/comments.blade.php b/resources/views/comments.blade.php
index a18cc3d..e7f6dd1 100644
--- a/resources/views/comments.blade.php
+++ b/resources/views/comments.blade.php
@@ -3,7 +3,7 @@
 <div class="comm:flex comm:gap-4 comm:h-full" x-data="{ wasFocused: false }">
     {{-- Main Comments Area --}}
     <div class="comm:flex-1 comm:space-y-2">
-        @if (Config::resolveAuthenticatedUser()?->can('create', Config::getCommentModel()))
+        @if (!$this->isReadonly() && Config::resolveAuthenticatedUser()?->can('create', Config::getCommentModel()))
             <form wire:submit.prevent="save" x-cloak>
                 {{-- tiptap editor --}}
                 <div class="comm:relative tip-tap-container comm:mb-2" x-on:click="wasFocused = true" wire:ignore>
@@ -40,6 +40,7 @@
             :per-page="$perPage ?? 5"
             :load-more-label="$loadMoreLabel ?? 'Show more'"
             :per-page-increment="$perPageIncrement ?? null"
+            :readonly="$this->isReadonly()"
         />
     </div>
 
diff --git a/resources/views/filament/forms/comments-section.blade.php b/resources/views/filament/forms/comments-section.blade.php
new file mode 100644
index 0000000..6e5e6cb
--- /dev/null
+++ b/resources/views/filament/forms/comments-section.blade.php
@@ -0,0 +1,13 @@
+<div class="p-6 bg-white rounded-lg border border-gray-200 dark:bg-gray-800 dark:border-gray-700">
+    <h3 class="text-lg font-medium text-gray-900 dark:text-white mb-4">{{ __('commentions::comments.label') }}</h3>
+    
+    @if($record ?? null)
+        @livewire('commentions::comments', [
+            'record' => $record,
+            'mentionables' => config('commentions.mentionables.default', \App\Models\User::all()),
+            'readonly' => $readonly ?? false
+        ])
+    @else
+        <p class="text-sm text-gray-500 dark:text-gray-400">{{ __('commentions::comments.save_record_first', ['default' => 'Save the record first to enable comments.']) }}</p>
+    @endif
+</div>
diff --git a/resources/views/reactions.blade.php b/resources/views/reactions.blade.php
index eeff02e..5690bd0 100644
--- a/resources/views/reactions.blade.php
+++ b/resources/views/reactions.blade.php
@@ -2,25 +2,39 @@
     {{-- Inline buttons for existing reactions --}}
     @foreach ($this->reactionSummary as $reactionData)
         <span wire:key="inline-reaction-button-{{ $reactionData['reaction'] }}-{{ $comment->getId() }}">
-            <button
-                x-cloak
-                wire:click="handleReactionToggle('{{ $reactionData['reaction'] }}')"
-                type="button"
-                class="comm:inline-flex comm:items-center comm:justify-center comm:gap-1 comm:rounded-full comm:border comm:px-2 comm:h-8 comm:text-xs comm:font-medium comm:transition comm:focus:outline-none comm:focus:ring-2 comm:focus:ring-offset-2 comm:disabled:opacity-50 comm:disabled:cursor-not-allowed
-                    {{ $reactionData['reacted_by_current_user']
-                        ? 'comm:bg-gray-50 comm:dark:bg-gray-800 comm:border-gray-300 comm:dark:border-gray-600 comm:text-gray-700 comm:dark:text-gray-200 comm:hover:bg-gray-200 comm:dark:hover:bg-gray-600'
-                        : 'comm:bg-white comm:dark:bg-gray-900 comm:border-gray-300 comm:dark:border-gray-600 comm:text-gray-700 comm:dark:text-gray-200 comm:hover:bg-gray-100 comm:dark:hover:bg-gray-600' }}"
-                title="{{ $reactionData['reaction'] }}"
+            @if ($this->isReadonly())
+                <span
+                    class="comm:inline-flex comm:items-center comm:justify-center comm:gap-1 comm:rounded-full comm:border comm:px-2 comm:h-8 comm:text-xs comm:font-medium
+                        {{ $reactionData['reacted_by_current_user']
+                            ? 'comm:bg-gray-50 comm:dark:bg-gray-800 comm:border-gray-300 comm:dark:border-gray-600 comm:text-gray-700 comm:dark:text-gray-200'
+                            : 'comm:bg-white comm:dark:bg-gray-900 comm:border-gray-300 comm:dark:border-gray-600 comm:text-gray-700 comm:dark:text-gray-200' }}"
+                    title="{{ $reactionData['reaction'] }}"
+                >
+                    <span>{{ $reactionData['reaction'] }}</span>
+                    <span wire:key="inline-reaction-count-{{ $reactionData['reaction'] }}-{{ $comment->getId() }}">{{ $reactionData['count'] }}</span>
+                </span>
+            @else
+                <button
+                    x-cloak
+                    wire:click="handleReactionToggle('{{ $reactionData['reaction'] }}')"
+                    type="button"
+                    class="comm:inline-flex comm:items-center comm:justify-center comm:gap-1 comm:rounded-full comm:border comm:px-2 comm:h-8 comm:text-xs comm:font-medium comm:transition comm:focus:outline-none comm:focus:ring-2 comm:focus:ring-offset-2 comm:disabled:opacity-50 comm:disabled:cursor-not-allowed
+                        {{ $reactionData['reacted_by_current_user']
+                            ? 'comm:bg-gray-50 comm:dark:bg-gray-800 comm:border-gray-300 comm:dark:border-gray-600 comm:text-gray-700 comm:dark:text-gray-200 comm:hover:bg-gray-200 comm:dark:hover:bg-gray-600'
+                            : 'comm:bg-white comm:dark:bg-gray-900 comm:border-gray-300 comm:dark:border-gray-600 comm:text-gray-700 comm:dark:text-gray-200 comm:hover:bg-gray-100 comm:dark:hover:bg-gray-600' }}"
+                    title="{{ $reactionData['reaction'] }}"
 
-            >
-                <span>{{ $reactionData['reaction'] }}</span>
-                <span wire:key="inline-reaction-count-{{ $reactionData['reaction'] }}-{{ $comment->getId() }}">{{ $reactionData['count'] }}</span>
-            </button>
+                >
+                    <span>{{ $reactionData['reaction'] }}</span>
+                    <span wire:key="inline-reaction-count-{{ $reactionData['reaction'] }}-{{ $comment->getId() }}">{{ $reactionData['count'] }}</span>
+                </button>
+            @endif
         </span>
     @endforeach
 
     {{-- Add Reaction Button --}}
-    <div class="comm:relative" x-data="{ open: false }" wire:ignore.self>
+    @if (!$this->isReadonly())
+        <div class="comm:relative" x-data="{ open: false }" wire:ignore.self>
         <button
             x-on:click="open = !open"
             type="button"
@@ -63,7 +77,8 @@ class="comm:inline-flex comm:items-center comm:justify-center comm:gap-1 comm:ro
                 </button>
             @endforeach
         </div>
-    </div>
+        </div>
+    @endif
 
     {{-- Display summary of reactions not explicitly in the allowed list --}}
     @foreach ($this->reactionSummary as $reactionEmoji => $data)
diff --git a/src/Filament/Actions/CommentsAction.php b/src/Filament/Actions/CommentsAction.php
index 264697a..6eb121a 100644
--- a/src/Filament/Actions/CommentsAction.php
+++ b/src/Filament/Actions/CommentsAction.php
@@ -8,6 +8,7 @@
 use Kirschbaum\Commentions\Filament\Concerns\HasPagination;
 use Kirschbaum\Commentions\Filament\Concerns\HasPolling;
 use Kirschbaum\Commentions\Filament\Concerns\HasSidebar;
+use Kirschbaum\Commentions\Filament\Concerns\IsReadonly;
 
 class CommentsAction extends Action
 {
@@ -15,6 +16,7 @@ class CommentsAction extends Action
     use HasPagination;
     use HasPolling;
     use HasSidebar;
+    use IsReadonly;
 
     protected function setUp(): void
     {
@@ -32,6 +34,7 @@ protected function setUp(): void
                 'perPageIncrement' => $this->getPerPageIncrement() ?: $this->getPerPage(),
                 'sidebarEnabled' => $this->isSidebarEnabled(),
                 'showSubscribers' => $this->showSubscribers(),
+                'readonly' => $this->readonly,
             ]))
             ->modalWidth($this->isSidebarEnabled() ? '4xl' : 'xl')
             ->label(__('commentions::comments.label'))
diff --git a/src/Filament/Actions/CommentsTableAction.php b/src/Filament/Actions/CommentsTableAction.php
index 03883b1..443d0cd 100644
--- a/src/Filament/Actions/CommentsTableAction.php
+++ b/src/Filament/Actions/CommentsTableAction.php
@@ -7,12 +7,14 @@
 use Kirschbaum\Commentions\Filament\Concerns\HasMentionables;
 use Kirschbaum\Commentions\Filament\Concerns\HasPolling;
 use Kirschbaum\Commentions\Filament\Concerns\HasSidebar;
+use Kirschbaum\Commentions\Filament\Concerns\IsReadonly;
 
 class CommentsTableAction extends Action
 {
     use HasMentionables;
     use HasPolling;
     use HasSidebar;
+    use IsReadonly;
 
     protected function setUp(): void
     {
@@ -26,6 +28,7 @@ protected function setUp(): void
                 'pollingInterval' => $this->getPollingInterval(),
                 'sidebarEnabled' => $this->isSidebarEnabled(),
                 'showSubscribers' => $this->showSubscribers(),
+                'readonly' => $this->readonly,
             ]))
             ->modalWidth($this->isSidebarEnabled() ? '4xl' : 'xl')
             ->label(__('commentions::comments.label'))
diff --git a/src/Filament/Concerns/IsReadonly.php b/src/Filament/Concerns/IsReadonly.php
new file mode 100644
index 0000000..9819942
--- /dev/null
+++ b/src/Filament/Concerns/IsReadonly.php
@@ -0,0 +1,20 @@
+<?php
+
+namespace Kirschbaum\Commentions\Filament\Concerns;
+
+trait IsReadonly
+{
+    protected bool $readonly = false;
+
+    public function readonly(bool $readonly = true): static
+    {
+        $this->readonly = $readonly;
+
+        return $this;
+    }
+
+    public function isReadonly(): bool
+    {
+        return $this->readonly;
+    }
+}
diff --git a/src/Livewire/Comment.php b/src/Livewire/Comment.php
index a29e391..23fba70 100644
--- a/src/Livewire/Comment.php
+++ b/src/Livewire/Comment.php
@@ -8,6 +8,7 @@
 use Kirschbaum\Commentions\Config;
 use Kirschbaum\Commentions\Contracts\RenderableComment;
 use Kirschbaum\Commentions\Livewire\Concerns\HasMentions;
+use Kirschbaum\Commentions\Livewire\Concerns\IsReadonly;
 use Livewire\Attributes\On;
 use Livewire\Attributes\Renderless;
 use Livewire\Component;
@@ -15,6 +16,7 @@
 class Comment extends Component
 {
     use HasMentions;
+    use IsReadonly;
 
     public CommentModel|RenderableComment $comment;
 
@@ -39,7 +41,7 @@ public function handleReactionToggledEvent(string $reaction, int $commentId): vo
     #[Renderless]
     public function delete()
     {
-        if (! auth()->user()?->can('delete', $this->comment)) {
+        if ($this->isReadonly() || ! auth()->user()?->can('delete', $this->comment)) {
             return;
         }
 
@@ -75,7 +77,7 @@ public function clear(): void
 
     public function edit(): void
     {
-        if (! Config::resolveAuthenticatedUser()?->can('update', $this->comment)) {
+        if ($this->isReadonly() || ! Config::resolveAuthenticatedUser()?->can('update', $this->comment)) {
             return;
         }
 
@@ -87,7 +89,7 @@ public function edit(): void
 
     public function updateComment()
     {
-        if (! Config::resolveAuthenticatedUser()?->can('update', $this->comment)) {
+        if ($this->isReadonly() || ! Config::resolveAuthenticatedUser()?->can('update', $this->comment)) {
             return;
         }
 
diff --git a/src/Livewire/CommentList.php b/src/Livewire/CommentList.php
index 2887391..ce788c7 100644
--- a/src/Livewire/CommentList.php
+++ b/src/Livewire/CommentList.php
@@ -7,6 +7,7 @@
 use Kirschbaum\Commentions\Livewire\Concerns\HasMentions;
 use Kirschbaum\Commentions\Livewire\Concerns\HasPagination;
 use Kirschbaum\Commentions\Livewire\Concerns\HasPolling;
+use Kirschbaum\Commentions\Livewire\Concerns\IsReadonly;
 use Livewire\Attributes\Computed;
 use Livewire\Attributes\On;
 use Livewire\Component;
@@ -16,6 +17,7 @@ class CommentList extends Component
     use HasMentions;
     use HasPagination;
     use HasPolling;
+    use IsReadonly;
 
     public Model $record;
 
diff --git a/src/Livewire/Comments.php b/src/Livewire/Comments.php
index f39bb5e..7509d12 100644
--- a/src/Livewire/Comments.php
+++ b/src/Livewire/Comments.php
@@ -9,6 +9,7 @@
 use Kirschbaum\Commentions\Livewire\Concerns\HasPagination;
 use Kirschbaum\Commentions\Livewire\Concerns\HasPolling;
 use Kirschbaum\Commentions\Livewire\Concerns\HasSidebar;
+use Kirschbaum\Commentions\Livewire\Concerns\IsReadonly;
 use Livewire\Attributes\On;
 use Livewire\Attributes\Renderless;
 use Livewire\Component;
@@ -19,6 +20,7 @@ class Comments extends Component
     use HasPagination;
     use HasPolling;
     use HasSidebar;
+    use IsReadonly;
 
     public Model $record;
 
@@ -31,6 +33,10 @@ class Comments extends Component
     #[Renderless]
     public function save()
     {
+        if ($this->isReadonly()) {
+            return;
+        }
+
         $this->validate();
 
         SaveComment::run(
diff --git a/src/Livewire/Concerns/IsReadonly.php b/src/Livewire/Concerns/IsReadonly.php
new file mode 100644
index 0000000..2682f73
--- /dev/null
+++ b/src/Livewire/Concerns/IsReadonly.php
@@ -0,0 +1,13 @@
+<?php
+
+namespace Kirschbaum\Commentions\Livewire\Concerns;
+
+trait IsReadonly
+{
+    public bool $readonly = false;
+
+    public function isReadonly(): bool
+    {
+        return $this->readonly;
+    }
+}
diff --git a/src/Livewire/Reactions.php b/src/Livewire/Reactions.php
index 62fc4b5..10644a1 100644
--- a/src/Livewire/Reactions.php
+++ b/src/Livewire/Reactions.php
@@ -6,16 +6,23 @@
 use Kirschbaum\Commentions\Comment as CommentModel;
 use Kirschbaum\Commentions\Config;
 use Kirschbaum\Commentions\Contracts\RenderableComment;
+use Kirschbaum\Commentions\Livewire\Concerns\IsReadonly;
 use Livewire\Attributes\Computed;
 use Livewire\Attributes\On;
 use Livewire\Component;
 
 class Reactions extends Component
 {
+    use IsReadonly;
+
     public RenderableComment $comment;
 
     public function handleReactionToggle(string $reaction): void
     {
+        if ($this->isReadonly()) {
+            return;
+        }
+
         $this->dispatch(
             'comment:reaction:toggled',
             reaction: $reaction,
diff --git a/tests/Concerns/ReadonlyTraitsTest.php b/tests/Concerns/ReadonlyTraitsTest.php
new file mode 100644
index 0000000..40464bd
--- /dev/null
+++ b/tests/Concerns/ReadonlyTraitsTest.php
@@ -0,0 +1,105 @@
+<?php
+
+use Kirschbaum\Commentions\Filament\Concerns\IsReadonly as FilamentIsReadonly;
+use Kirschbaum\Commentions\Livewire\Concerns\IsReadonly as LivewireIsReadonly;
+
+// Mock class to test Filament IsReadonly trait
+class MockFilamentAction
+{
+    use FilamentIsReadonly;
+}
+
+// Mock class to test Livewire IsReadonly trait
+class MockLivewireComponent
+{
+    use LivewireIsReadonly;
+}
+
+test('Filament IsReadonly trait has correct default value', function () {
+    $mock = new MockFilamentAction();
+
+    expect($mock->isReadonly())->toBeFalse();
+});
+
+test('Filament IsReadonly trait readonly method sets value correctly', function () {
+    $mock = new MockFilamentAction();
+
+    // Test setting to true
+    $result = $mock->readonly(true);
+    expect($mock->isReadonly())->toBeTrue();
+    expect($result)->toBe($mock); // Should return self for fluent interface
+
+    // Test setting to false
+    $mock->readonly(false);
+    expect($mock->isReadonly())->toBeFalse();
+
+    // Test default parameter (should be true)
+    $mock->readonly();
+    expect($mock->isReadonly())->toBeTrue();
+});
+
+test('Filament IsReadonly trait returns fluent interface', function () {
+    $mock = new MockFilamentAction();
+
+    $result = $mock->readonly(true);
+
+    expect($result)->toBeInstanceOf(MockFilamentAction::class);
+    expect($result)->toBe($mock);
+});
+
+test('Livewire IsReadonly trait has correct default value', function () {
+    $mock = new MockLivewireComponent();
+
+    expect($mock->isReadonly())->toBeFalse();
+});
+
+test('Livewire IsReadonly trait readonly property can be set', function () {
+    $mock = new MockLivewireComponent();
+
+    // Test setting to true
+    $mock->readonly = true;
+    expect($mock->isReadonly())->toBeTrue();
+
+    // Test setting to false
+    $mock->readonly = false;
+    expect($mock->isReadonly())->toBeFalse();
+});
+
+test('Livewire IsReadonly trait isReadonly method returns correct value', function () {
+    $mock = new MockLivewireComponent();
+
+    // Default should be false
+    expect($mock->isReadonly())->toBeFalse();
+
+    // After setting to true
+    $mock->readonly = true;
+    expect($mock->isReadonly())->toBeTrue();
+
+    // After setting back to false
+    $mock->readonly = false;
+    expect($mock->isReadonly())->toBeFalse();
+});
+
+test('traits work independently', function () {
+    $filamentMock = new MockFilamentAction();
+    $livewireMock = new MockLivewireComponent();
+
+    // Set one to readonly
+    $filamentMock->readonly(true);
+
+    // The other should remain non-readonly
+    expect($filamentMock->isReadonly())->toBeTrue();
+    expect($livewireMock->isReadonly())->toBeFalse();
+
+    // Set the other to readonly
+    $livewireMock->readonly = true;
+
+    expect($filamentMock->isReadonly())->toBeTrue();
+    expect($livewireMock->isReadonly())->toBeTrue();
+
+    // Change first back to non-readonly
+    $filamentMock->readonly(false);
+
+    expect($filamentMock->isReadonly())->toBeFalse();
+    expect($livewireMock->isReadonly())->toBeTrue();
+});
diff --git a/tests/Filament/ReadonlyActionsTest.php b/tests/Filament/ReadonlyActionsTest.php
new file mode 100644
index 0000000..e049abd
--- /dev/null
+++ b/tests/Filament/ReadonlyActionsTest.php
@@ -0,0 +1,73 @@
+<?php
+
+use Kirschbaum\Commentions\Filament\Actions\CommentsAction;
+use Tests\Models\User;
+
+// Filament 4 specific tests for readonly functionality in actions
+
+test('Filament 4 CommentsAction readonly method sets readonly state', function () {
+    $action = CommentsAction::make();
+
+    // Default should be false
+    expect($action->isReadonly())->toBeFalse();
+
+    // Setting readonly to true
+    $action->readonly(true);
+    expect($action->isReadonly())->toBeTrue();
+
+    // Setting readonly to false
+    $action->readonly(false);
+    expect($action->isReadonly())->toBeFalse();
+
+    // Calling readonly() without parameter should default to true
+    $action->readonly();
+    expect($action->isReadonly())->toBeTrue();
+});
+
+test('Filament 4 CommentsAction readonly method returns fluent interface', function () {
+    $action = CommentsAction::make();
+
+    $result = $action->readonly();
+
+    expect($result)->toBeInstanceOf(CommentsAction::class);
+    expect($result)->toBe($action); // Should return the same instance
+});
+
+test('Filament 4 CommentsAction can chain readonly with other methods', function () {
+    $users = User::factory()->count(3)->create();
+
+    $action = CommentsAction::make()
+        ->readonly()
+        ->mentionables($users)
+        ->label('Read-only Comments');
+
+    expect($action->isReadonly())->toBeTrue();
+    expect($action->getMentionables())->toBe($users);
+});
+
+test('Filament 4 CommentsAction readonly state is properly maintained', function () {
+    $users = User::factory()->count(2)->create();
+
+    $action = CommentsAction::make()
+        ->readonly()
+        ->mentionables($users);
+
+    expect($action->isReadonly())->toBeTrue();
+
+    // Test chaining doesn't break readonly state
+    $action->label('Custom Label');
+    expect($action->isReadonly())->toBeTrue();
+});
+
+test('Filament 4 CommentsAction conditional readonly functionality', function () {
+    $action = CommentsAction::make();
+
+    // Test conditional readonly based on some logic
+    $shouldBeReadonly = true;
+    $action->readonly($shouldBeReadonly);
+    expect($action->isReadonly())->toBeTrue();
+
+    $shouldBeReadonly = false;
+    $action->readonly($shouldBeReadonly);
+    expect($action->isReadonly())->toBeFalse();
+});
diff --git a/tests/Integration/ReadonlyIntegrationTest.php b/tests/Integration/ReadonlyIntegrationTest.php
new file mode 100644
index 0000000..deccdf9
--- /dev/null
+++ b/tests/Integration/ReadonlyIntegrationTest.php
@@ -0,0 +1,188 @@
+<?php
+
+use Illuminate\Support\Facades\Auth;
+use Kirschbaum\Commentions\Comment as CommentModel;
+use Kirschbaum\Commentions\Config;
+use Kirschbaum\Commentions\Livewire\Comment as CommentComponent;
+use Kirschbaum\Commentions\Livewire\CommentList;
+use Kirschbaum\Commentions\Livewire\Comments;
+use Kirschbaum\Commentions\Livewire\Reactions;
+use Tests\Models\Post;
+use Tests\Models\User;
+
+use function Pest\Laravel\actingAs;
+use function Pest\Laravel\assertDatabaseHas;
+use function Pest\Laravel\assertDatabaseMissing;
+use function Pest\Livewire\livewire;
+
+beforeEach(function () {
+    config(['commentions.reactions.allowed' => ['👍', '❤️', '😂']]);
+    Config::resolveAuthenticatedUserUsing(fn () => Auth::user());
+});
+
+test('full readonly flow prevents all interactions', function () {
+    /** @var User $user */
+    $user = User::factory()->create();
+    actingAs($user);
+
+    $post = Post::factory()->create();
+    $existingComment = CommentModel::factory()->author($user)->commentable($post)->create([
+        'body' => 'Existing comment',
+    ]);
+    // Create a reaction directly in the database
+    $existingComment->reactions()->create([
+        'reactor_id' => $user->id,
+        'reactor_type' => $user->getMorphClass(),
+        'reaction' => '👍',
+    ]);
+
+    // Test Comments component in readonly mode
+    $commentsComponent = livewire(Comments::class, [
+        'record' => $post,
+        'readonly' => true,
+    ]);
+
+    // Should not allow creating new comments
+    $commentsComponent
+        ->set('commentBody', 'New comment attempt')
+        ->call('save')
+        ->assertSet('commentBody', 'New comment attempt'); // Should not be cleared
+
+    assertDatabaseMissing('comments', [
+        'body' => 'New comment attempt',
+    ]);
+
+    // Test Comment component in readonly mode
+    $commentComponent = livewire(CommentComponent::class, [
+        'comment' => $existingComment,
+        'readonly' => true,
+    ]);
+
+    // Should not allow editing
+    $commentComponent
+        ->call('edit')
+        ->assertSet('editing', false);
+
+    // Should not allow deleting
+    $commentComponent->call('delete');
+    assertDatabaseHas('comments', [
+        'id' => $existingComment->id,
+        'body' => 'Existing comment',
+    ]);
+
+    // Test Reactions component in readonly mode
+    $reactionsComponent = livewire(Reactions::class, [
+        'comment' => $existingComment,
+        'readonly' => true,
+    ]);
+
+    // Should not allow adding new reactions
+    $reactionsComponent->call('handleReactionToggle', '❤️');
+    assertDatabaseMissing('comment_reactions', [
+        'comment_id' => $existingComment->id,
+        'reaction' => '❤️',
+    ]);
+
+    // Should not allow removing existing reactions
+    $reactionsComponent->call('handleReactionToggle', '👍');
+    assertDatabaseHas('comment_reactions', [
+        'comment_id' => $existingComment->id,
+        'reaction' => '👍',
+    ]);
+});
+
+test('readonly state is properly inherited through component hierarchy', function () {
+    /** @var User $user */
+    $user = User::factory()->create();
+    actingAs($user);
+
+    $post = Post::factory()->create();
+    $comment = CommentModel::factory()->author($user)->commentable($post)->create([
+        'body' => 'Test comment',
+    ]);
+
+    // Test that CommentList passes readonly to child components
+    $commentListComponent = livewire(CommentList::class, [
+        'record' => $post,
+        'readonly' => true,
+    ]);
+
+    expect($commentListComponent->instance()->isReadonly())->toBeTrue();
+
+    // Test Comments component with sidebar
+    $commentsComponent = livewire(Comments::class, [
+        'record' => $post,
+        'readonly' => true,
+        'sidebarEnabled' => true,
+    ]);
+
+    expect($commentsComponent->instance()->isReadonly())->toBeTrue();
+});
+
+test('mixed readonly and editable components work independently', function () {
+    /** @var User $user */
+    $user = User::factory()->create();
+    actingAs($user);
+
+    $post = Post::factory()->create();
+    $comment = CommentModel::factory()->author($user)->commentable($post)->create([
+        'body' => 'Test comment',
+    ]);
+
+    // One readonly component
+    $readonlyComponent = livewire(CommentComponent::class, [
+        'comment' => $comment,
+        'readonly' => true,
+    ]);
+
+    // One editable component
+    $editableComponent = livewire(CommentComponent::class, [
+        'comment' => $comment,
+        'readonly' => false,
+    ]);
+
+    // Readonly should prevent editing
+    $readonlyComponent
+        ->call('edit')
+        ->assertSet('editing', false);
+
+    // Editable should allow editing
+    $editableComponent
+        ->call('edit')
+        ->assertSet('editing', true);
+
+    expect($readonlyComponent->instance()->isReadonly())->toBeTrue();
+    expect($editableComponent->instance()->isReadonly())->toBeFalse();
+});
+
+test('readonly mode respects existing permissions', function () {
+    $author = User::factory()->create();
+    $otherUser = User::factory()->create();
+    actingAs($otherUser);
+
+    $post = Post::factory()->create();
+    $comment = CommentModel::factory()->author($author)->commentable($post)->create([
+        'body' => 'Authors comment',
+    ]);
+
+    // Even in non-readonly mode, other users shouldn't be able to edit
+    $component = livewire(CommentComponent::class, [
+        'comment' => $comment,
+        'readonly' => false,
+    ]);
+
+    // Should not show edit/delete buttons due to permissions
+    $component
+        ->assertDontSeeHtml('wire:click="edit"')
+        ->assertDontSeeHtml('wire:click="delete"');
+
+    // In readonly mode, still shouldn't be able to edit
+    $readonlyComponent = livewire(CommentComponent::class, [
+        'comment' => $comment,
+        'readonly' => true,
+    ]);
+
+    $readonlyComponent
+        ->assertDontSeeHtml('wire:click="edit"')
+        ->assertDontSeeHtml('wire:click="delete"');
+});
diff --git a/tests/Livewire/CommentsTest.php b/tests/Livewire/CommentsTest.php
index 848b015..696afd4 100644
--- a/tests/Livewire/CommentsTest.php
+++ b/tests/Livewire/CommentsTest.php
@@ -7,6 +7,8 @@
 use Tests\Models\User;
 
 use function Pest\Laravel\actingAs;
+use function Pest\Laravel\assertDatabaseHas;
+use function Pest\Laravel\assertDatabaseMissing;
 use function Pest\Livewire\livewire;
 
 test('can create a comment', function () {
@@ -27,7 +29,7 @@
         ->assertSet('commentBody', '')
         ->assertDispatched('comment:saved');
 
-    $this->assertDatabaseHas('comments', [
+    assertDatabaseHas('comments', [
         'body' => 'This is a test comment',
         'commentable_id' => $post->id,
         'commentable_type' => Post::class,
@@ -56,7 +58,7 @@
         ->call('save')
         ->assertHasErrors(['commentBody' => 'required']);
 
-    $this->assertDatabaseMissing('comments', [
+    assertDatabaseMissing('comments', [
         'commentable_id' => $post->id,
         'commentable_type' => Post::class,
     ]);
@@ -75,7 +77,7 @@
             ->call('save');
     })->toThrow(TypeError::class);
 
-    $this->assertDatabaseMissing('comments', [
+    assertDatabaseMissing('comments', [
         'body' => 'This is a test comment',
         'commentable_id' => $post->id,
         'commentable_type' => Post::class,
diff --git a/tests/Livewire/ReadonlyCommentListTest.php b/tests/Livewire/ReadonlyCommentListTest.php
new file mode 100644
index 0000000..531ab9e
--- /dev/null
+++ b/tests/Livewire/ReadonlyCommentListTest.php
@@ -0,0 +1,81 @@
+<?php
+
+use Kirschbaum\Commentions\Comment as CommentModel;
+use Kirschbaum\Commentions\Livewire\CommentList;
+use Tests\Models\Post;
+use Tests\Models\User;
+
+use function Pest\Laravel\actingAs;
+use function Pest\Livewire\livewire;
+
+test('readonly comment list component isReadonly method returns correct value', function () {
+    $user = User::factory()->create();
+    actingAs($user);
+
+    $post = Post::factory()->create();
+
+    // Test readonly true
+    $readonlyComponent = livewire(CommentList::class, [
+        'record' => $post,
+        'readonly' => true,
+    ]);
+
+    expect($readonlyComponent->instance()->isReadonly())->toBeTrue();
+
+    // Test readonly false
+    $editableComponent = livewire(CommentList::class, [
+        'record' => $post,
+        'readonly' => false,
+    ]);
+
+    expect($editableComponent->instance()->isReadonly())->toBeFalse();
+
+    // Test default value
+    $defaultComponent = livewire(CommentList::class, [
+        'record' => $post,
+    ]);
+
+    expect($defaultComponent->instance()->isReadonly())->toBeFalse();
+});
+
+test('readonly comment list properly passes readonly state to child comments', function () {
+    $user = User::factory()->create();
+    actingAs($user);
+
+    $post = Post::factory()->create();
+    $comment = CommentModel::factory()->author($user)->commentable($post)->create([
+        'body' => 'Test comment',
+    ]);
+
+    $component = livewire(CommentList::class, [
+        'record' => $post,
+        'readonly' => true,
+    ]);
+
+    // Check that the view contains readonly true for child components
+    $component->assertSee('Test comment');
+
+    // Verify the component correctly identifies as readonly
+    expect($component->instance()->isReadonly())->toBeTrue();
+});
+
+test('non-readonly comment list allows interaction', function () {
+    $user = User::factory()->create();
+    actingAs($user);
+
+    $post = Post::factory()->create();
+    $comment = CommentModel::factory()->author($user)->commentable($post)->create([
+        'body' => 'Test comment',
+    ]);
+
+    $component = livewire(CommentList::class, [
+        'record' => $post,
+        'readonly' => false,
+    ]);
+
+    // Check that the view contains the comment
+    $component->assertSee('Test comment');
+
+    // Verify the component correctly identifies as not readonly
+    expect($component->instance()->isReadonly())->toBeFalse();
+});
diff --git a/tests/Livewire/ReadonlyCommentTest.php b/tests/Livewire/ReadonlyCommentTest.php
new file mode 100644
index 0000000..e43d454
--- /dev/null
+++ b/tests/Livewire/ReadonlyCommentTest.php
@@ -0,0 +1,154 @@
+<?php
+
+use Kirschbaum\Commentions\Comment as CommentModel;
+use Kirschbaum\Commentions\Livewire\Comment as CommentComponent;
+use Tests\Models\Post;
+use Tests\Models\User;
+
+use function Pest\Laravel\actingAs;
+use function Pest\Laravel\assertDatabaseHas;
+use function Pest\Laravel\assertDatabaseMissing;
+use function Pest\Livewire\livewire;
+
+test('readonly comment component hides edit and delete buttons', function () {
+    /** @var User $user */
+    $user = User::factory()->create();
+    actingAs($user);
+
+    $post = Post::factory()->create();
+    $comment = CommentModel::factory()->author($user)->commentable($post)->create([
+        'body' => 'Test comment body',
+    ]);
+
+    livewire(CommentComponent::class, [
+        'comment' => $comment,
+        'readonly' => true,
+    ])
+        ->assertSee('Test comment body')
+        ->assertSee($comment->author->name)
+        ->assertDontSeeHtml('wire:click="edit"')  // Edit button should be hidden
+        ->assertDontSeeHtml('wire:click="delete"'); // Delete button should be hidden
+});
+
+test('readonly comment component prevents editing', function () {
+    /** @var User $user */
+    $user = User::factory()->create();
+    actingAs($user);
+
+    $post = Post::factory()->create();
+    $comment = CommentModel::factory()->author($user)->commentable($post)->create([
+        'body' => 'Original comment body',
+    ]);
+
+    livewire(CommentComponent::class, [
+        'comment' => $comment,
+        'readonly' => true,
+    ])
+        ->call('edit')
+        ->assertSet('editing', false) // Should not enter edit mode
+        ->assertSet('commentBody', ''); // Comment body should remain empty
+});
+
+test('readonly comment component prevents deleting', function () {
+    /** @var User $user */
+    $user = User::factory()->create();
+    actingAs($user);
+
+    $post = Post::factory()->create();
+    $comment = CommentModel::factory()->author($user)->commentable($post)->create([
+        'body' => 'Comment to be protected',
+    ]);
+
+    livewire(CommentComponent::class, [
+        'comment' => $comment,
+        'readonly' => true,
+    ])
+        ->call('delete');
+
+    // Comment should still exist in database
+    assertDatabaseHas('comments', [
+        'id' => $comment->id,
+        'body' => 'Comment to be protected',
+    ]);
+});
+
+test('readonly comment component prevents updating', function () {
+    /** @var User $user */
+    $user = User::factory()->create();
+    actingAs($user);
+
+    $post = Post::factory()->create();
+    $comment = CommentModel::factory()->author($user)->commentable($post)->create([
+        'body' => 'Original comment body',
+    ]);
+
+    livewire(CommentComponent::class, [
+        'comment' => $comment,
+        'readonly' => true,
+    ])
+        ->set('commentBody', 'Modified comment body')
+        ->call('updateComment');
+
+    // Comment should remain unchanged in database
+    assertDatabaseHas('comments', [
+        'id' => $comment->id,
+        'body' => 'Original comment body',
+    ]);
+
+    assertDatabaseMissing('comments', [
+        'id' => $comment->id,
+        'body' => 'Modified comment body',
+    ]);
+});
+
+test('readonly comment component isReadonly method returns correct value', function () {
+    $user = User::factory()->create();
+    actingAs($user);
+
+    $post = Post::factory()->create();
+    $comment = CommentModel::factory()->author($user)->commentable($post)->create();
+
+    // Test readonly true
+    $readonlyComponent = livewire(CommentComponent::class, [
+        'comment' => $comment,
+        'readonly' => true,
+    ]);
+
+    expect($readonlyComponent->instance()->isReadonly())->toBeTrue();
+
+    // Test readonly false
+    $editableComponent = livewire(CommentComponent::class, [
+        'comment' => $comment,
+        'readonly' => false,
+    ]);
+
+    expect($editableComponent->instance()->isReadonly())->toBeFalse();
+
+    // Test default value
+    $defaultComponent = livewire(CommentComponent::class, [
+        'comment' => $comment,
+    ]);
+
+    expect($defaultComponent->instance()->isReadonly())->toBeFalse();
+});
+
+test('non-readonly comment component allows editing and deleting', function () {
+    /** @var User $user */
+    $user = User::factory()->create();
+    actingAs($user);
+
+    $post = Post::factory()->create();
+    $comment = CommentModel::factory()->author($user)->commentable($post)->create([
+        'body' => 'Original comment body',
+    ]);
+
+    livewire(CommentComponent::class, [
+        'comment' => $comment,
+        'readonly' => false,
+    ])
+        ->assertSeeHtml('wire:click="edit"')  // Edit button should be visible
+        ->assertSeeHtml('wire:click="delete"') // Delete button should be visible
+        ->call('edit')
+        ->assertSet('editing', true) // Should enter edit mode
+        ->assertSet('commentBody', 'Original comment body'); // Comment body should be loaded
+});
diff --git a/tests/Livewire/ReadonlyCommentsTest.php b/tests/Livewire/ReadonlyCommentsTest.php
new file mode 100644
index 0000000..94adfbf
--- /dev/null
+++ b/tests/Livewire/ReadonlyCommentsTest.php
@@ -0,0 +1,122 @@
+<?php
+
+use Illuminate\Support\Facades\Event;
+use Kirschbaum\Commentions\Events\CommentWasCreatedEvent;
+use Kirschbaum\Commentions\Livewire\Comments;
+use Tests\Models\Post;
+use Tests\Models\User;
+
+use function Pest\Laravel\actingAs;
+use function Pest\Laravel\assertDatabaseHas;
+use function Pest\Laravel\assertDatabaseMissing;
+use function Pest\Livewire\livewire;
+
+test('readonly comments component prevents creating new comments', function () {
+    Event::fake();
+
+    /** @var User $user */
+    $user = User::factory()->create();
+    actingAs($user);
+
+    $post = Post::factory()->create();
+
+    livewire(Comments::class, [
+        'record' => $post,
+        'readonly' => true,
+    ])
+        ->set('commentBody', 'This should not be saved')
+        ->call('save')
+        ->assertHasNoErrors()
+        ->assertSet('commentBody', 'This should not be saved'); // Body should not be cleared since save was prevented
+
+    assertDatabaseMissing('comments', [
+        'body' => 'This should not be saved',
+        'commentable_id' => $post->id,
+        'commentable_type' => Post::class,
+        'author_id' => $user->id,
+    ]);
+
+    Event::assertNotDispatched(CommentWasCreatedEvent::class);
+});
+
+test('readonly comments component isReadonly method returns correct value', function () {
+    $post = Post::factory()->create();
+
+    // Test readonly true
+    $readonlyComponent = livewire(Comments::class, [
+        'record' => $post,
+        'readonly' => true,
+    ]);
+
+    expect($readonlyComponent->instance()->isReadonly())->toBeTrue();
+
+    // Test readonly false
+    $editableComponent = livewire(Comments::class, [
+        'record' => $post,
+        'readonly' => false,
+    ]);
+
+    expect($editableComponent->instance()->isReadonly())->toBeFalse();
+
+    // Test default value
+    $defaultComponent = livewire(Comments::class, [
+        'record' => $post,
+    ]);
+
+    expect($defaultComponent->instance()->isReadonly())->toBeFalse();
+});
+
+test('non-readonly comments component allows creating comments', function () {
+    Event::fake();
+
+    /** @var User $user */
+    $user = User::factory()->create();
+    actingAs($user);
+
+    $post = Post::factory()->create();
+
+    livewire(Comments::class, [
+        'record' => $post,
+        'readonly' => false,
+    ])
+        ->set('commentBody', 'This should be saved')
+        ->call('save')
+        ->assertHasNoErrors()
+        ->assertSet('commentBody', ''); // Body should be cleared after successful save
+
+    assertDatabaseHas('comments', [
+        'body' => 'This should be saved',
+        'commentable_id' => $post->id,
+        'commentable_type' => Post::class,
+        'author_id' => $user->id,
+    ]);
+
+    Event::assertDispatched(CommentWasCreatedEvent::class);
+});
+
+test('readonly comments component works with Filament 4 view field integration', function () {
+    /** @var User $user */
+    $user = User::factory()->create();
+    actingAs($user);
+
+    $post = Post::factory()->create();
+
+    // Simulate how it would be used in a Filament 4 form ViewField
+    $component = livewire(Comments::class, [
+        'record' => $post,
+        'readonly' => true,
+    ]);
+
+    expect($component->instance()->isReadonly())->toBeTrue();
+
+    // Should not allow saving even when trying to bypass readonly
+    $component
+        ->set('commentBody', 'Attempt to bypass readonly')
+        ->call('save');
+
+    expect($component->get('commentBody'))->toBe('Attempt to bypass readonly');
+
+    assertDatabaseMissing('comments', [
+        'body' => 'Attempt to bypass readonly',
+    ]);
+});
diff --git a/tests/Livewire/ReadonlyReactionsTest.php b/tests/Livewire/ReadonlyReactionsTest.php
new file mode 100644
index 0000000..e3fcbe5
--- /dev/null
+++ b/tests/Livewire/ReadonlyReactionsTest.php
@@ -0,0 +1,143 @@
+<?php
+
+use Illuminate\Support\Facades\Auth;
+use Kirschbaum\Commentions\Comment as CommentModel;
+use Kirschbaum\Commentions\Config;
+use Kirschbaum\Commentions\Livewire\Reactions;
+use Tests\Models\Post;
+use Tests\Models\User;
+
+use function Pest\Laravel\actingAs;
+use function Pest\Laravel\assertDatabaseHas;
+use function Pest\Laravel\assertDatabaseMissing;
+use function Pest\Livewire\livewire;
+
+beforeEach(function () {
+    config(['commentions.reactions.allowed' => ['👍', '❤️', '😂', '😮', '😢', '🤔']]);
+    Config::resolveAuthenticatedUserUsing(fn () => Auth::user());
+});
+
+test('readonly reactions component prevents adding reactions', function () {
+    /** @var User $user */
+    $user = User::factory()->create();
+    actingAs($user);
+
+    $post = Post::factory()->create();
+    $comment = CommentModel::factory()->author($user)->commentable($post)->create();
+
+    livewire(Reactions::class, [
+        'comment' => $comment,
+        'readonly' => true,
+    ])
+        ->call('handleReactionToggle', '👍');
+
+    // No reaction should be created
+    assertDatabaseMissing('comment_reactions', [
+        'comment_id' => $comment->id,
+        'reactor_id' => $user->id,
+        'reactor_type' => $user->getMorphClass(),
+        'reaction' => '👍',
+    ]);
+});
+
+test('readonly reactions component prevents removing reactions', function () {
+    /** @var User $user */
+    $user = User::factory()->create();
+    actingAs($user);
+
+    $post = Post::factory()->create();
+    $comment = CommentModel::factory()->author($user)->commentable($post)->create();
+
+    // First create a reaction directly in the database
+    $comment->reactions()->create([
+        'reactor_id' => $user->id,
+        'reactor_type' => $user->getMorphClass(),
+        'reaction' => '👍',
+    ]);
+
+    // Verify reaction exists
+    assertDatabaseHas('comment_reactions', [
+        'comment_id' => $comment->id,
+        'reactor_id' => $user->id,
+        'reactor_type' => $user->getMorphClass(),
+        'reaction' => '👍',
+    ]);
+
+    // Try to remove it in readonly mode
+    livewire(Reactions::class, [
+        'comment' => $comment,
+        'readonly' => true,
+    ])
+        ->call('handleReactionToggle', '👍');
+
+    // Reaction should still exist
+    assertDatabaseHas('comment_reactions', [
+        'comment_id' => $comment->id,
+        'reactor_id' => $user->id,
+        'reactor_type' => $user->getMorphClass(),
+        'reaction' => '👍',
+    ]);
+});
+
+test('readonly reactions component isReadonly method returns correct value', function () {
+    $user = User::factory()->create();
+    actingAs($user);
+
+    $post = Post::factory()->create();
+    $comment = CommentModel::factory()->author($user)->commentable($post)->create();
+
+    // Test readonly true
+    $readonlyComponent = livewire(Reactions::class, [
+        'comment' => $comment,
+        'readonly' => true,
+    ]);
+
+    expect($readonlyComponent->instance()->isReadonly())->toBeTrue();
+
+    // Test readonly false
+    $editableComponent = livewire(Reactions::class, [
+        'comment' => $comment,
+        'readonly' => false,
+    ]);
+
+    expect($editableComponent->instance()->isReadonly())->toBeFalse();
+
+    // Test default value
+    $defaultComponent = livewire(Reactions::class, [
+        'comment' => $comment,
+    ]);
+
+    expect($defaultComponent->instance()->isReadonly())->toBeFalse();
+});
+
+test('non-readonly reactions component allows reaction toggling via Comment component', function () {
+    /** @var User $user */
+    $user = User::factory()->create();
+    actingAs($user);
+
+    $post = Post::factory()->create();
+    $comment = CommentModel::factory()->author($user)->commentable($post)->create();
+
+    // Test that non-readonly reactions component correctly calls the event
+    $reactionsComponent = livewire(Reactions::class, [
+        'comment' => $comment,
+        'readonly' => false,
+    ]);
+
+    expect($reactionsComponent->instance()->isReadonly())->toBeFalse();
+
+    // Verify that the handleReactionToggle method executes without readonly restrictions
+    // We test this by ensuring the method doesn't return early due to readonly check
+    $reactionsComponent->call('handleReactionToggle', '👍');
+
+    // The actual reaction creation happens in the Comment component via the dispatched event
+    // So we test the reaction creation through the Comment component integration
+    $comment->toggleReaction('👍');
+
+    assertDatabaseHas('comment_reactions', [
+        'comment_id' => $comment->id,
+        'reactor_id' => $user->id,
+        'reactor_type' => $user->getMorphClass(),
+        'reaction' => '👍',
+    ]);
+});