ruact 0.0.10 → 0.0.12

data/spec/ruact/server_functions/codegen_spec.rb

@@ -1,397 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-require "tmpdir"
-
-module Ruact
-  module ServerFunctions
-    RSpec.describe Codegen, :story_9_3 do
-      # Story 9.9 — the v1 (registry / `_makeRef`) render path was demolished;
-      # only the route-driven (version-2) snapshot is supported.
-      let(:v2_base) do
-        {
-          version: 2,
-          generated_at: "2026-06-09T00:00:00Z",
-          functions: []
-        }
-      end
-
-      describe ".render — unsupported / malformed snapshots" do
-        it "rejects when snapshot is not a Hash" do
-          expect { described_class.render("oops") }
-            .to raise_error(Ruact::ConfigurationError, /snapshot must be a Hash/)
-        end
-
-        it "wraps a missing root key as Ruact::ConfigurationError" do
-          evil = { generated_at: "2026-05-14T00:00:00Z", functions: [] } # no :version
-          expect { described_class.render(evil) }
-            .to raise_error(Ruact::ConfigurationError, /missing required key/)
-        end
-
-        it "rejects a snapshot whose version contains a line break" do
-          evil = v2_base.merge(version: "2\n// injected")
-          expect { described_class.render(evil) }
-            .to raise_error(Ruact::ConfigurationError, /version.*line break/)
-        end
-
-        it "rejects a snapshot whose generated_at contains a line break" do
-          evil = v2_base.merge(generated_at: "2026-05-14\n// injected")
-          expect { described_class.render(evil) }
-            .to raise_error(Ruact::ConfigurationError, /generated_at.*line break/)
-        end
-
-        it "rejects a snapshot whose version contains a U+2028 line separator (JS LineTerminator parity)" do
-          evil = v2_base.merge(version: "2
// injected")
-          expect { described_class.render(evil) }
-            .to raise_error(Ruact::ConfigurationError, /line break.*U\+2028/)
-        end
-
-        it "rejects a snapshot whose generated_at contains a U+2029 paragraph separator (JS LineTerminator parity)" do
-          evil = v2_base.merge(generated_at: "2026-05-14
// injected")
-          expect { described_class.render(evil) }
-            .to raise_error(Ruact::ConfigurationError, /line break.*U\+2029/)
-        end
-
-        it "rejects an unsupported (non-v2) snapshot version" do
-          evil = v2_base.merge(version: 1)
-          expect { described_class.render(evil) }
-            .to raise_error(Ruact::ConfigurationError, /unsupported snapshot version/)
-        end
-      end
-
-      describe ".generate_ts! (write-if-changed wrapper)" do
-        around do |example|
-          Dir.mktmpdir do |dir|
-            @tmpdir = dir
-            example.run
-          end
-        end
-
-        let(:path) { File.join(@tmpdir, "server-functions.ts") }
-
-        it "writes the file on first call and returns true" do
-          expect(described_class.generate_ts!(snapshot: v2_base, output_path: path))
-            .to be(true)
-          expect(File.read(path)).to include("// AUTO-GENERATED by vite-plugin-ruact")
-        end
-
-        it "does NOT rewrite when the content is byte-identical" do
-          described_class.generate_ts!(snapshot: v2_base, output_path: path)
-          expect(described_class.generate_ts!(snapshot: v2_base, output_path: path))
-            .to be(false)
-        end
-      end
-
-      describe ".render — route-driven v2 snapshot (Story 9.3)", :story_9_3 do
-        let(:v2_snapshot) do
-          {
-            version: 2,
-            generated_at: "2026-06-09T00:00:00Z",
-            functions: [
-              { "js_identifier" => "createPost", "kind" => "action",
-                "http_method" => "POST", "path" => "/posts", "segments" => [],
-                "controller" => "posts", "action" => "create" },
-              { "js_identifier" => "updatePost", "kind" => "action",
-                "http_method" => "PATCH", "path" => "/posts/:id", "segments" => ["id"],
-                "controller" => "posts", "action" => "update" }
-            ]
-          }
-        end
-
-        it "dispatches on version 2 and emits _makeServerFunction with real path+verb" do
-          out = described_class.render(v2_snapshot)
-          expect(out).to include('import { _makeServerFunction } from "ruact/server-functions-runtime";')
-          expect(out).to include('_makeServerFunction({ method: "POST", path: "/posts", segments: [] });')
-          expect(out).to include('_makeServerFunction({ method: "PATCH", path: "/posts/:id", segments: ["id"] });')
-          expect(out).to include('export { revalidate } from "ruact/server-functions-runtime";')
-        end
-
-        it "keeps the Story 8.2 intersection signature on v2 actions (form action support)" do
-          out = described_class.render(v2_snapshot)
-          expect(out).to include("& ((formData: FormData) => Promise<void>)")
-        end
-
-        it "emits the empty-v2 module when no routes are exposed" do
-          out = described_class.render(version: 2, generated_at: "2026-06-09T00:00:00Z", functions: [])
-          expect(out).to include("void _makeServerFunction;")
-          expect(out).to include("(no server functions exposed yet")
-          expect(out).to end_with("export { revalidate } from \"ruact/server-functions-runtime\";\n")
-        end
-
-        it "rejects a v2 entry with an invalid http_method" do
-          evil = v2_snapshot.merge(functions: [
-                                     { "js_identifier" => "createPost", "kind" => "action",
-                                       "http_method" => "GET", "path" => "/posts", "segments" => [] }
-                                   ])
-          expect { described_class.render(evil) }
-            .to raise_error(Ruact::ConfigurationError, /invalid http_method/)
-        end
-
-        it "rejects a v2 entry declaring a segment absent from the path" do
-          evil = v2_snapshot.merge(functions: [
-                                     { "js_identifier" => "updatePost", "kind" => "action",
-                                       "http_method" => "PATCH", "path" => "/posts", "segments" => ["id"] }
-                                   ])
-          expect { described_class.render(evil) }
-            .to raise_error(Ruact::ConfigurationError, /absent from path/)
-        end
-
-        it "rejects a v2 entry with an unknown kind (Story 9.5 — action/query only)" do
-          evil = v2_snapshot.merge(functions: [
-                                     { "js_identifier" => "createPost", "kind" => "mutation",
-                                       "http_method" => "POST", "path" => "/posts", "segments" => [] }
-                                   ])
-          expect { described_class.render(evil) }
-            .to raise_error(Ruact::ConfigurationError, /v2 entries are "action" or "query"/)
-        end
-
-        it "rejects a v2 entry whose js_identifier is reserved" do
-          evil = v2_snapshot.merge(functions: [
-                                     { "js_identifier" => "revalidate", "kind" => "action",
-                                       "http_method" => "POST", "path" => "/posts", "segments" => [] }
-                                   ])
-          expect { described_class.render(evil) }
-            .to raise_error(Ruact::ConfigurationError, /reserved/)
-        end
-
-        it "rejects a v2 entry named after the v2 runtime accessor (_makeServerFunction)" do
-          evil = v2_snapshot.merge(functions: [
-                                     { "js_identifier" => "_makeServerFunction", "kind" => "action",
-                                       "http_method" => "POST", "path" => "/posts", "segments" => [] }
-                                   ])
-          expect { described_class.render(evil) }
-            .to raise_error(Ruact::ConfigurationError, /reserved/)
-        end
-
-        it "rejects a v2 path with an undeclared dynamic segment (bidirectional guard)" do
-          evil = v2_snapshot.merge(functions: [
-                                     { "js_identifier" => "updatePost", "kind" => "action",
-                                       "http_method" => "PATCH", "path" => "/posts/:id",
-                                       "segments" => [] }
-                                   ])
-          expect { described_class.render(evil) }
-            .to raise_error(Ruact::ConfigurationError, /not declared in segments/)
-        end
-
-        it "rejects a v2 segment that only substring-matches a longer path token" do
-          evil = v2_snapshot.merge(functions: [
-                                     { "js_identifier" => "updatePost", "kind" => "action",
-                                       "http_method" => "PATCH", "path" => "/posts/:id_extra",
-                                       "segments" => ["id"] }
-                                   ])
-          expect { described_class.render(evil) }
-            .to raise_error(Ruact::ConfigurationError, /absent from path/)
-        end
-      end
-
-      describe ".render — v2 query entries (Story 9.5)", :story_9_5 do
-        def query_entry(js_id, path, accepts_params:)
-          {
-            "js_identifier" => js_id, "kind" => "query", "http_method" => "GET",
-            "path" => path, "segments" => [], "accepts_params" => accepts_params,
-            "controller" => "CatalogQuery", "action" => js_id
-          }
-        end
-
-        it "emits a no-param query as _makeQuery with the () signature + useQuery re-export" do
-          out = described_class.render(version: 2, generated_at: "t", functions: [
-                                         query_entry("categories", "/q/categories", accepts_params: false)
-                                       ])
-          expect(out).to include('import { _makeQuery } from "ruact/server-functions-runtime";')
-          expect(out).to include("export const categories: () => Promise<unknown> =")
-          expect(out).to include('_makeQuery({ path: "/q/categories", kind: "query" });')
-          expect(out).to include('export { useQuery } from "ruact/server-functions-runtime";')
-          expect(out).to include('export { revalidate } from "ruact/server-functions-runtime";')
-        end
-
-        it "emits a param-declaring query with the (params) signature" do
-          out = described_class.render(version: 2, generated_at: "t", functions: [
-                                         query_entry("searchUsers", "/q/searchUsers", accepts_params: true)
-                                       ])
-          expect(out).to include("export const searchUsers: (params: Record<string, unknown>) => Promise<unknown> =")
-          expect(out).to include('_makeQuery({ path: "/q/searchUsers", kind: "query" });')
-        end
-
-        it "imports both accessors and re-exports useQuery for a mixed action+query snapshot" do
-          out = described_class.render(version: 2, generated_at: "t", functions: [
-                                         { "js_identifier" => "createPost", "kind" => "action",
-                                           "http_method" => "POST", "path" => "/posts", "segments" => [] },
-                                         query_entry("categories", "/q/categories", accepts_params: false)
-                                       ])
-          expect(out).to include('import { _makeServerFunction, _makeQuery } from "ruact/server-functions-runtime";')
-          expect(out).to include("_makeServerFunction({ method: \"POST\"")
-          expect(out).to include("_makeQuery({ path: \"/q/categories\", kind: \"query\" })")
-          expect(out).to include('export { useQuery } from "ruact/server-functions-runtime";')
-        end
-
-        it "accepts GET for a query entry (queries are GET-only)" do
-          expect do
-            described_class.render(version: 2, generated_at: "t", functions: [
-                                     query_entry("categories", "/q/categories", accepts_params: false)
-                                   ])
-          end.not_to raise_error
-        end
-
-        it "rejects a non-GET verb on a query entry" do
-          evil = { "js_identifier" => "categories", "kind" => "query", "http_method" => "POST",
-                   "path" => "/q/categories", "segments" => [] }
-          expect { described_class.render(version: 2, generated_at: "t", functions: [evil]) }
-            .to raise_error(Ruact::ConfigurationError, /invalid http_method/)
-        end
-
-        it "rejects a query entry whose js_identifier is the useQuery re-export name" do
-          evil = { "js_identifier" => "useQuery", "kind" => "query", "http_method" => "GET",
-                   "path" => "/q/useQuery", "segments" => [], "accepts_params" => false }
-          expect { described_class.render(version: 2, generated_at: "t", functions: [evil]) }
-            .to raise_error(Ruact::ConfigurationError, /reserved/)
-        end
-
-        it "rejects a query entry whose js_identifier is the _makeQuery import name" do
-          evil = { "js_identifier" => "_makeQuery", "kind" => "query", "http_method" => "GET",
-                   "path" => "/q/_makeQuery", "segments" => [], "accepts_params" => false }
-          expect { described_class.render(version: 2, generated_at: "t", functions: [evil]) }
-            .to raise_error(Ruact::ConfigurationError, /reserved/)
-        end
-
-        it "does NOT re-export useQuery for an action-only snapshot (byte-stable with 9.3)" do
-          out = described_class.render(version: 2, generated_at: "t", functions: [
-                                         { "js_identifier" => "createPost", "kind" => "action",
-                                           "http_method" => "POST", "path" => "/posts", "segments" => [] }
-                                       ])
-          expect(out).not_to include("useQuery")
-          expect(out).to end_with("export { revalidate } from \"ruact/server-functions-runtime\";\n")
-        end
-      end
-
-      describe ".render — typed query params (Story 13.4)", :story_13_4 do
-        def typed_query(js_id, path, params:, params_rest: false)
-          {
-            "js_identifier" => js_id, "kind" => "query", "http_method" => "GET",
-            "path" => path, "segments" => [],
-            "accepts_params" => !params.empty? || params_rest,
-            "params" => params, "params_rest" => params_rest,
-            "controller" => "CatalogQuery", "action" => js_id
-          }
-        end
-
-        let(:union) { "string | number | boolean | null" }
-
-        it "emits a typed params object (required + optional, declaration order)" do
-          out = described_class.render(version: 2, generated_at: "t", functions: [
-                                         typed_query("searchUsers", "/q/searchUsers", params: [
-                                                       { "name" => "term", "required" => true },
-                                                       { "name" => "limit", "required" => false }
-                                                     ])
-                                       ])
-          expect(out).to include(
-            "export const searchUsers: (params: { term: #{union}; limit?: #{union} }) => Promise<unknown> ="
-          )
-        end
-
-        it "emits the bare () signature for a query with empty params + no rest" do
-          out = described_class.render(version: 2, generated_at: "t", functions: [
-                                         typed_query("categories", "/q/categories", params: [])
-                                       ])
-          expect(out).to include("export const categories: () => Promise<unknown> =")
-        end
-
-        it "intersects named keys with Record<string, unknown> for a **keyrest query" do
-          out = described_class.render(version: 2, generated_at: "t", functions: [
-                                         typed_query("withRest", "/q/withRest",
-                                                     params: [{ "name" => "scope", "required" => true }],
-                                                     params_rest: true)
-                                       ])
-          expect(out).to include(
-            "export const withRest: (params: { scope: #{union} } & Record<string, unknown>) => Promise<unknown> ="
-          )
-        end
-
-        it "keeps the open Record<string, unknown> for a **keyrest-only query" do
-          out = described_class.render(version: 2, generated_at: "t", functions: [
-                                         typed_query("restOnly", "/q/restOnly", params: [], params_rest: true)
-                                       ])
-          expect(out).to include(
-            "export const restOnly: (params: Record<string, unknown>) => Promise<unknown> ="
-          )
-        end
-
-        it "quotes a param key that is not a valid bare JS identifier" do
-          out = described_class.render(version: 2, generated_at: "t", functions: [
-                                         typed_query("oddKey", "/q/oddKey",
-                                                     params: [{ "name" => "weird-key", "required" => false }])
-                                       ])
-          expect(out).to include("(params: { \"weird-key\"?: #{union} }) => Promise<unknown>")
-        end
-
-        it "falls back to the accepts_params boolean when no params metadata is present" do
-          out = described_class.render(version: 2, generated_at: "t", functions: [
-                                         { "js_identifier" => "legacyQuery", "kind" => "query",
-                                           "http_method" => "GET", "path" => "/q/legacyQuery",
-                                           "segments" => [], "accepts_params" => true }
-                                       ])
-          expect(out).to include(
-            "export const legacyQuery: (params: Record<string, unknown>) => Promise<unknown> ="
-          )
-        end
-
-        it "rejects params that are not an Array (trust boundary)" do
-          evil = typed_query("x", "/q/x", params: []).merge("params" => "oops")
-          expect { described_class.render(version: 2, generated_at: "t", functions: [evil]) }
-            .to raise_error(Ruact::ConfigurationError, /invalid.*params/)
-        end
-
-        it "rejects a params element that is not an object" do
-          evil = typed_query("x", "/q/x", params: ["nope"])
-          expect { described_class.render(version: 2, generated_at: "t", functions: [evil]) }
-            .to raise_error(Ruact::ConfigurationError, /params element that is not an object/)
-        end
-
-        it "rejects a params name containing a line break (TS injection guard)" do
-          evil = typed_query("x", "/q/x", params: [{ "name" => "a\n// injected", "required" => true }])
-          expect { described_class.render(version: 2, generated_at: "t", functions: [evil]) }
-            .to raise_error(Ruact::ConfigurationError, /non-empty single-line String/)
-        end
-
-        it "rejects a params name that is empty" do
-          evil = typed_query("x", "/q/x", params: [{ "name" => "", "required" => true }])
-          expect { described_class.render(version: 2, generated_at: "t", functions: [evil]) }
-            .to raise_error(Ruact::ConfigurationError, /non-empty single-line String/)
-        end
-
-        it "rejects a non-Boolean required" do
-          evil = typed_query("x", "/q/x", params: [{ "name" => "q", "required" => "yes" }])
-          expect { described_class.render(version: 2, generated_at: "t", functions: [evil]) }
-            .to raise_error(Ruact::ConfigurationError, /non-Boolean .*required/)
-        end
-
-        it "rejects a non-Boolean params_rest (would silently over-widen the type)" do
-          evil = typed_query("x", "/q/x", params: []).merge("params_rest" => "true")
-          expect { described_class.render(version: 2, generated_at: "t", functions: [evil]) }
-            .to raise_error(Ruact::ConfigurationError, /non-Boolean params_rest/)
-        end
-
-        it "accepts a legitimate required: false (not mis-read as absent)" do
-          expect do
-            described_class.render(version: 2, generated_at: "t", functions: [
-                                     typed_query("q1", "/q/q1", params: [{ "name" => "limit", "required" => false }])
-                                   ])
-          end.not_to raise_error
-        end
-
-        it "is byte-stable: regenerating a typed-query snapshot writes nothing the second pass" do
-          Dir.mktmpdir do |dir|
-            path = File.join(dir, "server-functions.ts")
-            snapshot = { version: 2, generated_at: "t", functions: [
-              typed_query("searchUsers", "/q/searchUsers", params: [
-                            { "name" => "term", "required" => true },
-                            { "name" => "limit", "required" => false }
-                          ])
-            ] }
-            expect(described_class.generate_ts!(snapshot: snapshot, output_path: path)).to be(true)
-            expect(described_class.generate_ts!(snapshot: snapshot, output_path: path)).to be(false)
-          end
-        end
-      end
-    end
-  end
-end

data/spec/ruact/server_functions/error_payload_spec.rb

@@ -1,222 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-require "ruact/server_functions/error_payload"
-
-module Ruact
-  module ServerFunctions
-    RSpec.describe ErrorPayload, :story_8_4 do
-      let(:gem_root) { "/tmp/ruact-test-gem" }
-
-      before { allow(Ruact).to receive(:gem_path).and_return(gem_root) }
-
-      # Build an exception whose `.class.name` is spoofed so the spec can
-      # exercise the RecordInvalid path without requiring ActiveRecord.
-      def build_record_invalid(full_messages: ["Title can't be blank"])
-        record = Object.new
-        errors = Object.new
-        record.define_singleton_method(:errors) { errors }
-        errors.define_singleton_method(:full_messages) { full_messages }
-
-        klass = Class.new(StandardError) do
-          attr_reader :record
-          define_singleton_method(:name) { "ActiveRecord::RecordInvalid" }
-          def initialize(record, message)
-            super(message)
-            @record = record
-          end
-        end
-        err = klass.new(record, "Validation failed: Title can't be blank")
-        err.set_backtrace([
-                            "/Users/dev/host/app/controllers/posts_controller.rb:12:in `create'",
-                            "#{gem_root}/lib/ruact/server_functions/endpoint_controller.rb:111:in `dispatch'"
-                          ])
-        err
-      end
-
-      describe ".build in :development mode" do
-        let(:error) { build_record_invalid }
-
-        subject(:payload) do
-          described_class.build(action_name: :create_post, error: error, mode: :development)
-        end
-
-        it "carries the discriminator" do
-          expect(payload["_ruact_server_action_error"]).to be(true)
-        end
-
-        it "exposes the action name as a string (symbol input is coerced)" do
-          expect(payload["action_name"]).to eq("create_post")
-        end
-
-        it "exposes the error class as a string" do
-          expect(payload["error_class"]).to eq("ActiveRecord::RecordInvalid")
-        end
-
-        it "exposes the error message" do
-          expect(payload["message"]).to eq("Validation failed: Title can't be blank")
-        end
-
-        it "splits the backtrace into app_frames and gem_frames" do
-          expect(payload["app_frames"]).to contain_exactly(
-            a_string_including("posts_controller.rb:12")
-          )
-          expect(payload["gem_frames"]).to contain_exactly(
-            a_string_including("endpoint_controller.rb:111")
-          )
-        end
-
-        it "extracts validation_errors from the record" do
-          expect(payload["validation_errors"]).to eq(["Title can't be blank"])
-        end
-
-        it "extracts the contextual suggestion" do
-          expect(payload["suggestion"]).to eq("Validation failed — check the model's `validates` rules")
-        end
-      end
-
-      describe ".build in :production mode" do
-        let(:error) { build_record_invalid }
-
-        subject(:payload) do
-          described_class.build(action_name: :create_post, error: error, mode: :production)
-        end
-
-        it "carries the four baseline keys" do
-          expect(payload.keys).to contain_exactly(
-            "_ruact_server_action_error",
-            "action_name",
-            "error_class",
-            "message"
-          )
-        end
-
-        it "shares the four baseline values with the dev-mode payload" do
-          dev = described_class.build(action_name: :create_post, error: error, mode: :development)
-          payload.each_key do |key|
-            expect(payload[key]).to eq(dev[key])
-          end
-        end
-
-        it "ABSENT (not null): app_frames, gem_frames, suggestion, validation_errors" do
-          expect(payload).not_to have_key("app_frames")
-          expect(payload).not_to have_key("gem_frames")
-          expect(payload).not_to have_key("suggestion")
-          expect(payload).not_to have_key("validation_errors")
-        end
-      end
-
-      describe "validation_errors edge cases (dev mode)" do
-        it "is [] when RecordInvalid was constructed without a record" do
-          klass = Class.new(StandardError) do
-            attr_reader :record
-            define_singleton_method(:name) { "ActiveRecord::RecordInvalid" }
-            def initialize
-              super("boom")
-              @record = nil
-            end
-          end
-          payload = described_class.build(action_name: :x, error: klass.new, mode: :development)
-          expect(payload["validation_errors"]).to eq([])
-        end
-
-        it "is ABSENT (no key) when the error class is not RecordInvalid" do
-          payload = described_class.build(
-            action_name: :x,
-            error: RuntimeError.new("boom"),
-            mode: :development
-          )
-          expect(payload).not_to have_key("validation_errors")
-        end
-      end
-
-      describe "suggestion is null for unknown error classes (dev mode)" do
-        it "produces suggestion: nil for RuntimeError" do
-          payload = described_class.build(
-            action_name: :x,
-            error: RuntimeError.new("boom"),
-            mode: :development
-          )
-          expect(payload["suggestion"]).to be_nil
-        end
-      end
-
-      describe "Pitfall #5 — frozen-string error message safety" do
-        it "does not raise FrozenError when the error message is frozen" do
-          err = StandardError.new("frozen msg".freeze)
-          expect do
-            described_class.build(action_name: :x, error: err, mode: :development)
-          end.not_to raise_error
-        end
-
-        it "stores a mutable dup of the message in the payload" do
-          err = StandardError.new("frozen msg".freeze)
-          payload = described_class.build(action_name: :x, error: err, mode: :development)
-          expect(payload["message"]).to eq("frozen msg")
-          expect(payload["message"]).not_to be_frozen
-        end
-      end
-
-      describe "Story 8.5 — UploadTooLargeError gets a dev-only upload_limit block", :story_8_5 do
-        let(:error) { Ruact::UploadTooLargeError.new(received_bytes: 11_534_336, limit_bytes: 10_485_760) }
-
-        it "exposes received_bytes and limit_bytes under upload_limit (dev mode)" do
-          payload = described_class.build(action_name: :upload_post, error: error, mode: :development)
-          expect(payload["upload_limit"]).to eq(
-            "received_bytes" => 11_534_336,
-            "limit_bytes" => 10_485_760
-          )
-        end
-
-        it "carries error_class as Ruact::UploadTooLargeError" do
-          payload = described_class.build(action_name: :upload_post, error: error, mode: :development)
-          expect(payload["error_class"]).to eq("Ruact::UploadTooLargeError")
-        end
-
-        it "extracts the upload-too-large suggestion from ErrorSuggestion" do
-          payload = described_class.build(action_name: :upload_post, error: error, mode: :development)
-          expect(payload["suggestion"]).to include("Increase Ruact.config.max_upload_bytes")
-        end
-
-        it "does NOT include upload_limit in :production mode (four baseline keys only)" do
-          payload = described_class.build(action_name: :upload_post, error: error, mode: :production)
-          expect(payload).not_to have_key("upload_limit")
-          expect(payload.keys).to contain_exactly(
-            "_ruact_server_action_error",
-            "action_name",
-            "error_class",
-            "message"
-          )
-        end
-
-        it "is ABSENT (no key) when the error class is not UploadTooLargeError" do
-          payload = described_class.build(
-            action_name: :x,
-            error: RuntimeError.new("boom"),
-            mode: :development
-          )
-          expect(payload).not_to have_key("upload_limit")
-        end
-      end
-
-      describe "backtrace edge cases (dev mode)" do
-        it "is { app_frames: [], gem_frames: [] } when backtrace is nil" do
-          err = StandardError.new("boom") # never raised => backtrace is nil
-          payload = described_class.build(action_name: :x, error: err, mode: :development)
-          expect(payload["app_frames"]).to eq([])
-          expect(payload["gem_frames"]).to eq([])
-        end
-
-        it "caps each bucket at MAX_FRAMES_PER_BUCKET frames" do
-          app_frames = Array.new(40) { |i| "/Users/dev/host/app/file_#{i}.rb:#{i}" }
-          gem_frames = Array.new(40) { |i| "#{gem_root}/lib/ruact/file_#{i}.rb:#{i}" }
-          err = StandardError.new("boom")
-          err.set_backtrace(app_frames + gem_frames)
-          payload = described_class.build(action_name: :x, error: err, mode: :development)
-          expect(payload["app_frames"].size).to eq(ErrorPayload::MAX_FRAMES_PER_BUCKET)
-          expect(payload["gem_frames"].size).to eq(ErrorPayload::MAX_FRAMES_PER_BUCKET)
-        end
-      end
-    end
-  end
-end