openui-rails 0.2.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5999111a7f7f05fa709fd9e247a29d54cb817e07d6152caeac3413ac0eb82655
-  data.tar.gz: 530bcdc1b2c261e49cb8db318f330dc9c31dc7d9fbb9b7e9cc48d8ead04edd2b
+  metadata.gz: 1fd5862a42a9eaf7c669e6e94fa38d8aaac1784e4f7efe5340e9cec48756902a
+  data.tar.gz: f7ada4e9693c3de0c0d13b05a7cc7692a44b402b291721d430038a68c6047f4c
 SHA512:
-  metadata.gz: 4018f00dba918786dc8d3addbb96209fe055c09b84bf1bbae7f595fad3f114cd25a58b54ef0cccb0bac349865871ba98b43fd7fab240448d3639582d7d84b9d3
-  data.tar.gz: ae6065874f65fe3e37e4133322bf698c4c90a74e4126b2efcc4f3c94df51dac927ea89ec403159d466a84f348d67d29b0a70345b4642f7b08dae64690d07b5f9
+  metadata.gz: 0dc08e62c9508a13e11fa3d4995717d6b88be85458d505da3c363bccbfa1b57a1017bc59d72d667ed3d8043eb68f1005cd18b77bc87bae3ac9df0d2fe4683017
+  data.tar.gz: 524eb2239e400a15e6e0dee14d98b5d71e0a6f94866e4bfafda48917ea17f55a18a9eda9126cb13d7a7e4e149bd3ecfaa4f755ebac32f4ba2ca99d9b18db1d01

data/CHANGELOG.md

@@ -6,6 +6,46 @@ adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+## [0.4.0] - 2026-10-20
+
+### Added
+
+- Optional `Actions::Idempotency::ActiveRecordStore` with atomic database claims,
+  ownership fencing, JSON result persistence, and explicit expiry cleanup.
+  SQLite is the verified database; memory remains the default.
+- `openui:idempotency` generates the opt-in table and its unique key and expiry
+  indexes. Installing the engine alone creates no shared-store table.
+- Reusable Minitest store-conformance checks, independent-process SQLite tests,
+  and a fresh-host migration and restart check against the built gem.
+
+### Changed
+
+- The support-desk reference uses the shared store while retaining its business
+  uniqueness constraint. A shared claim does not guarantee exactly-once effects.
+
+## [0.3.0] - 2026-10-19
+
+### Added
+
+- A packaged, opt-in support-ticket reference host with SQLite persistence,
+  importmap, HTTP Turbo Streams, real Query/Mutation calls, host-owned
+  conversation continuation, and scoped snapshot recovery.
+- `bin/check-reference` verifies the maintained host or a fresh host using only
+  the built artifact. Browser checks cover reload, lost envelopes, expired
+  identity, cross-tenant access, read-only roles, stale/duplicate actions, CSRF,
+  keyboard activation, and mobile layout. The reference host enables CSRF
+  itself, including during the documented test-environment review session.
+- `bin/check-release --candidate` validates unpublished candidate metadata
+  without weakening the publication gate.
+- `Surface` and `openui_surface` accept persisted `next_sequence` and
+  `completed` values to restore stream ordering after a page reload.
+
+### Fixed
+
+- Conversation actions preserve the official runtime's user message, form name,
+  and form state as validated-by-host action arguments. Strict
+  `continue_conversation` schemas need to allow the metadata they consume.
+
 ## [0.2.0] - 2026-10-18
 
 ### Added
@@ -93,6 +133,8 @@ adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 - Gem-scoped RubyGems Trusted Publishing through GitHub OIDC, with a protected
   release environment and verified artifact handoff.
 
-[Unreleased]: https://github.com/yorzi/openui-rails/compare/v0.2.0...main
+[Unreleased]: https://github.com/yorzi/openui-rails/compare/v0.4.0...main
+[0.4.0]: https://github.com/yorzi/openui-rails/releases/tag/v0.4.0
+[0.3.0]: https://github.com/yorzi/openui-rails/releases/tag/v0.3.0
 [0.2.0]: https://github.com/yorzi/openui-rails/releases/tag/v0.2.0
 [0.1.0]: https://github.com/yorzi/openui-rails/releases/tag/v0.1.0

data/CONTRIBUTING.md

@@ -25,7 +25,7 @@ bundle exec bin/rails test        # unit + integration tests
 bundle exec bin/rails test:system # browser (system) tests, needs Chrome
 bundle exec rubocop               # style (rubocop-rails-omakase)
 bundle exec gem build openui-rails.gemspec
-bundle exec ruby bin/smoke-package openui-rails-0.2.0.gem
+bundle exec ruby bin/smoke-package openui-rails-0.4.0.gem
 bundle exec bundler-audit check --update
 bundle exec ruby -Itest test/compatibility/ruby_llm_smoke.rb
 ```

data/DEVELOPMENT.md

@@ -12,6 +12,27 @@ authorizes a live call. Follow this loop for each feature:
 5. Commit a completed unit with its actual verification results. Stop any
    task-owned service before finishing.
 
+## Reference workflow
+
+```sh
+bin/check-reference
+bin/check-reference --runtime tmp/real-runtime
+bin/check-reference --gem tmp/package/openui-rails-0.4.0.gem --runtime tmp/real-runtime
+# Focus one browser scenario:
+bin/check-reference --runtime tmp/real-runtime --name test_a_lost_turbo_envelope_recovers_from_the_scoped_snapshot
+```
+
+The first command verifies reference-host transactions in a temporary SQLite
+database. The browser option uses the real renderer and screenshot evidence.
+The gem option generates an isolated consumer using the example packaged in
+that artifact; it imports no dummy-app fixtures. `bin/check --runtime` includes
+this consumer flow. CI runs the host transaction tests in its Ruby/Rails matrix
+and the artifact browser flow in the system job.
+
+Add `--host tmp/support-desk` with `--gem` to retain a synthetic review host.
+It refuses existing directories and starts no persistent service. Follow the
+site's Reference Workflow guide for its explicit loopback review command.
+
 ## Checks
 
 ```sh

data/README.md

@@ -22,8 +22,8 @@ or renderer.
 - One allowlisted action endpoint with authorization, validation, and replay protection.
 - An optional RubyLLM streaming adapter.
 
-Your app supplies scoped record lookup, stream subscriptions, snapshot recovery,
-and shared idempotency storage when running multiple processes.
+Your app supplies scoped record lookup, stream subscriptions, and snapshot
+recovery. Multi-process apps can opt into the SQLite shared idempotency store.
 
 ## Get started
 
@@ -32,7 +32,7 @@ The runtime-fetch task also needs npm. RubyLLM is optional.
 
 ```ruby
 # Gemfile
-gem "openui-rails", "~> 0.2.0"
+gem "openui-rails", "~> 0.4.0"
 ```
 
 ```sh
@@ -65,14 +65,15 @@ The documentation site contains the full guides and API reference:
 - [RubyLLM](https://openui-rails.wangyaodi.com/ruby-llm/) and [production setup](https://openui-rails.wangyaodi.com/production/)
 - [Upgrading](https://openui-rails.wangyaodi.com/upgrading/) and [API reference](https://openui-rails.wangyaodi.com/api-reference/)
 
-Version `0.2.0` adds default-library preparation and setup diagnostics.
+Version `0.4.0` adds optional shared replay storage for Rails workers.
+See [What's New](https://openui-rails.wangyaodi.com/whats-new-in-0-4/) for the upgrade.
 The API may change during `0.x`; see the
 [changelog](CHANGELOG.md) and the proposed [path to 1.0](ROADMAP.md).
 The site's stable channel follows the latest release; [/next/](https://openui-rails.wangyaodi.com/next/)
 follows `main`.
 
 For repository work, use [Contributing](CONTRIBUTING.md),
-[Releasing](RELEASING.md), and the dated [0.1.0 audit](AUDIT.md).
+[Releasing](RELEASING.md), and the [0.3.0 release record](RELEASE_0_3.md).
 Report vulnerabilities through the [security policy](SECURITY.md).
 
 ## License

data/RELEASING.md

@@ -34,6 +34,13 @@ and a 16-token output cap. See [AUDIT.md](AUDIT.md) for the result and limits.
 
 ## Prepare the candidate
 
+During development, keep `released: false`, document delivered work under
+`Unreleased`, and run `ruby bin/check-release --candidate`. This confirms
+candidate metadata without authorizing or satisfying the publication gate.
+The candidate must pass the full verification and built-gem reference flow.
+After publication is authorized, complete the release metadata steps below.
+
+
 1. Set the version in `lib/openui/rails/version.rb`.
 2. Add a dated `## [x.y.z] - YYYY-MM-DD` changelog section.
    Set the same version and `released: true` in `docs/_config.yml`, update
@@ -86,6 +93,11 @@ and both channels include the matching setup and upgrading guides. Record
 the workflow, published gem checksum, and hosted verification in a dated
 release record. Keep earlier local validation evidence unchanged.
 
+A successful Pages job alone does not prove the hosted version changed.
+If the stable site still serves the previous release, compare its contents with
+the build log. Push a documentation update or rerun the docs workflow, then
+verify the actual installation command and version selector again.
+
 ## Recovery
 
 Prefer a patch release for a defect. If a published version is unsafe, the owner

data/app/javascript/openui/rails/openui_controller.js

@@ -226,7 +226,7 @@ export default class extends Controller {
   async dispatchAction(payload = {}) {
     const body = {
       action: payload.action ?? payload.name ?? payload.type,
-      args: payload.args ?? payload.params ?? {},
+      args: this.actionArguments(payload),
       surface_id: this.surfaceId,
       version: this.version,
       idempotency_key: payload.idempotency_key ?? this.newIdempotencyKey(),
@@ -268,6 +268,19 @@ export default class extends Controller {
     }
   }
 
+  // The official renderer places conversation metadata beside params. Keep
+  // it in the allowlisted action's args so the host can validate and persist it.
+  actionArguments(payload) {
+    const args = payload.args ?? payload.params ?? {}
+    if ((payload.action ?? payload.name ?? payload.type) !== "continue_conversation") return args
+    if (typeof args !== "object" || Array.isArray(args)) return args
+    const metadata = {}
+    if (payload.humanFriendlyMessage !== undefined) metadata.message = payload.humanFriendlyMessage
+    if (payload.formState !== undefined) metadata.form_state = payload.formState
+    if (payload.formName !== undefined) metadata.form_name = payload.formName
+    return { ...args, ...metadata }
+  }
+
   // Every browser `Query()`/`Mutation()` tool call is routed to the same
   // server endpoint; the host registry decides what is permitted.
   toolProvider() {

data/examples/support_desk/README.md

@@ -0,0 +1,20 @@
+# Support Desk reference host
+
+This opt-in reference belongs to the host application, outside the engine's
+public API. It uses synthetic accounts, recorded generation, the real pinned
+OpenUI runtime, SQLite, importmap, and HTTP Turbo Streams. It opts into the
+Active Record idempotency store and retains a unique business receipt for closing
+a ticket. Shared claims do not replace that database constraint.
+
+From the repository:
+
+```sh
+mkdir -p tmp/package
+bundle exec gem build openui-rails.gemspec --output tmp/package/openui-rails-0.4.0.gem
+bin/check-reference --gem tmp/package/openui-rails-0.4.0.gem --runtime tmp/real-runtime
+```
+
+Fetch the runtime first. See the [complete guide](https://openui-rails.wangyaodi.com/reference-workflow/)
+for setup, retained-host review, failure checks, and evidence limits. The
+reference is not enabled by requiring the gem. Keep the demo loopback-only;
+replace its synthetic login before adapting it to a real application.

data/examples/support_desk/app/controllers/support_desk/base_controller.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module SupportDesk # :nodoc:
+  class BaseController < ::ApplicationController
+    protect_from_forgery with: :exception
+    layout "support_desk/application"
+    before_action :local_demo_only
+    before_action :authenticate
+    rescue_from ActiveRecord::RecordNotFound do
+      render json: { error: { code: "not_found", message: "inaccessible conversation" } }, status: :not_found
+    end
+    rescue_from OpenUI::Rails::Error do |error|
+      status = error.is_a?(OpenUI::Rails::StaleSurfaceError) ? :conflict : :unprocessable_content
+      code = error.is_a?(OpenUI::Rails::StaleSurfaceError) ? "stale_surface" : "invalid_state"
+      render json: { error: { code: code, message: "request rejected" } }, status: status
+    end
+
+    private
+
+    def current_actor
+      @current_actor ||= User.find_by(id: session[:support_desk_user_id])
+    end
+    helper_method :current_actor
+
+    def local_demo_only
+      head :forbidden unless [ "127.0.0.1", "::1" ].include?(request.remote_ip)
+    end
+
+    def authenticate
+      render json: { error: { code: "unauthorized", message: "sign in to the local demo" } }, status: :unauthorized unless current_actor
+    end
+
+    def conversation
+      @conversation ||= Conversation.find_by!(id: params[:id], user_id: current_actor.id, tenant_id: current_actor.tenant_id)
+    end
+  end
+end

data/examples/support_desk/app/controllers/support_desk/conversations_controller.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module SupportDesk # :nodoc:
+  class ConversationsController < BaseController
+    # The state endpoint uses an explicit top-level JSON contract.
+    wrap_parameters false
+    skip_before_action :authenticate, only: :index
+
+    def index
+    end
+
+    def show
+      conversation
+    end
+
+    def stream
+      frames = conversation.generate!
+      transport = OpenUI::Rails::Stream::Transports::TurboStreams.new("unused", target: "desk-envelopes")
+      response.headers["Content-Type"] = "text/vnd.turbo-stream.html; charset=utf-8"
+      response.headers["Cache-Control"] = "no-store"
+      self.response_body = Enumerator.new do |body|
+        frames.each do |frame|
+          body << %(<turbo-stream action="append" target="desk-envelopes"><template>#{transport.element(frame)}</template></turbo-stream>\n)
+        end
+      end
+    end
+
+    def snapshot
+      if conversation.response.empty?
+        head :conflict
+      else
+        render json: conversation.snapshot.to_h
+      end
+    end
+
+    def state
+      record = conversation
+      body = request.request_parameters
+      unless (body.keys - %w[state version]).empty? && body["version"].is_a?(Integer) && body["version"] >= 0
+        raise OpenUI::Rails::InvalidActionError, "invalid state request"
+      end
+
+      record.save_form!(body["state"], expected_version: body["version"])
+      head :no_content
+    end
+  end
+end

data/examples/support_desk/app/controllers/support_desk/sessions_controller.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module SupportDesk # :nodoc:
+  class SessionsController < BaseController
+    skip_before_action :authenticate
+
+    def create
+      user = User.find_by!(name: params[:name])
+      reset_session
+      session[:support_desk_user_id] = user.id
+      redirect_to conversation_path(Conversation.find_by!(user_id: user.id))
+    end
+
+    def destroy
+      reset_session
+      redirect_to root_path
+    end
+  end
+end

data/examples/support_desk/app/javascript/support_desk.js

@@ -0,0 +1,109 @@
+import { Application, Controller } from "@hotwired/stimulus"
+import "@hotwired/turbo-rails"
+import OpenUIController from "openui/rails/openui_controller"
+import EnvelopeController from "openui/rails/openui_envelope_controller"
+
+class SupportDeskController extends Controller {
+  connect() {
+    this.abort = new AbortController()
+    this.saves = Promise.resolve()
+    this.lastState = null
+    if (this.surface.dataset.openuiStreaming === "true") this.stream().catch(error => this.failure(error))
+  }
+
+  disconnect() { this.abort.abort() }
+  get surface() { return this.element.querySelector("[data-controller='openui']") }
+  get status() { return this.element.querySelector("#desk-status") }
+
+  headers() {
+    return { "Content-Type": "application/json", "X-CSRF-Token": document.querySelector("meta[name='csrf-token']").content }
+  }
+
+  async checked(response) {
+    if (response.redirected || !response.ok) throw new Error(response.status === 401 || response.status === 403 ? "Session expired. Sign in again." : "Request rejected. Reload the conversation.")
+    return response
+  }
+
+  // Consume newline-delimited Turbo Stream elements as response chunks arrive.
+  // Authorization and canonical response persistence happen before delivery.
+  async stream() {
+    const response = await this.checked(await fetch(this.element.dataset.supportDeskStreamUrl, {
+      method: "POST", headers: this.headers(), signal: this.abort.signal, credentials: "same-origin"
+    }))
+    const reader = response.body.getReader()
+    const decoder = new TextDecoder()
+    let pending = ""
+    try {
+      while (true) {
+        const { value, done } = await reader.read()
+        pending += decoder.decode(value, { stream: !done })
+        let end
+        while ((end = pending.indexOf("\n")) >= 0) {
+          window.Turbo.renderStreamMessage(pending.slice(0, end))
+          pending = pending.slice(end + 1)
+        }
+        if (done) break
+      }
+      if (pending.trim()) throw new Error("Incomplete stream. Reload the conversation.")
+      this.status.textContent = "Response loaded"
+    } finally {
+      await reader.cancel().catch(() => {})
+    }
+  }
+
+  async recover() {
+    if (this.recovering) return
+    this.recovering = true
+    try {
+      const response = await this.checked(await fetch(this.element.dataset.supportDeskSnapshotUrl, {
+        headers: { Accept: "application/json" }, signal: this.abort.signal, credentials: "same-origin"
+      }))
+      const envelope = await response.json()
+      this.surface.dispatchEvent(new CustomEvent("openui:envelope", { bubbles: true, detail: envelope }))
+      this.element.dataset.recovered = "true"
+      this.status.textContent = "Recovered from a missing update"
+    } catch (error) { this.failure(error) }
+    finally { this.recovering = false }
+  }
+
+  saveState(event) {
+    const note = event.detail.state?.reply?.note
+    if (!note || typeof note.value !== "string") return
+    const state = { reply: { note: { value: note.value, componentType: "Input" } } }
+    const serialized = JSON.stringify(state)
+    if (this.lastState === serialized) return
+    this.lastState = serialized
+    this.status.textContent = "Saving draft"
+    const version = Number(this.surface.dataset.openuiVersion)
+    this.saves = this.saves.then(async () => {
+      await this.checked(await fetch(this.element.dataset.supportDeskStateUrl, {
+        method: "PATCH", headers: this.headers(), credentials: "same-origin", signal: this.abort.signal,
+        body: JSON.stringify({ state, version })
+      }))
+      if (this.lastState === serialized) this.status.textContent = "Draft saved"
+    }).catch(error => this.failure(error))
+  }
+
+  async action(event) {
+    if (!["continue_conversation", "close_ticket"].includes(event.detail.result.action)) return
+    await this.saves
+    window.location.reload()
+  }
+
+  error(event) {
+    if (["unauthorized", "csrf_failed"].includes(event.detail.code)) {
+      this.denied = true
+      this.failure(new Error("Action not permitted. Sign in again."))
+    } else if (!this.denied) {
+      this.failure(new Error(event.detail.message || "Unable to render this response."))
+    }
+  }
+  failure(error) {
+    if (error.name !== "AbortError") this.element.querySelector("#desk-error").textContent = error.message
+  }
+}
+
+const application = Application.start()
+application.register("support-desk", SupportDeskController)
+application.register("openui", OpenUIController)
+application.register("openui-envelope", EnvelopeController)

data/examples/support_desk/app/models/support_desk/conversation.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module SupportDesk # :nodoc:
+  # Host-owned state and business transactions, outside the gem's public API.
+  class Conversation < ActiveRecord::Base
+    belongs_to :user
+    belongs_to :ticket
+
+    def message_id = "desk-#{id}-turn-#{version}"
+
+    def surface
+      OpenUI::Rails::Surface.new(
+        id: id, version: version, message_id: message_id, response: response,
+        library_version: OpenUI::Rails.configuration.library_fingerprint,
+        next_sequence: next_sequence, completed: response.present?, streaming: response.empty?, context: form_state
+      )
+    end
+
+    # Persist canonical output before delivery. A disconnect cannot erase it.
+    # This deterministic fixture substitutes for a provider, not for the renderer.
+    def generate!
+      with_lock do
+        return [ snapshot ] if response.present?
+
+        controls = if ticket.reload.status == "closed"
+          'TextContent("Ticket is closed")'
+        else
+          'Buttons([Button("Close ticket", @Run(close))])'
+        end
+        source = <<~LANG
+          ticket = Query("ticket_lookup", {}, {title: "Loading ticket", status: "loading"})
+          close = Mutation("close_ticket", {})
+          note = FormControl("Private note", Input("note", "Write a note"))
+          replyButtons = Buttons([Button("Continue conversation", @ToAssistant("Review this ticket"))])
+          reply = Form("reply", replyButtons, [note])
+          controls = #{controls}
+          root = Card([CardHeader("Support ticket"), TextContent(ticket.title), TextContent(ticket.status), TextContent("Conversation turns: #{messages.length}"), reply, controls])
+        LANG
+        config = OpenUI::Rails::Configuration.new
+        config.pending_byte_limit = 1
+        frames = OpenUI::Rails::Stream::Bridge.new(message_id: message_id,
+          library_version: OpenUI::Rails.configuration.library_fingerprint, configuration: config).envelopes(source.lines).to_a
+        update!(response: source, next_sequence: frames.last.sequence + 1)
+        frames
+      end
+    end
+
+    def snapshot
+      OpenUI::Rails::Stream::Envelope.snapshot(message_id: message_id,
+        sequence: next_sequence - 1, response: response,
+        library_version: OpenUI::Rails.configuration.library_fingerprint)
+    end
+
+    def self.valid_form_state?(state)
+      state.is_a?(Hash) &&
+        (state.keys - [ "reply" ]).empty? && state.values.all? { |fields|
+          fields.is_a?(Hash) && (fields.keys - [ "note" ]).empty? && fields.values.all? { |field|
+            field.is_a?(Hash) && (field.keys - %w[value componentType]).empty? &&
+              field["value"].is_a?(String) && field["value"].bytesize <= 2000 &&
+              (!field.key?("componentType") || field["componentType"] == "Input")
+          }
+        } && JSON.generate(state).bytesize <= 4096
+    end
+
+    def save_form!(state, expected_version:)
+      raise OpenUI::Rails::InvalidActionError, "invalid note state" unless self.class.valid_form_state?(state)
+
+      with_lock do
+        check_version!(expected_version)
+        update!(form_state: state)
+      end
+    end
+
+    def close_ticket!(invocation)
+      with_lock do
+        check_version!(invocation.submission.version)
+        raise OpenUI::Rails::InvalidActionError, "ticket is already closed" if ticket.reload.status == "closed"
+
+        Receipt.create!(ticket_id: ticket_id, operation: "close")
+        ticket.update!(status: "closed")
+        advance!
+      end
+      { "version" => version, "status" => "closed" }
+    end
+
+    def continue!(invocation)
+      with_lock do
+        check_version!(invocation.submission.version)
+        raise OpenUI::Rails::InvalidActionError, "demo turn limit reached" if messages.length >= 20
+
+        update!(messages: messages + [ { "role" => "user", "text" => invocation.args.fetch("message") } ],
+          form_state: invocation.args.fetch("form_state", form_state))
+        advance!
+      end
+      { "version" => version }
+    end
+
+    private
+
+    def check_version!(expected)
+      raise OpenUI::Rails::StaleSurfaceError, "conversation changed; reload it" unless version == expected
+    end
+
+    def advance!
+      update!(version: version + 1, response: "", next_sequence: 0)
+    end
+  end
+end

data/examples/support_desk/app/models/support_desk/demo.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module SupportDesk # :nodoc:
+  class Demo
+    def self.seed!
+      [ [ "Alice", "north", "agent" ], [ "Bob", "south", "agent" ], [ "Reader", "north", "reader" ] ].each do |name, tenant, role|
+        user = User.find_or_create_by!(name: name) { |record| record.tenant_id = tenant; record.role = role }
+        next if Conversation.exists?(user_id: user.id)
+
+        ticket = Ticket.create!(tenant_id: tenant, title: "#{tenant.capitalize} delivery question")
+        Conversation.create!(user: user, ticket: ticket, tenant_id: tenant)
+      end
+    end
+  end
+end

data/examples/support_desk/app/models/support_desk/receipt.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module SupportDesk # :nodoc:
+  class Receipt < ActiveRecord::Base
+  end
+end

data/examples/support_desk/app/models/support_desk/ticket.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module SupportDesk # :nodoc:
+  class Ticket < ActiveRecord::Base
+  end
+end

data/examples/support_desk/app/models/support_desk/user.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module SupportDesk # :nodoc:
+  class User < ActiveRecord::Base
+  end
+end

data/examples/support_desk/app/views/layouts/support_desk/application.html.erb

@@ -0,0 +1,18 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <title>Support Desk · OpenUI Rails reference</title>
+    <meta name="viewport" content="width=device-width,initial-scale=1">
+    <%= csrf_meta_tags %>
+    <%= openui_stylesheet_tag %>
+    <%= javascript_importmap_tags "support_desk" %>
+    <style>
+      body { margin: 0; padding: 24px; font: 16px/1.6 system-ui; background: #f6f7f9; color: #17202a; }
+      main { max-width: 800px; margin: auto; } h1 { font-size: 28px; } button { cursor: pointer; }
+      header { display: flex; gap: 16px; align-items: center; flex-wrap: wrap; }
+      .notice { padding: 12px; background: #fff3cf; border-radius: 8px; }
+      [role="alert"] { color: #a11; } .openui-surface { background: white; padding: 16px; border-radius: 12px; }
+    </style>
+  </head>
+  <body><main><%= yield %></main></body>
+</html>

data/examples/support_desk/app/views/support_desk/conversations/index.html.erb

@@ -0,0 +1,6 @@
+<h1>Support Desk reference host</h1>
+<p class="notice">Synthetic accounts and tickets. Local demo only. No model provider is called.</p>
+<p>Sign in to stream a ticket, save a private draft, continue the conversation, and close the ticket.</p>
+<% %w[Alice Bob Reader].each do |name| %>
+  <%= button_to "Sign in as #{name}", session_path, params: { name: name } %>
+<% end %>

data/examples/support_desk/app/views/support_desk/conversations/show.html.erb

@@ -0,0 +1,16 @@
+<header>
+  <h1>Support Desk</h1>
+  <span><%= current_actor.name %> · <%= current_actor.tenant_id %> tenant</span>
+  <%= button_to "Sign out", session_path, method: :delete %>
+</header>
+<p class="notice">Recorded response, real OpenUI runtime. Your Rails host owns the ticket and conversation.</p>
+<section data-controller="support-desk"
+         data-support-desk-stream-url="<%= stream_conversation_path(@conversation) %>"
+         data-support-desk-snapshot-url="<%= snapshot_conversation_path(@conversation) %>"
+         data-support-desk-state-url="<%= state_conversation_path(@conversation) %>"
+         data-action="openui:state->support-desk#saveState openui:snapshot-required->support-desk#recover openui:action->support-desk#action openui:error->support-desk#error">
+  <%= openui_surface(surface: @conversation.surface, label: "Support ticket") %>
+  <div id="desk-envelopes" hidden></div>
+  <p role="status" id="desk-status">Ready</p>
+  <p role="alert" id="desk-error"></p>
+</section>

data/examples/support_desk/boot.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+# Explicitly loaded by the reference host. Never loaded by require "openui/rails".
+module SupportDesk # :nodoc:
+  class Engine < ::Rails::Engine
+    isolate_namespace SupportDesk
+    engine_name "support_desk"
+    config.root = File.expand_path(__dir__)
+
+    # The documented local review uses RAILS_ENV=test. Keep the reference's
+    # form tags and the shared action endpoint protected in that environment too.
+    initializer "support_desk.csrf", before: "action_controller.set_configs" do |app|
+      app.config.action_controller.allow_forgery_protection = true
+    end
+
+    initializer "support_desk.assets", before: "importmap" do |app|
+      app.config.assets.paths << root.join("app/javascript")
+      app.config.importmap.paths << root.join("config/importmap.rb")
+    end
+  end
+end

data/examples/support_desk/config/importmap.rb

@@ -0,0 +1,4 @@
+pin "support_desk", to: "support_desk.js"
+pin "@hotwired/turbo-rails", to: "turbo.min.js"
+pin "@hotwired/stimulus", to: "stimulus.min.js"
+pin_all_from OpenUI::Rails::Engine.root.join("app/javascript/openui"), under: "openui"

data/examples/support_desk/config/initializers/openui.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+OpenUI::Rails.configure do |config|
+  library = ENV.fetch("OPENUI_REFERENCE_LIBRARY_DIR") { Rails.root.join("config/openui") }
+  config.library_spec_path = File.join(library, "library.spec.json")
+  config.prompt_path = File.join(library, "library.prompt.txt")
+  config.actor_resolver = ->(controller) { SupportDesk::User.find_by(id: controller.session[:support_desk_user_id]) }
+  config.surface_resolver = ->(id, actor:, **) {
+    SupportDesk::Conversation.find_by(id: id, user_id: actor.id, tenant_id: actor.tenant_id) if actor
+  }
+  config.idempotency_store = OpenUI::Rails::Actions::Idempotency::ActiveRecordStore.new
+  config.idempotency_scope = ->(invocation) { [ invocation.actor.tenant_id, invocation.actor.id ] }
+  config.authorize_action = ->(invocation) {
+    actor, conversation = invocation.actor, invocation.surface
+    actor && conversation && conversation.user_id == actor.id && conversation.tenant_id == actor.tenant_id &&
+      (invocation.action == "ticket_lookup" || actor.role == "agent")
+  }
+end
+OpenUI::Rails.actions.register "ticket_lookup", schema: {}, handler: ->(invocation) {
+  ticket = invocation.surface.ticket
+  { "title" => ticket.title, "status" => ticket.status }
+}
+OpenUI::Rails.actions.register "close_ticket", schema: {}, handler: ->(invocation) {
+  invocation.surface.close_ticket!(invocation)
+}
+OpenUI::Rails.actions.register "continue_conversation",
+  schema: ->(args) {
+    (args.keys - %w[message context form_name form_state]).empty? &&
+      args["message"].is_a?(String) && args["message"].bytesize.between?(1, 1000) &&
+      (!args.key?("context") || args["context"].is_a?(String) && args["context"].bytesize <= 1000) &&
+      (!args.key?("form_name") || args["form_name"] == "reply") &&
+      (!args.key?("form_state") || SupportDesk::Conversation.valid_form_state?(args["form_state"]))
+  }, handler: ->(invocation) { invocation.surface.continue!(invocation) }

data/examples/support_desk/config/routes.rb

@@ -0,0 +1,12 @@
+SupportDesk::Engine.routes.draw do
+  root "conversations#index"
+  post "/session", to: "sessions#create"
+  delete "/session", to: "sessions#destroy"
+  resources :conversations, only: [ :show ] do
+    member do
+      post :stream
+      get :snapshot
+      patch :state
+    end
+  end
+end

data/examples/support_desk/db/migrate/20261019000000_create_support_desk.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+class CreateSupportDesk < ActiveRecord::Migration[8.0] # :nodoc:
+  def change
+    create_table :support_desk_users do |t|
+      t.string :name, null: false
+      t.string :tenant_id, null: false
+      t.string :role, null: false
+    end
+    add_index :support_desk_users, :name, unique: true
+    create_table :support_desk_tickets do |t|
+      t.string :tenant_id, null: false
+      t.string :title, null: false
+      t.string :status, null: false, default: "open"
+    end
+    create_table :support_desk_conversations do |t|
+      t.references :user, null: false, foreign_key: { to_table: :support_desk_users }
+      t.references :ticket, null: false, foreign_key: { to_table: :support_desk_tickets }
+      t.string :tenant_id, null: false
+      t.integer :version, null: false, default: 0
+      t.text :response, null: false, default: ""
+      t.integer :next_sequence, null: false, default: 0
+      t.json :form_state, null: false, default: {}
+      t.json :messages, null: false, default: []
+    end
+    create_table :support_desk_receipts do |t|
+      t.references :ticket, null: false, foreign_key: { to_table: :support_desk_tickets }
+      t.string :operation, null: false
+    end
+    # Domain-level guard survives a process restart and idempotency-store expiry.
+    add_index :support_desk_receipts, [ :ticket_id, :operation ], unique: true
+  end
+end

data/examples/support_desk/install.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# Explicit reference-host wiring, not a generator and not a general installer.
+require "fileutils"
+root = File.realpath(ARGV.fetch(0, Dir.pwd))
+application = File.join(root, "config/application.rb")
+source = File.read(application)
+marker = "Bundler.require(*Rails.groups)"
+abort "expected a generated full-stack Rails host" unless source.include?(marker)
+line = 'require File.join(Gem.loaded_specs.fetch("openui-rails").full_gem_path, "examples/support_desk/boot")'
+File.write(application, source.sub(marker, "#{marker}\n#{line}")) unless source.include?(line)
+routes = File.join(root, "config/routes.rb")
+route = 'Rails.application.routes.draw { mount SupportDesk::Engine => "/support" }'
+File.open(routes, "a") { |file| file.puts route } unless File.read(routes).include?("SupportDesk::Engine")
+puts "Reference host wired. Install migrations, prepare the default library/runtime, and seed synthetic records as documented."

data/lib/generators/openui/idempotency/idempotency_generator.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "rails/generators/active_record"
+
+module OpenUI
+  # Generate the opt-in shared action-claim table without changing configuration.
+  class IdempotencyGenerator < ::ActiveRecord::Generators::Base
+    namespace "openui:idempotency"
+    source_root File.expand_path("templates", __dir__)
+    desc "Create the optional OpenUI shared idempotency store migration."
+    # This generator has no model-name argument.
+    argument :name, type: :string, default: "openui_action_claims", hide: true
+
+    # Write the optional, reversible host migration.
+    def create_store_migration
+      migration_template "create_openui_action_claims.rb", "db/migrate/create_openui_action_claims.rb"
+    end
+  end
+end

data/lib/generators/openui/idempotency/templates/create_openui_action_claims.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+class CreateOpenUIActionClaims < ActiveRecord::Migration[8.0]
+  def change
+    create_table :openui_action_claims do |t|
+      t.string :key, null: false
+      t.string :digest
+      t.string :claim_token, null: false
+      t.boolean :completed, null: false, default: false
+      t.text :result_json
+      t.datetime :expires_at, null: false, precision: 6
+    end
+    add_index :openui_action_claims, :key, unique: true
+    add_index :openui_action_claims, :expires_at
+  end
+end

data/lib/generators/openui/install/templates/config/initializers/openui.rb.tt

@@ -14,6 +14,10 @@ OpenUI::Rails.configure do |config|
   config.runtime_assets = :self_hosted
   # config.runtime_integrity = "sha384-..."
 
+  # Optional shared SQLite claims: first run openui:idempotency and db:migrate.
+  # See the Shared Idempotency Storage guide for JSON results and crash limits.
+  # config.idempotency_store = OpenUI::Rails::Actions::Idempotency::ActiveRecordStore.new
+
   # Authorize every action/tool call. This fails closed: with no authorizer an
   # action is denied. Return truthy to permit.
   # config.authorize_action = ->(invocation) do

data/lib/openui/rails/actions/idempotency/active_record_store.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require "active_record"
+require "json"
+require "securerandom"
+
+module OpenUI
+  module Rails
+    module Actions
+      module Idempotency
+        # Optional shared action store. Verified with SQLite on Rails 8.0/8.1.
+        # Install its table with `rails generate openui:idempotency` and db:migrate.
+        # JSON values replay across workers; object keys become strings. TTL runs
+        # from claim creation, not completion. Never assumes exactly-once effects.
+        class ActiveRecordStore
+          class Entry < ::ActiveRecord::Base # :nodoc:
+            self.table_name = "openui_action_claims"
+          end
+          private_constant :Entry
+
+          # @param model [Class] dedicated Active Record model, optionally using another database
+          # @param clock [#call] shared wall clock returning UTC Time values
+          def initialize(model: Entry, clock: -> { Time.now.utc })
+            @model = model
+            @clock = clock
+          end
+
+          # Atomically insert or replace an expired claim. Returns the same
+          # [status, result, stored_digest, token] contract as MemoryStore.
+          # A changed digest is returned to the dispatcher, which rejects it.
+          def claim(key, ttl:, digest: nil)
+            raise ConfigurationError, "idempotency ttl must be positive" unless ttl.is_a?(Numeric) && ttl.finite? && ttl > 0
+
+            loop do
+              now = @clock.call
+              attributes = { key: key, digest: digest, claim_token: SecureRandom.hex(16),
+                             completed: false, result_json: nil, expires_at: now + ttl }
+              inserted = @model.insert_all([ attributes ], unique_by: :key, returning: %w[id])
+              return [ :claimed, nil, digest, attributes[:claim_token] ] if inserted.any?
+
+              replaced = @model.where(key: key).where("expires_at <= ?", now).update_all(attributes.except(:key))
+              return [ :claimed, nil, digest, attributes[:claim_token] ] if replaced == 1
+
+              # Cleanup can delete the expired row between SQL statements.
+              entry = @model.find_by(key: key)
+              next unless entry
+
+              value = entry.completed ? JSON.parse(entry.result_json) : nil
+              return [ entry.completed ? :replay : :pending, value, entry.digest, entry.claim_token ]
+            end
+          end
+
+          # Record only while this token owns a live claim. JSON encoding rejects
+          # unsupported Ruby objects before writing; it never invokes Marshal.
+          def record(key, result, claim_token:)
+            json = JSON.generate(JsonValue.copy(result))
+            @model.where(key: key, claim_token: claim_token).where("expires_at > ?", @clock.call)
+              .update_all(result_json: json, completed: true)
+            nil
+          rescue ArgumentError, JSON::GeneratorError => error
+            raise ConfigurationError, "idempotency result must be a JSON value: #{error.message}"
+          end
+
+          # Delete expired claims, returning the number removed. Call from a host
+          # maintenance task; expiry of the requested key never needs this sweep.
+          def delete_expired
+            @model.where("expires_at <= ?", @clock.call).delete_all
+          end
+        end
+      end
+    end
+  end
+end

data/lib/openui/rails/actions/idempotency/memory_store.rb

@@ -7,8 +7,8 @@ module OpenUI
     module Actions
       module Idempotency
         # Default, single-process idempotency store. Hosts that run multiple
-        # processes should inject a shared store (e.g. Redis or the database)
-        # that implements the same contract.
+        # processes can opt into ActiveRecordStore on SQLite
+        # or inject another shared adapter implementing the same contract.
         #
         # Contract:
         #   claim(key, ttl:, digest:) -> [status, result, digest, claim_token]

data/lib/openui/rails/actions.rb

@@ -13,6 +13,9 @@ module OpenUI
     # a host authorizer, stale-surface protection and idempotency, shared by
     # both component actions and browser tool calls.
     module Actions
+      module Idempotency
+        autoload :ActiveRecordStore, "openui/rails/actions/idempotency/active_record_store"
+      end
     end
   end
 end

data/lib/openui/rails/surface.rb

@@ -8,10 +8,10 @@ module OpenUI
     # opaque identifier plus the current revision and the source to render.
     # A surface can be built explicitly or coerced from a host record that
     # exposes `id` (and, optionally, `version`, `library_version`, `response`,
-    # `context`, `message_id`).
+    # `context`, `message_id`, `next_sequence`, `completed`).
     class Surface
       # Surface values copied from an explicit object, hash, or host record.
-      ATTRIBUTES = %i[id version library_version response context streaming message_id].freeze
+      ATTRIBUTES = %i[id version library_version response context streaming message_id next_sequence completed].freeze
 
       attr_reader(*ATTRIBUTES)
 
@@ -72,15 +72,28 @@ module OpenUI
       #
       # @param message_id [String, nil] stream identity; defaults to id
       #
+      # @param next_sequence [Integer] next expected envelope sequence after persisted output
+      #
+      # @param completed [Boolean] ignore later non-snapshot envelopes for a terminal response
+      #
       # @return [Surface]
       def initialize(id:, version: 0, library_version: nil, response: nil, context: nil,
-                     streaming: false, message_id: nil)
+                     streaming: false, message_id: nil, next_sequence: 0, completed: false)
         raise ArgumentError, "surface id is required" if id.nil? || id.to_s.empty?
         unless version.nil? || (version.is_a?(Integer) && version >= 0)
           raise ArgumentError, "surface version must be a non-negative Integer"
         end
         raise ArgumentError, "surface response must be a String" unless response.nil? || response.is_a?(String)
 
+        unless next_sequence.is_a?(Integer) && next_sequence.between?(0, 9_007_199_254_740_991)
+          raise ArgumentError, "next_sequence must be a non-negative JavaScript-safe Integer"
+        end
+        unless [ true, false ].include?(completed) && !(completed && streaming)
+          raise ArgumentError, "completed must be boolean and cannot coexist with streaming"
+        end
+
+        @next_sequence = next_sequence
+        @completed = completed
         @id = id.to_s.dup.freeze
         @version = version || 0
         @library_version = library_version&.to_s&.dup&.freeze
@@ -102,7 +115,8 @@ module OpenUI
       def to_h
         {
           id: id, version: version, library_version: library_version,
-          response: response, context: context, streaming: streaming, message_id: message_id
+          response: response, context: context, streaming: streaming, message_id: message_id,
+          next_sequence: next_sequence, completed: completed
         }
       end
 
@@ -124,10 +138,14 @@ module OpenUI
       #
       # @return [Hash] HTML data attributes with string values
       def to_mount_data(stream: false, actions_endpoint:, initial_state: nil)
+        raise ArgumentError, "completed surfaces cannot be mounted as streaming" if completed && stream
+
         {
           controller: "openui",
           openui_surface_id: id,
           openui_message_id: message_id,
+          openui_next_sequence: next_sequence.to_s,
+          openui_completed: completed.to_s,
           openui_version: version.to_s,
           openui_library_version: library_version,
           openui_streaming: (streaming? || stream) ? "true" : "false",

data/lib/openui/rails/testing/idempotency_store_contract.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module OpenUI
+  module Rails
+    module Testing
+      # Reusable Minitest contract for idempotency adapters. Include this module
+      # in a test case that defines build_store and advance_store_clock(seconds).
+      # Each test needs an empty store and a controllable shared clock.
+      module IdempotencyStoreContract
+        def test_claim_distinguishes_pending_from_completed
+          store = build_store
+          status, value, digest, token = store.claim("key", ttl: 60, digest: "original")
+          assert_equal :claimed, status
+          assert_nil value
+          assert_equal "original", digest
+          refute_empty token
+          assert_equal [ :pending, nil, "original", token ], store.claim("key", ttl: 60, digest: "changed")
+          store.record("key", "saved", claim_token: token)
+          assert_equal [ :replay, "saved", "original", token ], store.claim("key", ttl: 60, digest: "changed")
+        end
+
+        def test_completed_nil_and_false_replay
+          store = build_store
+          [ nil, false ].each_with_index do |value, index|
+            key = "nullable-#{index}"
+            token = store.claim(key, ttl: 60, digest: "d").last
+            store.record(key, value, claim_token: token)
+            assert_equal [ :replay, value, "d", token ], store.claim(key, ttl: 60, digest: "d")
+          end
+        end
+
+        def test_json_results_round_trip
+          store = build_store
+          value = { "list" => [ 1, 2.5, true, false, nil, "你好" ], "nested" => { "ok" => true } }
+          token = store.claim("key", ttl: 60, digest: "d").last
+          store.record("key", value, claim_token: token)
+          assert_equal value, store.claim("key", ttl: 60, digest: "d")[1]
+        end
+
+        def test_expired_owner_cannot_record
+          store = build_store
+          token = store.claim("key", ttl: 10, digest: "old").last
+          advance_store_clock(10)
+          store.record("key", "late", claim_token: token)
+          status, value, _, replacement = store.claim("key", ttl: 60, digest: "new")
+          assert_equal :claimed, status
+          assert_nil value
+          refute_equal token, replacement
+        end
+
+        def test_replaced_owner_cannot_overwrite
+          store = build_store
+          old = store.claim("key", ttl: 10, digest: "old").last
+          advance_store_clock(11)
+          token = store.claim("key", ttl: 60, digest: "new").last
+          store.record("key", "new result", claim_token: token)
+          store.record("key", "old result", claim_token: old)
+          assert_equal [ :replay, "new result", "new", token ], store.claim("key", ttl: 60, digest: "new")
+        end
+
+        def test_wrong_token_and_unknown_key_do_not_complete_a_claim
+          store = build_store
+          token = store.claim("key", ttl: 60, digest: "d").last
+          store.record("missing", "value", claim_token: token)
+          store.record("key", "value", claim_token: "wrong")
+          assert_equal :pending, store.claim("key", ttl: 60, digest: "d").first
+          assert_equal :claimed, store.claim("missing", ttl: 60, digest: "d").first
+        end
+
+        def test_ttl_must_be_positive_and_finite
+          store = build_store
+          [ 0, -1, Float::INFINITY, Float::NAN, "60", nil ].each do |ttl|
+            assert_raises(OpenUI::Rails::ConfigurationError) { store.claim("key", ttl: ttl, digest: "d") }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/openui/rails/version.rb

@@ -1,5 +1,5 @@
 module OpenUI
   module Rails
-    VERSION = "0.2.0"
+    VERSION = "0.4.0"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: openui-rails
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Andy Wang
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-10-18 00:00:00.000000000 Z
+date: 2026-10-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -61,12 +61,34 @@ files:
 - app/javascript/openui/rails/openui_controller.js
 - app/javascript/openui/rails/openui_envelope_controller.js
 - config/routes.rb
+- examples/support_desk/README.md
+- examples/support_desk/app/controllers/support_desk/base_controller.rb
+- examples/support_desk/app/controllers/support_desk/conversations_controller.rb
+- examples/support_desk/app/controllers/support_desk/sessions_controller.rb
+- examples/support_desk/app/javascript/support_desk.js
+- examples/support_desk/app/models/support_desk/conversation.rb
+- examples/support_desk/app/models/support_desk/demo.rb
+- examples/support_desk/app/models/support_desk/receipt.rb
+- examples/support_desk/app/models/support_desk/ticket.rb
+- examples/support_desk/app/models/support_desk/user.rb
+- examples/support_desk/app/views/layouts/support_desk/application.html.erb
+- examples/support_desk/app/views/support_desk/conversations/index.html.erb
+- examples/support_desk/app/views/support_desk/conversations/show.html.erb
+- examples/support_desk/boot.rb
+- examples/support_desk/config/importmap.rb
+- examples/support_desk/config/initializers/openui.rb
+- examples/support_desk/config/routes.rb
+- examples/support_desk/db/migrate/20261019000000_create_support_desk.rb
+- examples/support_desk/install.rb
+- lib/generators/openui/idempotency/idempotency_generator.rb
+- lib/generators/openui/idempotency/templates/create_openui_action_claims.rb
 - lib/generators/openui/install/install_generator.rb
 - lib/generators/openui/install/templates/config/initializers/openui.rb.tt
 - lib/generators/openui/install/templates/config/openui/README.md
 - lib/openui/rails.rb
 - lib/openui/rails/actions.rb
 - lib/openui/rails/actions/dispatcher.rb
+- lib/openui/rails/actions/idempotency/active_record_store.rb
 - lib/openui/rails/actions/idempotency/memory_store.rb
 - lib/openui/rails/actions/invocation.rb
 - lib/openui/rails/actions/registry.rb
@@ -97,6 +119,7 @@ files:
 - lib/openui/rails/stream/transports/memory.rb
 - lib/openui/rails/stream/transports/turbo_streams.rb
 - lib/openui/rails/surface.rb
+- lib/openui/rails/testing/idempotency_store_contract.rb
 - lib/openui/rails/version.rb
 - lib/openui/rails/view_helper.rb
 - lib/tasks/openui.rake