solid_objects 0.2.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 654720ae19caa970f403b5cded61287e1f6a9eb9d731ff90fd9f4f103d55fa53
-  data.tar.gz: 256712423dd88685643a0345de44eb774efbca12188c78c9e89571ef884b59fc
+  metadata.gz: 557108141818714af50bfee19acda22c9243482e976b50329e5e234aed6d9adb
+  data.tar.gz: fe525288022e4bb0630e60bc7ec949e2f61d1ad152fadcaccaeaa41bd1a0376e
 SHA512:
-  metadata.gz: f1e43da5f13c33558bdb187b52c55b55093786d3ec8af9f49d4ffc123ade274d2f5483dd8975c6a638152dfc9ae1c4cf416d8b1ea94cb1383ac30b33ef7548aa
-  data.tar.gz: f8cb10850b5b3748450ffaf741417866ed360437657c5d21836312018f0d6b27109cd69c4035f770f6cf643227ab086ae7eedc1b0a14245103cfe517a008f49c
+  metadata.gz: e4414b1f2e0d47f95f9307fec6140894bcd8ebcab6dbdc20f54155c332dea76de2728ca7b0bf71bc13c978f2494e059f2099986757c3b933296d460a2bec7a65
+  data.tar.gz: 6e807551d58c7d87465bc55b460386f5b9617e36021ddbdfdcbfd25aac31d9c48a7166a818f5a39be3f52eb6a7cb63efd74223a0512fb7a53dce7c55a2c23ca8

data/CHANGELOG.md

@@ -1,5 +1,29 @@
 # Changelog
 
+## 0.4.0 - 2026-08-06
+
+- Add dependency-driven live ERB components with request-time authorization,
+  conventional partial resolution, revision fencing, refresh coalescing, and
+  reconnect convergence without broadcasting personalized HTML.
+- Persist a monotonic state revision for secure component refresh ordering.
+- Retry SQLite synchronous lock contention in Ruby so a native busy wait
+  cannot starve the thread holding the database lock.
+- Allow maintainers to dispatch CI manually when a push webhook is dropped.
+
+## 0.3.0 - 2026-08-06
+
+- Reject application-record writes from actor handlers and provide registered
+  same-database commit actions for fenced atomic changes.
+- Reject synchronous invocation inside an open Solid Objects transaction and
+  add adapter database deadlines, durable diagnostics, and recoverable results
+  to sync timeouts.
+- Guard handlers, observables, lifecycle hooks, and state migrations from
+  direct application-record writes.
+- Add dry-run-first bounded message, process, and opt-in actor-instance
+  pruning, configurable retention, and graceful caller-process shutdown.
+- Add authorized committed state snapshots, mutable JSON copies, commit-action
+  instrumentation, and deterministic full-runtime Minitest draining.
+
 ## 0.2.1 - 2026-08-06
 
 - Add `solid_objects:doctor` for configuration, schema, policy, runtime, and

data/README.md

@@ -24,6 +24,7 @@ end
 counter = Counter.ref("global")
 count = counter.increment(amount: 5)
 current_count = counter.value
+current_snapshot = counter.snapshot.value
 
 # Durable fire-and-forget delivery. A worker processes it later.
 message = counter.async(:increment, amount: 5)
@@ -41,13 +42,21 @@ The invocation model is the first adoption decision:
 | --- | --- | --- |
 | `counter.increment(amount: 5)` | Committed handler result | No |
 | `counter.sync(:increment, amount: 5)` | Committed handler result | No |
-| `counter.value` | Deeply frozen state snapshot | No |
+| `counter.value` | Ordered, committed query result | No |
+| `counter.snapshot.value` | Current committed state without a mailbox message | No |
 | `counter.async(:increment, amount: 5)` | `MessageReference` immediately | Yes |
 
 Direct methods and `sync` durably enqueue the call, then the Rails caller helps
 execute the actor through the same mailbox, lease, and fencing path as a
 worker. `async` only enqueues; a runtime process handles it later.
 
+Synchronous calls fail before enqueue when the Solid Objects database
+connection is already inside a transaction. Actor handlers may read application
+records, but direct Active Record writes are rejected so they cannot escape a
+later actor failure. Use a same-database
+[`commit_action`](#application-database-writes) for atomic database changes and
+[`emit`](#effects) for external I/O.
+
 Before adopting a latency-sensitive or high-volume surface, read
 [Is Solid Objects a good fit?](docs/fit.md) and the
 [measured performance and row-growth costs](docs/benchmarks.md).
@@ -56,8 +65,8 @@ This is a port of the programming model, not Cloudflare's edge runtime or
 platform. Read the conceptual overview at [solidobjects.dev](https://solidobjects.dev/)
 and the exact Rails guarantees in [Correctness and delivery semantics](docs/correctness.md).
 
-Version 0.2 is an early release. Its correctness core is implemented and tested,
-but the project does not yet claim production readiness. See
+Solid Objects is an early release. Its correctness core is implemented and
+tested, but the project does not yet claim production readiness. See
 [Status](#status) and the [roadmap](docs/roadmap.md).
 
 ## Table of contents
@@ -65,10 +74,12 @@ but the project does not yet claim production readiness. See
 - [Cloudflare Durable Objects for Rails](#cloudflare-durable-objects-for-rails)
 - [Reactive ERB](#reactive-erb)
 - [Installation](#installation)
+- [Upgrading](#upgrading)
 - [Worker requirements](#worker-requirements)
 - [Defining an actor](#defining-an-actor)
 - [Actor identity](#actor-identity)
 - [Invoking an object](#invoking-an-object)
+- [Application database writes](#application-database-writes)
 - [Effects](#effects)
 - [Reminders](#reminders)
 - [Destroying an object](#destroying-an-object)
@@ -163,42 +174,105 @@ rolled-back state change cannot leak into the page.
 Define an observable:
 
 ```ruby
-class ShoppingCart < SolidObjects::Actor
-  attribute :items, default: -> { [] }
+class ChatRoom < SolidObjects::Actor
+  attribute :recent_messages, default: -> { [] }
+  attribute :status, default: "open"
 
-  observable :items_count do
-    items.sum { |item| item.fetch("quantity") }
+  observable :message_count do
+    recent_messages.length
   end
+
+  observable :recent_messages
+  observable :status
 end
 ```
 
-Render it:
+Scalar observables remain stable `<span>` targets:
 
 ```erb
-<%= solid_object current_cart do |cart| %>
-  Cart items: <%= cart.items_count %>
+<%= solid_object @room, authorization_context: current_user do |room| %>
+  Messages: <%= room.message_count %>
 <% end %>
 ```
 
-That template provides initial server rendering, a stable opaque DOM target,
-and live Turbo replacements after committed actor turns. One `solid_object`
-block makes one Action Cable subscription for all values inside it, and Action
-Cable multiplexes subscriptions over the browser's WebSocket.
+Reactive components rerender a host ERB partial when one of their explicit
+dependencies changes:
+
+```erb
+<%= solid_object @room, authorization_context: current_user do |room| %>
+  <%= room.component :messages, observes: :recent_messages %>
+  <%= room.component :presence, observes: %i[recent_messages status] %>
+<% end %>
+```
+
+`room.component(:messages)` resolves only
+`actors/chat_room/_messages`. Its partial receives `actor` and
+`authorization_context` locals:
+
+```erb
+<ul>
+  <% actor.recent_messages.each do |message| %>
+    <li><%= message.fetch("body") %></li>
+  <% end %>
+</ul>
+```
+
+Declared observables are deeply frozen ordinary Ruby values inside a
+component. Arrays support loops, hashes support ordinary lookup, conditionals
+work normally, and ERB still escapes user strings. A reactive component cannot
+read `actor.state`, access an undeclared observable, or choose a dynamic
+partial path.
+
+That template provides initial server rendering, stable opaque DOM targets,
+and live updates after committed actor turns. One `solid_object` block makes
+one Action Cable subscription for all scalar values and components inside it,
+and Action Cable multiplexes subscriptions over the browser's WebSocket.
 
 No client-side state store, custom Stimulus controller, channel class, manual
 broadcast, or one-WebSocket-per-value setup is required. Signed stream tokens
-protect integrity, an application policy authorizes every subscription,
-broadcasts are delivered from a durable outbox, and reconnecting clients
-refresh from current actor state.
+protect integrity, not access. Initial rendering authorizes with the
+`authorization_context` passed to `solid_object`; Cable authorizes with its
+connection; every component refresh authorizes again with a request-specific
+context:
+
+```ruby
+SolidObjects.configure do |configuration|
+  configuration.component_authorization_context = ->(controller:) { Current.user }
+end
+```
 
-`cart.component(:summary)` supports initial rendering of
-`actors/shopping_cart/_summary`. Durable live component replacement and
-Turbo append actions are roadmap work; observable replacement is the live path
-implemented in 0.2.
+The durable outbox stores one row per changed observable, never personalized
+HTML. Cable sends invalidation metadata over the shared actor stream, then a
+Turbo Frame requests the component with normal cookies. Only scalar targets
+that the server rendered into this `solid_object` scope are signed into its
+stream token and receive value payloads; component-only dependencies do not
+send their values to the browser. The endpoint renders the latest committed
+snapshot, returns `private, no-store`, and reauthorizes the component name plus
+every declared dependency. Two viewers can therefore receive different HTML
+for the same actor without sharing either projection.
+
+Reconnect compares the component's signed initial revision with the latest
+actor incarnation and state revision, then refreshes stale components. Cable
+coalesces several dependency changes from one actor turn into one component
+refresh and ignores older out-of-order invalidations. A newer invalidation
+replaces an in-flight frame, so its detached older response cannot overwrite
+newer state.
+
+Reactive components add no HTML to durable rows, but each affected component
+causes an authorized HTTP render. One actor turn still inserts one broadcast
+row per changed observable; several dependencies from that turn coalesce at
+the subscriber. Keep components bounded, declare only necessary dependencies,
+and use scalar observables for inexpensive single-value replacement.
 
 Reactive views require `turbo-rails` and a working Action Cable adapter in the
-host application. They are optional; the actor runtime itself does not depend
-on Turbo.
+host application. The Solid Objects engine must be mounted so its signed
+component endpoint is reachable. Reactive views are optional; the actor
+runtime itself does not depend on Turbo.
+
+```ruby
+# config/routes.rb
+mount SolidObjects::Engine => "/solid_objects"
+```
 
 ## Installation
 
@@ -264,6 +338,50 @@ can generate the gem RBI with:
 bundle exec tapioca gem solid_objects
 ```
 
+## Upgrading
+
+Review [CHANGELOG.md](CHANGELOG.md) for compatibility and deployment-order
+notes, then update the gem:
+
+```bash
+bundle update solid_objects
+```
+
+If the `Gemfile` pins an exact version, update that constraint first and run
+`bundle install`. Commit both `Gemfile.lock` and the copied Solid Objects
+migrations.
+
+Copy only migrations that the newer gem has added, migrate, and verify the
+installation:
+
+```bash
+bin/rails solid_objects:install:migrations
+bin/rails db:migrate
+bin/rails solid_objects:doctor
+```
+
+The migration task skips engine migrations already present in the application
+and gives new migrations host-specific timestamps. Inspect the resulting
+`db/migrate/*.solid_objects.rb` files before applying them. Do not rerun
+`generate solid_objects:install` during an upgrade because that also attempts
+to regenerate the application initializer.
+
+When Solid Objects uses a separate database configuration named `actors`, copy
+and run migrations through that database's configured migration path:
+
+```bash
+DATABASE=actors bin/rails solid_objects:install:migrations
+bin/rails db:migrate:actors
+bin/rails solid_objects:doctor
+```
+
+For production, back up the actor database and run new migrations before
+starting application or Solid Objects worker processes that require the new
+schema. Restart the web and Solid Objects worker fleet after the bundle and
+schema are current. For releases that change actor state versions, also follow
+the [state migration and rolling-deployment guide](docs/state-migrations.md);
+Rails schema migrations and actor state migrations are separate concerns.
+
 ## Worker requirements
 
 Synchronous actors can be adopted without adding a long-running process. Start
@@ -273,13 +391,14 @@ the runtime when the feature introduces asynchronous delivery or outboxes:
 | --- | --- |
 | Direct actor method or explicit `sync` | None; the caller executes it |
 | Attribute or declared query read | None; the caller executes it |
+| Committed `snapshot` read | None; reads the instance row directly |
 | `destroy` | None |
 | `async` including delayed delivery | Actor worker |
 | One-shot or recurring `schedule` | Reminder scheduler and actor worker |
 | `emit` without an actor callback | Effect worker |
 | `emit` with success or failure callback | Effect worker and actor worker |
 | Actor-to-actor `async` or `send_to` | Effect worker and actor worker |
-| Observable Turbo updates | Broadcast worker, Action Cable, and the actor execution path |
+| Scalar or component Turbo updates | Broadcast worker, Action Cable, and the actor execution path |
 | Initial `solid_object` server render | No Solid Objects worker; normal Rails rendering |
 
 One command starts every Solid Objects role:
@@ -346,6 +465,20 @@ mailbox. State changes must go through public actor methods or explicit
 State, arguments, results, effects, and reminder arguments accept
 JSON-compatible values. Solid Objects never deserializes Ruby `Marshal` data.
 
+Attribute readers are ordered mailbox queries and retain message history. For
+a read that does not need mailbox ordering, use an authorized committed
+snapshot:
+
+```ruby
+snapshot = cart.snapshot
+items = snapshot.items
+```
+
+Snapshots and synchronous results are deeply frozen. Use
+`SolidObjects.mutable_copy(items)` before changing a returned collection.
+Snapshot reads can race with an in-flight turn; they return the most recently
+committed state and do not create or activate a missing actor.
+
 Lifecycle hooks are also available:
 
 ```ruby
@@ -451,6 +584,37 @@ and MCP request/response boundaries when the handler itself fits the
 application's latency budget. If another process owns the activation, the
 caller waits for the durable result using wake-up hints with bounded database
 polling as the fallback. A timeout never cancels the durable invocation.
+`SolidObjects::SyncTimeout` includes actor identity, message ID, sequence,
+durable status, mailbox blocker, and activation-owner diagnostics without
+including message arguments. The configured timeout also bounds adapter
+database lock waits from the enqueue attempt through result observation.
+PostgreSQL uses transaction lock and statement timeouts, SQLite uses its busy
+timeout, and MySQL uses its execution timeout plus InnoDB's one-second minimum
+lock-wait granularity.
+
+The durable call can finish after its original caller gives up. Reauthorize and
+recover its eventual result through the durable message identity:
+
+```ruby
+begin
+  order.submit(timeout: 250.milliseconds)
+rescue SolidObjects::SyncTimeout => error
+  result = error.message_reference.wait(
+    timeout: 5.seconds,
+    authorization_context: Current.user
+  )
+end
+```
+
+If the enqueue transaction itself cannot finish within the budget, Solid
+Objects raises `SyncEnqueueTimeout`; no durable message exists to recover.
+Timeouts do not preempt Ruby handler code that has already started.
+
+Do not wrap a synchronous actor call in `ApplicationRecord.transaction`.
+Solid Objects raises `SolidObjects::SyncInsideTransaction` before enqueue when
+its connection already has an open transaction. Move the actor call before the
+transaction, use `async`, or let the actor own the coordinated change through a
+commit action.
 
 Actor code cannot use direct calls or `sync` on another actor; synchronous
 actor-to-actor waits can deadlock in cycles. Use `async` or `send_to` and a
@@ -492,6 +656,50 @@ end
 
 External systems must also deduplicate effects using the stable effect ID.
 
+## Application database writes
+
+Actor handlers execute outside the fenced commit. They may query application
+records, but Solid Objects rejects direct Active Record writes from all
+user-supplied actor code: handlers, observables, activation/deactivation hooks,
+and state migrations. Otherwise an application row could commit before the
+actor later raises or loses its activation fence.
+
+For a short database-only change that must commit atomically with actor state,
+stage a named action:
+
+```ruby
+class Assessment < SolidObjects::Actor
+  attribute :status, default: "open"
+
+  def finish(attempt_id:, score:)
+    self.status = "complete"
+    commit_action :complete_attempt, attempt_id:, score:
+  end
+end
+```
+
+Register its implementation during application boot:
+
+```ruby
+SolidObjects.register_commit_action(:complete_attempt) do |arguments, context|
+  AssessmentAttempt.find(arguments.fetch("attempt_id")).update!(
+    score: arguments.fetch("score"),
+    actor_message_id: context.message_id
+  )
+end
+```
+
+The registered block runs inside the short fenced transaction. Its database
+writes, actor state, message completion, and outboxes all commit or roll back
+together. Commit actions require Solid Objects and `ActiveRecord::Base` to
+share one connection pool. They may be invoked again after a database rollback,
+so keep them deterministic, bounded, and database-only. Never perform network
+I/O, wait for another actor, or enqueue nontransactional work from a commit
+action.
+
+When Solid Objects uses a separate actor database, use `emit` and an idempotent
+effect consumer instead; the two databases cannot share one transaction.
+
 ## Effects
 
 Cloudflare Durable Objects can call external services directly. Solid Objects
@@ -555,6 +763,10 @@ It may read `SolidObjects::Instance.states_for`, `.without_pending_work`, and
 `.orphaned`, but every repair must go through `async`. Never bulk-update actor
 state around the lease and fencing checks.
 
+Suspended actors should be reported rather than silently resumed. Spread large
+repair batches with `available_at:` so reconciliation cannot stampede one
+mailbox or the worker fleet.
+
 ## Destroying an object
 
 Destroy an actor incarnation through its reference:
@@ -631,6 +843,11 @@ Important defaults:
 | `max_attempts` | 5 |
 | `process_heartbeat_interval` | 15 seconds |
 | `process_alive_threshold` | 60 seconds |
+| `message_retention` | 30 days |
+| `message_retention_by_actor_type` | `{}` |
+| `instance_retention_by_actor_type` | `{}`; instances never expire unless listed |
+| `process_retention` | 7 days |
+| `prune_batch_size` | 1,000 |
 | `worker_count` | 1 |
 | `effect_worker_count` | 1 |
 | `broadcast_worker_count` | 1 |
@@ -664,10 +881,16 @@ Administration commands require the administration policy:
 ```bash
 bundle exec solid_objects status
 bundle exec solid_objects cleanup
+bundle exec solid_objects prune_messages
+bundle exec solid_objects prune_instances
+bundle exec solid_objects prune_processes
 bundle exec solid_objects dead_letters
 bundle exec solid_objects retry_dead_letter 123
 ```
 
+The prune commands preview counts by default. Add `--execute` only after
+reviewing the configured retention policy.
+
 The supervisor stops new claims, drains active loops, releases cached leases,
 and marks process rows stopped on graceful shutdown. A hard-killed worker's
 claimed turn is recovered after its process heartbeat or activation lease
@@ -814,11 +1037,13 @@ See the [development guide](docs/development.md) and
 
 ## Status
 
-Implemented and tested in 0.2:
+Implemented and tested in 0.4:
 
 - Rails engine, install generator, migrations, and `solid_objects` executable;
 - actor registry, references, JSON state, and state migrations;
 - direct synchronous actor RPC, explicit `sync`, and durable `async`;
+- guarded transaction boundaries, same-database commit actions, adapter lock
+  deadlines, structured synchronous timeout diagnostics, and result recovery;
 - durable message history plus ready and claimed membership tables;
 - concurrent sequence allocation and actor creation;
 - activation leases, per-activation tokens, fencing generations, and
@@ -830,8 +1055,13 @@ Implemented and tested in 0.2:
 - one-shot and recurring per-actor reminders;
 - authorized actor destruction with fenced stale-write rejection and cascading
   durable-work cleanup;
-- durable observable broadcasts and authorized Action Cable refresh;
-- process registration, heartbeats, cleanup, and graceful shutdown; and
+- durable observable invalidations, scalar Turbo replacement, and authorized
+  request-time ERB component refresh;
+- process registration, heartbeats, caller shutdown, cleanup, and bounded
+  message/process retention plus opt-in actor-instance expiration;
+- an opt-in Minitest helper for actor-state isolation and deterministic async
+  actor/reminder/effect/broadcast draining;
+- authorized mailbox-free state snapshots and mutable JSON copies; and
 - SQLite, PostgreSQL, and MySQL integration tests.
 
 Partially implemented:
@@ -840,12 +1070,12 @@ Partially implemented:
   run periodic maintenance automatically;
 - cross-process wake-up uses polling; PostgreSQL notifications and optional
   Redis acceleration are not implemented;
-- live observable replacement works, while live component replacement and
-  Turbo append actions remain future work;
+- live observable and component replacement work, while Turbo append actions
+  remain future work;
 - local admission limits exist, but distributed rate limits and global
   admission control do not; and
-- administration views exist, but retention automation and richer audit tools
-  do not.
+- administration views and pruning commands exist, but scheduled maintenance
+  and richer audit tools do not.
 
 Production readiness requires hardening and operational soak evidence. The
 [roadmap](docs/roadmap.md) tracks that work.

data/app/controllers/solid_objects/components_controller.rb

@@ -0,0 +1,78 @@
+# rbs_inline: enabled
+
+require "action_controller/base"
+
+module SolidObjects
+  class ComponentsController < ActionController::Base
+    protect_from_forgery with: :exception
+
+    # @rbs () -> void
+    def show
+      registration = ComponentRegistration.from_token(
+        params.require(:token)
+      )
+      requested_revision = requested_revision_key
+      snapshot = ActorSnapshot.new(registration.reference)
+      return head :conflict if newer_than_snapshot?(requested_revision, snapshot)
+
+      authorization_context = SolidObjects
+        .configuration
+        .component_authorization_context
+        .call(controller: self)
+      rendered = ComponentRenderer.new(
+        snapshot:,
+        component_name: registration.component_name,
+        dependencies: registration.dependencies,
+        view_context: component_view_context,
+        authorization_context:
+      ).call
+      response.headers["Cache-Control"] = "private, no-store"
+      render html: component_frame(registration, snapshot, rendered)
+    rescue Unauthorized
+      head :forbidden
+    rescue UnknownComponent
+      head :not_found
+    rescue ActionController::ParameterMissing,
+      ArgumentError,
+      InvalidComponentToken
+      head :bad_request
+    end
+
+    private
+
+    # @rbs () -> Array[Integer]
+    def requested_revision_key
+      instance_id = Integer(params.fetch(:instance_id), 10)
+      revision = Integer(params.fetch(:revision), 10)
+      raise ArgumentError if instance_id.negative? || revision.negative?
+
+      [ instance_id, revision ]
+    end
+
+    # @rbs (Array[Integer], ActorSnapshot) -> bool
+    def newer_than_snapshot?(requested_revision, snapshot)
+      (requested_revision <=> [ snapshot.instance_id, snapshot.revision ]) == 1
+    end
+
+    # @rbs () -> untyped
+    def component_view_context
+      if defined?(Rails) && Rails.application
+        prepend_view_path(*Rails.application.paths["app/views"].existent)
+      end
+
+      view_context.tap do |context|
+        context.extend(Rails.application.helpers) if defined?(Rails) && Rails.application
+      end
+    end
+
+    # @rbs (ComponentRegistration, ActorSnapshot, untyped) -> String
+    def component_frame(registration, snapshot, rendered)
+      target = DomIdentity.component(
+        registration.reference,
+        registration.component_name
+      )
+      revision = "#{snapshot.instance_id}:#{snapshot.revision}"
+      %(<turbo-frame id="#{target}" data-solid-objects-revision="#{revision}">#{rendered}</turbo-frame>).html_safe
+    end
+  end
+end

data/app/helpers/solid_objects/actor_helper.rb

@@ -9,11 +9,20 @@ module SolidObjects
         view_context: self,
         authorization_context:
       )
-      subscription = tag.turbo_cable_stream_source(
-        channel: "SolidObjects::ActorChannel",
-        token: StreamToken.generate(reference)
-      )
       content = capture(actor, &block)
+      subscription_attributes = {
+        channel: "SolidObjects::ActorChannel",
+        token: StreamToken.generate(
+          reference,
+          observables: actor.scalar_observable_names
+        )
+      }
+      if actor.component_tokens.any?
+        subscription_attributes[:data] = {
+          components: JSON.generate(actor.component_tokens)
+        }
+      end
+      subscription = tag.turbo_cable_stream_source(**subscription_attributes)
 
       content_tag(
         :div,

data/config/routes.rb

@@ -1,6 +1,7 @@
 # rbs_inline: enabled
 
 SolidObjects::Engine.routes.draw do
+  get :components, to: "components#show"
   resources :instances, only: %i[index show]
   resources :dead_letters, only: %i[index] do
     post :retry, on: :member

data/db/migrate/20260806000000_add_state_revision_to_solid_objects_instances.rb

@@ -0,0 +1,12 @@
+# rbs_inline: enabled
+
+class AddStateRevisionToSolidObjectsInstances < ActiveRecord::Migration[8.0]
+  # @rbs () -> void
+  def change
+    add_column SolidObjects.table_name(:instances),
+      :state_revision,
+      :bigint,
+      null: false,
+      default: 0
+  end
+end