ruact 0.0.2 → 0.0.4

data/spec/ruact/server_functions/registry_spec.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+module Ruact
+  module ServerFunctions
+    RSpec.describe Registry, :story_8_0a do
+      subject(:registry) { described_class.new }
+
+      let(:posts_controller) do
+        Class.new { def self.name = "PostsController" }
+      end
+
+      let(:bar_controller) do
+        Class.new { def self.name = "BarController" }
+      end
+
+      describe "#register (Story 8.0a)" do
+        it "stores a single entry keyed by its Ruby symbol", :aggregate_failures do
+          entry = registry.register(:create_post, kind: :action, controller: posts_controller)
+
+          expect(entry).to be_a(RegistryEntry)
+          expect(entry.ruby_symbol).to eq(:create_post)
+          expect(entry.js_identifier).to eq("createPost")
+          expect(entry.kind).to eq(:action)
+          expect(entry.controller).to eq(posts_controller)
+          expect(registry.entries.keys).to eq([:create_post])
+        end
+
+        it "captures the implementation block verbatim for downstream invocation" do
+          block = -> { :pong }
+          entry = registry.register(:demo_ping, kind: :action, controller: posts_controller, &block)
+          expect(entry.block).to be(block)
+        end
+
+        it "allows registering an action and a query with the same symbol in separate registries" do
+          actions = described_class.new
+          queries = described_class.new
+          actions.register(:create_post, kind: :action, controller: posts_controller)
+          queries.register(:create_post, kind: :query, controller: posts_controller)
+          expect(actions.entries.keys).to eq([:create_post])
+          expect(queries.entries.keys).to eq([:create_post])
+        end
+
+        it "raises Ruact::ConfigurationError for SCREAMING_SNAKE symbols (Story 8.0a)" do
+          expect { registry.register(:RECALCULATE, kind: :action, controller: posts_controller) }
+            .to raise_error(Ruact::ConfigurationError) do |error|
+              expect(error.message).to include(":RECALCULATE")
+            end
+        end
+
+        it "raises Ruact::ConfigurationError on JS-identifier collision and names both " \
+           "Ruby symbols and both controllers (Story 8.0a)", :aggregate_failures do
+          registry.register(:foo_bar, kind: :action, controller: posts_controller)
+          expect { registry.register(:foo__bar, kind: :action, controller: bar_controller) }
+            .to raise_error(Ruact::ConfigurationError) do |error|
+              expect(error.message).to include(":foo_bar")
+              expect(error.message).to include(":foo__bar")
+              expect(error.message).to include("PostsController")
+              expect(error.message).to include("BarController")
+              expect(error.message).to include('"fooBar"')
+            end
+        end
+
+        it "allows re-registering the same Ruby symbol (replace semantics, dev reload)" do
+          registry.register(:create_post, kind: :action, controller: posts_controller)
+          expect do
+            registry.register(:create_post, kind: :action, controller: posts_controller)
+          end.not_to raise_error
+          expect(registry.size).to eq(1)
+        end
+
+        it "tolerates a nil controller (Rails-console registration path)" do
+          expect { registry.register(:create_post, kind: :action) }.not_to raise_error
+        end
+
+        it "rejects kinds other than :action / :query (Chunk1 Major 2026-05-13)" do
+          expect { registry.register(:create_post, kind: :wat, controller: posts_controller) }
+            .to raise_error(Ruact::ConfigurationError) do |error|
+              expect(error.message).to include(":create_post")
+              expect(error.message).to include("PostsController")
+              expect(error.message).to include(":wat")
+              expect(error.message).to include("[:action, :query]")
+            end
+        end
+
+        it "wraps NameBridge symbol-shape failures with AC7 'invalid server-function " \
+           "symbol :SYMBOL in CONTROLLER' framing (Re-run patch m5)" do
+          expect { registry.register(:RECALCULATE, kind: :action, controller: posts_controller) }
+            .to raise_error(Ruact::ConfigurationError) do |error|
+              expect(error.message).to start_with("invalid server-function symbol :RECALCULATE in PostsController")
+            end
+        end
+      end
+
+      describe "#entries (Story 8.0a)" do
+        it "returns a frozen snapshot independent of subsequent mutations" do
+          registry.register(:create_post, kind: :action, controller: posts_controller)
+          snapshot = registry.entries
+          expect(snapshot).to be_frozen
+          registry.register(:list_posts, kind: :query, controller: posts_controller)
+          expect(snapshot.keys).to eq([:create_post])
+        end
+      end
+
+      describe "#clear! (Story 8.0a)" do
+        it "wipes all entries and returns self" do
+          registry.register(:create_post, kind: :action, controller: posts_controller)
+          expect(registry.clear!).to be(registry)
+          expect(registry).to be_empty
+        end
+      end
+
+      describe "Story 8.3 — mixed controller+standalone collision", :story_8_3 do
+        let(:posts_controller_class) do
+          Class.new { def self.name = "PostsController" }
+        end
+
+        let(:standalone_create_post_module) do
+          Module.new do
+            extend Ruact::ServerAction
+
+            def self.name
+              "CreatePost"
+            end
+          end
+        end
+
+        it "raises Ruact::ConfigurationError when the same Ruby symbol is declared in a controller " \
+           "AND in a standalone module — message names BOTH hosts" do
+          registry.register(:create_post, kind: :action, controller: posts_controller_class)
+
+          expect do
+            registry.register(:create_post, kind: :action, controller: standalone_create_post_module)
+          end.to raise_error(Ruact::ConfigurationError) do |error|
+            expect(error.message).to include(":create_post")
+            expect(error.message).to include("PostsController")
+            expect(error.message).to include("CreatePost")
+            expect(error.message).to include("declared in BOTH")
+          end
+        end
+
+        it "raises Ruact::ConfigurationError when the same symbol is declared in standalone " \
+           "first, then in a controller (order-independent)" do
+          registry.register(:create_post, kind: :action, controller: standalone_create_post_module)
+
+          expect do
+            registry.register(:create_post, kind: :action, controller: posts_controller_class)
+          end.to raise_error(Ruact::ConfigurationError) do |error|
+            expect(error.message).to include("PostsController")
+            expect(error.message).to include("CreatePost")
+          end
+        end
+
+        it "describe_controller names a Module host correctly (no inspection fallback) " \
+           "when one side of the collision is a Module" do
+          registry.register(:create_post, kind: :action, controller: standalone_create_post_module)
+          another_module = Module.new do
+            extend Ruact::ServerAction
+
+            def self.name
+              "AdminCreatePost"
+            end
+          end
+
+          # Cross-bridge JS-identifier collision: two DIFFERENT Ruby symbols
+          # producing the SAME JS identifier — bridges into `js_identifier ==`
+          # branch of detect_collision!. The bridge collapses underscores,
+          # so `:create_post` and `:create__post` both → "createPost".
+          expect do
+            registry.register(:create__post, kind: :action, controller: another_module)
+          end.to raise_error(Ruact::ConfigurationError) do |error|
+            expect(error.message).to include("CreatePost")
+            expect(error.message).to include("AdminCreatePost")
+            expect(error.message).to include('"createPost"')
+          end
+        end
+      end
+
+      describe "Ruact module-level accessors (Story 8.0a)" do
+        it "returns two independent Registry singletons" do
+          expect(Ruact.action_registry).to be_a(described_class)
+          expect(Ruact.query_registry).to be_a(described_class)
+          expect(Ruact.action_registry).not_to equal(Ruact.query_registry)
+        end
+
+        it "memoizes the same instance across calls" do
+          expect(Ruact.action_registry).to equal(Ruact.action_registry)
+          expect(Ruact.query_registry).to equal(Ruact.query_registry)
+        end
+
+        it "both registries are empty at boot (Story 8.1 / 9.1 populate them)" do
+          expect(Ruact.action_registry).to be_empty
+          expect(Ruact.query_registry).to be_empty
+        end
+      end
+    end
+  end
+end

data/spec/ruact/server_functions/route_source_spec.rb

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "active_support/all"
+require "action_dispatch"
+require "ruact/server_functions/route_source"
+
+module Ruact
+  module ServerFunctions
+    # Story 9.3 — route introspection: Rails.application.routes (filtered to
+    # non-GET routes on controllers that include Ruact::Server) → v2 mutation
+    # entries with the derivation table locked in the 2026-06-09 ADR addendum.
+    RSpec.describe RouteSource, :story_9_3 do
+      # Builds an isolated RouteSet so specs never depend on a host app's routes.
+      def route_set(&blk)
+        rs = ActionDispatch::Routing::RouteSet.new
+        rs.draw(&blk)
+        rs
+      end
+
+      # All controllers count as Ruact::Server hosts (isolates the derivation
+      # table from constant-resolution); the filter behaviour is tested
+      # separately below.
+      def collect(routes, overrides: {})
+        described_class.collect(
+          routes,
+          host_predicate: ->(_controller) { true },
+          overrides_for: ->(controller) { overrides.fetch(controller, {}) }
+        )
+      end
+
+      def ids(entries) = entries.map { |e| e["js_identifier"] }
+
+      describe "derivation table (AC3)" do
+        it "names the RESTful collection create as singular verb+resource" do
+          rs = route_set { resources :posts, only: %i[create] }
+          entry = collect(rs).fetch(0)
+          expect(entry["js_identifier"]).to eq("createPost")
+          expect(entry["http_method"]).to eq("POST")
+          expect(entry["path"]).to eq("/posts")
+          expect(entry["segments"]).to eq([])
+          expect(entry["kind"]).to eq("action")
+        end
+
+        it "names update (member) singular and prefers PATCH over the PUT alias" do
+          rs = route_set { resources :posts, only: %i[update] }
+          entries = collect(rs)
+          expect(entries.size).to eq(1) # PATCH + PUT collapse to one entry
+          entry = entries.fetch(0)
+          expect(entry["js_identifier"]).to eq("updatePost")
+          expect(entry["http_method"]).to eq("PATCH")
+          expect(entry["path"]).to eq("/posts/:id")
+          expect(entry["segments"]).to eq(["id"])
+        end
+
+        it "names destroy (member) singular" do
+          rs = route_set { resources :posts, only: %i[destroy] }
+          entry = collect(rs).fetch(0)
+          expect(entry["js_identifier"]).to eq("destroyPost")
+          expect(entry["http_method"]).to eq("DELETE")
+          expect(entry["path"]).to eq("/posts/:id")
+        end
+
+        it "skips the GET RESTful actions (index/show/new/edit)" do
+          rs = route_set { resources :posts }
+          expect(ids(collect(rs))).to match_array(%w[createPost updatePost destroyPost])
+        end
+
+        it "names a custom member route singular (verb-action + singular resource)" do
+          rs = route_set do
+            resources :posts do
+              member { post :publish }
+            end
+          end
+          entry = collect(rs).find { |e| e["js_identifier"] == "publishPost" }
+          expect(entry).not_to be_nil
+          expect(entry["http_method"]).to eq("POST")
+          expect(entry["path"]).to eq("/posts/:id/publish")
+          expect(entry["segments"]).to eq(["id"])
+        end
+
+        it "names a custom collection route plural" do
+          rs = route_set do
+            resources :posts do
+              collection { post :publish_all }
+            end
+          end
+          entry = collect(rs).find { |e| e["js_identifier"] == "publishAllPosts" }
+          expect(entry).not_to be_nil
+          expect(entry["path"]).to eq("/posts/publish_all")
+          expect(entry["segments"]).to eq([])
+        end
+
+        it "names singular-resource create/destroy singular" do
+          rs = route_set { resource :session, only: %i[create destroy] }
+          expect(ids(collect(rs))).to match_array(%w[createSession destroySession])
+        end
+
+        it "prefixes namespaced controllers (verb + Namespace + Resource)" do
+          rs = route_set { namespace(:admin) { resources :posts, only: %i[create update] } }
+          expect(ids(collect(rs))).to match_array(%w[createAdminPost updateAdminPost])
+        end
+
+        it "deep-prefixes multi-level namespaces" do
+          rs = route_set do
+            namespace(:admin) { namespace(:reports) { resources :posts, only: %i[create] } }
+          end
+          expect(ids(collect(rs))).to eq(%w[createAdminReportsPost])
+        end
+
+        it "sorts entries by js_identifier for deterministic output" do
+          rs = route_set { resources :posts }
+          expect(ids(collect(rs))).to eq(%w[createPost destroyPost updatePost])
+        end
+
+        it "classifies a custom-param member route (param: :slug) as member → singular" do
+          rs = route_set do
+            resources :posts, param: :slug do
+              member { post :publish }
+            end
+          end
+          entry = collect(rs).find { |e| e["action"] == "publish" }
+          expect(entry["js_identifier"]).to eq("publishPost")
+          expect(entry["segments"]).to eq(["slug"])
+        end
+
+        it "classifies a nested collection route (only parent :id present) as collection → plural" do
+          rs = route_set do
+            resources :posts, only: [] do
+              resources :comments, only: [] do
+                collection { post :flag_all }
+              end
+            end
+          end
+          entry = collect(rs).find { |e| e["action"] == "flag_all" }
+          expect(entry["js_identifier"]).to eq("flagAllComments")
+        end
+      end
+
+      describe "rename override (AC4 input)" do
+        it "uses the per-controller override identifier when present" do
+          rs = route_set do
+            resources :posts do
+              collection { post :publish_all }
+            end
+          end
+          entries = collect(rs, overrides: { "posts" => { "publish_all" => "publishEverything" } })
+          expect(ids(entries)).to include("publishEverything")
+          expect(ids(entries)).not_to include("publishAllPosts")
+        end
+      end
+
+      describe "collision detection (AC4)" do
+        it "fails loudly naming BOTH origins when two routes map to the same identifier" do
+          rs = route_set do
+            resources :posts, only: %i[create]
+            resources :comments, only: %i[create]
+          end
+          # Force a collision: comments#create is renamed onto posts#create's name.
+          overrides = { "comments" => { "create" => "createPost" } }
+          expect do
+            collect(rs, overrides: overrides)
+          end.to raise_error(Ruact::ConfigurationError, /naming collision/) { |err|
+            expect(err.message).to include("posts#create")
+            expect(err.message).to include("comments#create")
+            expect(err.message).to include("createPost")
+          }
+        end
+
+        it "boot succeeds once the colliding route is renamed to a free identifier (full cycle)" do
+          rs = route_set do
+            resources :posts, only: %i[create]
+            resources :comments, only: %i[create]
+          end
+          overrides = { "comments" => { "create" => "createComment" } }
+          ids_out = ids(collect(rs, overrides: overrides))
+          expect(ids_out).to eq(%w[createComment createPost])
+        end
+      end
+
+      describe "host filter (Ruact::Server only)" do
+        it "skips routes whose controller is not a Ruact::Server host" do
+          rs = route_set do
+            resources :posts, only: %i[create]
+            resources :widgets, only: %i[create]
+          end
+          entries = described_class.collect(
+            rs,
+            host_predicate: ->(controller) { controller == "posts" },
+            overrides_for: ->(_c) { {} }
+          )
+          expect(ids(entries)).to eq(%w[createPost])
+        end
+
+        it "skips GET/HEAD routes even on a host controller" do
+          rs = route_set { get "/posts/search", to: "posts#search" }
+          expect(collect(rs)).to be_empty
+        end
+      end
+    end
+  end
+end

data/spec/ruact/server_functions/snapshot_spec.rb

@@ -0,0 +1,256 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "tmpdir"
+
+module Ruact
+  module ServerFunctions
+    RSpec.describe Snapshot, :story_8_0a do
+      let(:posts_controller) { Class.new { def self.name = "PostsController" } }
+      let(:cats_controller)  { Class.new { def self.name = "CategoriesController" } }
+      let(:actions)          { Registry.new }
+      let(:queries)          { Registry.new }
+      let(:frozen_time)      { Time.utc(2026, 5, 13, 12, 34, 56) }
+
+      describe ".dump (Story 8.0a — pure snapshot builder)" do
+        it "returns the empty payload when both registries are empty" do
+          snapshot = described_class.dump(actions, queries, now: frozen_time)
+
+          expect(snapshot).to eq(
+            version: 1,
+            generated_at: "2026-05-13T12:34:56Z",
+            functions: []
+          )
+        end
+
+        it "merges action + query entries into a single functions array" do
+          actions.register(:create_post, kind: :action, controller: posts_controller)
+          queries.register(:categories, kind: :query, controller: cats_controller)
+
+          snapshot = described_class.dump(actions, queries, now: frozen_time)
+
+          expect(snapshot[:functions]).to contain_exactly(
+            { "ruby_symbol" => "create_post", "js_identifier" => "createPost",
+              "kind" => "action", "controller" => "PostsController" },
+            { "ruby_symbol" => "categories", "js_identifier" => "categories",
+              "kind" => "query", "controller" => "CategoriesController" }
+          )
+        end
+
+        it "sorts functions by ruby_symbol for deterministic output (Story 8.0a)" do
+          actions.register(:zeta, kind: :action, controller: posts_controller)
+          actions.register(:alpha, kind: :action, controller: posts_controller)
+          queries.register(:mike, kind: :query, controller: posts_controller)
+
+          symbols = described_class.dump(actions, queries, now: frozen_time)[:functions]
+                                   .map { |fn| fn["ruby_symbol"] }
+          expect(symbols).to eq(%w[alpha mike zeta])
+        end
+
+        it "stringifies controller class names; falls back to nil for nil controllers" do
+          actions.register(:demo_ping, kind: :action, controller: nil)
+          snapshot = described_class.dump(actions, queries, now: frozen_time)
+          expect(snapshot[:functions].first["controller"]).to be_nil
+        end
+      end
+
+      describe ".functions_payload — cross-registry collision (Chunk1 Blocker 2026-05-13)" do
+        it "raises Ruact::ConfigurationError shaped per AC7 when an action and a query " \
+           "share a JS identifier (Re-run patch 2026-05-14 — message prefix aligned with " \
+           "within-registry collision)",
+           :aggregate_failures do
+          actions.register(:foo, kind: :action, controller: posts_controller)
+          queries.register(:foo, kind: :query, controller: cats_controller)
+          expect { described_class.functions_payload(actions, queries) }
+            .to raise_error(Ruact::ConfigurationError) do |error|
+              # AC7 exact shape: rake wraps to "[ruact] error: server-function naming collision: :foo (in PostsController) and :foo (in CategoriesController) both map to JS identifier \"foo\""
+              expect(error.message).to start_with("server-function naming collision:")
+              expect(error.message).to include(":foo (in PostsController)")
+              expect(error.message).to include(":foo (in CategoriesController)")
+              expect(error.message).to include('"foo"')
+              # No "kind:" annotation per Pass-2 patch 2026-05-14
+              expect(error.message).not_to include("kind:")
+            end
+        end
+
+        it "raises when different Ruby symbols cross-collide via the naming bridge" do
+          # `:foo_bar` action + `:foo__bar` query both → "fooBar"
+          actions.register(:foo_bar, kind: :action, controller: posts_controller)
+          queries.register(:foo__bar, kind: :query, controller: cats_controller)
+          expect { described_class.functions_payload(actions, queries) }
+            .to raise_error(Ruact::ConfigurationError, /server-function naming collision.*"fooBar"/m)
+        end
+
+        it "raises when both registries contain the same Ruby symbol with matching " \
+           "js_identifier (one js_identifier per emitted export is the design intent)" do
+          actions.register(:categories, kind: :action, controller: posts_controller)
+          queries.register(:categories, kind: :query, controller: cats_controller)
+          expect { described_class.functions_payload(actions, queries) }
+            .to raise_error(Ruact::ConfigurationError, /server-function naming collision/)
+        end
+      end
+
+      describe ".functions_payload (Story 8.0a — fingerprint surface)" do
+        it "excludes the generated_at timestamp so registry-equivalent calls match" do
+          actions.register(:create_post, kind: :action, controller: posts_controller)
+
+          first = described_class.functions_payload(actions, queries)
+          sleep 0.01
+          second = described_class.functions_payload(actions, queries)
+
+          expect(first).to eq(second)
+        end
+      end
+
+      describe ".generate! (Story 8.0a — write-if-changed orchestration)" do
+        around do |example|
+          Dir.mktmpdir do |dir|
+            @tmpdir = dir
+            example.run
+          end
+        end
+
+        let(:path) { File.join(@tmpdir, "server-functions.json") }
+
+        it "writes the file on first call and returns true" do
+          result = described_class.generate!(
+            action_registry: actions, query_registry: queries, path: path, now: frozen_time
+          )
+
+          expect(result).to be(true)
+          expect(File).to exist(path)
+          parsed = JSON.parse(File.read(path))
+          expect(parsed.fetch("version")).to eq(1)
+          expect(parsed.fetch("functions")).to eq([])
+        end
+
+        it "does NOT rewrite the file when the registry is unchanged " \
+           "(Story 8.0a — pitfall #1 mitigation)", :aggregate_failures do
+          actions.register(:create_post, kind: :action, controller: posts_controller)
+          described_class.generate!(action_registry: actions, query_registry: queries,
+                                    path: path, now: frozen_time)
+
+          original_mtime  = File.mtime(path)
+          original_bytes  = File.read(path)
+          original_time   = JSON.parse(original_bytes)["generated_at"]
+          sleep 1.05 # ensure mtime resolution is exceeded if we DID rewrite
+
+          result = described_class.generate!(
+            action_registry: actions, query_registry: queries,
+            path: path, now: Time.now.utc # different now
+          )
+
+          expect(result).to be(false)
+          expect(File.mtime(path)).to eq(original_mtime)
+          expect(JSON.parse(File.read(path))["generated_at"]).to eq(original_time)
+        end
+
+        it "rewrites the file when a function is added" do
+          described_class.generate!(action_registry: actions, query_registry: queries,
+                                    path: path, now: frozen_time)
+          actions.register(:create_post, kind: :action, controller: posts_controller)
+
+          result = described_class.generate!(
+            action_registry: actions, query_registry: queries, path: path, now: frozen_time
+          )
+
+          expect(result).to be(true)
+          expect(JSON.parse(File.read(path))["functions"].size).to eq(1)
+        end
+
+        it "creates the parent directory if missing" do
+          nested = File.join(@tmpdir, "deep", "nest", "server-functions.json")
+          expect do
+            described_class.generate!(action_registry: actions, query_registry: queries,
+                                      path: nested, now: frozen_time)
+          end
+            .to change { File.exist?(nested) }.from(false).to(true)
+        end
+
+        it "recovers from a corrupted existing file by overwriting it" do
+          File.write(path, "not json")
+          result = described_class.generate!(
+            action_registry: actions, query_registry: queries, path: path, now: frozen_time
+          )
+          expect(result).to be(true)
+          expect { JSON.parse(File.read(path)) }.not_to raise_error
+        end
+
+        it "rewrites the file when the on-disk snapshot has a different version " \
+           "(Chunk1 Major 2026-05-13 — version mismatch must not be treated as unchanged)" do
+          File.write(path, JSON.pretty_generate(version: 99, generated_at: "2020-01-01T00:00:00Z", functions: []))
+          result = described_class.generate!(
+            action_registry: actions, query_registry: queries, path: path, now: frozen_time
+          )
+          expect(result).to be(true)
+          expect(JSON.parse(File.read(path))["version"]).to eq(1)
+        end
+      end
+
+      describe "route-driven (v2) snapshot (Story 9.3)", :story_9_3 do
+        let(:entries) do
+          [
+            { "js_identifier" => "createPost", "kind" => "action", "http_method" => "POST",
+              "path" => "/posts", "segments" => [], "controller" => "posts", "action" => "create" }
+          ]
+        end
+
+        describe ".dump_v2" do
+          it "wraps entries in a version-2 snapshot Hash" do
+            snap = described_class.dump_v2(entries, now: frozen_time)
+            expect(snap[:version]).to eq(2)
+            expect(snap[:generated_at]).to eq(frozen_time.iso8601)
+            expect(snap[:functions]).to eq(entries)
+          end
+        end
+
+        describe ".generate_v2! (write-if-changed)" do
+          around do |example|
+            Dir.mktmpdir do |dir|
+              @tmpdir = dir
+              example.run
+            end
+          end
+
+          let(:path) { File.join(@tmpdir, "server-functions.next.json") }
+
+          it "writes a version-2 bridge on first call" do
+            expect(described_class.generate_v2!(entries: entries, path: path, now: frozen_time)).to be(true)
+            parsed = JSON.parse(File.read(path))
+            expect(parsed.fetch("version")).to eq(2)
+            expect(parsed.fetch("functions").first.fetch("js_identifier")).to eq("createPost")
+          end
+
+          it "short-circuits when entries are unchanged (no timestamp churn)" do
+            described_class.generate_v2!(entries: entries, path: path, now: frozen_time)
+            expect(described_class.generate_v2!(entries: entries, path: path, now: Time.now.utc)).to be(false)
+          end
+
+          it "rewrites when entries change" do
+            described_class.generate_v2!(entries: entries, path: path, now: frozen_time)
+            more = entries + [{ "js_identifier" => "destroyPost", "kind" => "action",
+                                "http_method" => "DELETE", "path" => "/posts/:id",
+                                "segments" => ["id"], "controller" => "posts", "action" => "destroy" }]
+            expect(described_class.generate_v2!(entries: more, path: path, now: frozen_time)).to be(true)
+          end
+        end
+
+        describe ".v1_declarations? (Decision-#6 ownership primitive)" do
+          it "is false when both registries are empty" do
+            expect(described_class.v1_declarations?(Registry.new, Registry.new)).to be(false)
+          end
+
+          it "is true when the action registry has any entry" do
+            actions.register(:create_post, kind: :action, controller: posts_controller)
+            expect(described_class.v1_declarations?(actions, Registry.new)).to be(true)
+          end
+
+          it "is true when the query registry has any entry" do
+            queries.register(:categories, kind: :query, controller: cats_controller)
+            expect(described_class.v1_declarations?(Registry.new, queries)).to be(true)
+          end
+        end
+      end
+    end
+  end
+end