ruact 0.0.4 → 0.0.6

data/lib/ruact/server_functions/name_bridge.rb

@@ -48,30 +48,28 @@ module Ruact
       # Story 8.2 (2026-05-17 review patches R2 + R12) — names already
       # bound at the top of `app/javascript/.ruact/server-functions.ts`,
       # either by a helper re-export (`revalidate`, `useQuery`) or a runtime
-      # import (`_makeRef`, `_makeServerFunction`, `_makeQuery`). A
-      # `ruact_action :revalidate` / a query method `use_query` would emit a
+      # import (`_makeServerFunction`, `_makeQuery`). A server function /
+      # query method named `revalidate` (or `use_query`) would emit a
       # clashing `export const` / duplicate export next to the existing
       # binding and crash the generated module at load time. The rule fires
-      # at controller-class load / route-draw so the failure surfaces during
-      # boot, not at first request.
+      # at route-draw so the failure surfaces during boot, not at first request.
       # Story 9.5 added `_makeQuery` (the v2 query import) and `useQuery` (the
-      # query hook re-export) to this list.
+      # query hook re-export) to this list. Story 9.9 removed `_makeRef` (the
+      # demolished v1 runtime export).
       RESERVED_BY_RUACT = %w[
         _makeQuery
-        _makeRef
         _makeServerFunction
         revalidate
         useQuery
       ].to_set.freeze
 
       class << self
-        # @param symbol [Symbol, String] the Ruby identifier registered via
-        #   `ruact_action` / `ruact_query` (Phase 2 stories 8.1 and 9.1).
+        # @param symbol [Symbol, String] the Ruby identifier of a routed server
+        #   function (a mutation action name or a `Ruact::Query` method name).
         # @return [String] the corresponding JS identifier.
         # @raise [Ruact::ConfigurationError] when +symbol+ does not match the
         #   allowed shape, is all-underscores, or maps to a JS reserved word —
-        #   caught at controller load time so misnamed routes never reach
-        #   production.
+        #   caught at route-draw time so misnamed routes never reach production.
         # @example
         #   Ruact::ServerFunctions::NameBridge.to_js_identifier(:create_post)
         #   # => "createPost"
@@ -83,12 +81,12 @@ module Ruact
 
           unless str.match?(VALID_SYMBOL)
             raise Ruact::ConfigurationError,
-                  "ruact_action / ruact_query symbol :#{symbol} must match /^[a-z_][a-z0-9_]*$/"
+                  "ruact server-function name :#{symbol} must match /^[a-z_][a-z0-9_]*$/"
           end
 
           if str.match?(UNDERSCORE_ONLY)
             raise Ruact::ConfigurationError,
-                  "ruact_action / ruact_query symbol :#{symbol} cannot be composed " \
+                  "ruact server-function name :#{symbol} cannot be composed " \
                   "entirely of underscores (no semantic content)"
           end
 
@@ -98,16 +96,16 @@ module Ruact
 
           if RESERVED_JS_IDENTIFIERS.include?(js_id)
             raise Ruact::ConfigurationError,
-                  "ruact_action / ruact_query symbol :#{symbol} maps to JS reserved " \
-                  "word \"#{js_id}\" — pick a different Ruby symbol (e.g. :#{symbol}_action)"
+                  "ruact server-function name :#{symbol} maps to JS reserved " \
+                  "word \"#{js_id}\" — pick a different name (e.g. :#{symbol}_fn)"
           end
 
           if RESERVED_BY_RUACT.include?(js_id)
             raise Ruact::ConfigurationError,
-                  "ruact_action / ruact_query symbol :#{symbol} maps to \"#{js_id}\", " \
+                  "ruact server-function name :#{symbol} maps to \"#{js_id}\", " \
                   "which is already exported by the ruact runtime from " \
                   "`@/.ruact/server-functions` and would emit a duplicate export. " \
-                  "Pick a different Ruby symbol (e.g. :#{symbol}_action)."
+                  "Pick a different name (e.g. :#{symbol}_fn)."
           end
 
           js_id

data/lib/ruact/server_functions/query_source.rb

@@ -57,6 +57,10 @@ module Ruact
         #   `js_identifier`; shape: `js_identifier`, `kind` (always `"query"`),
         #   `http_method` (always `"GET"`), `path`, `segments` (always `[]`),
         #   `accepts_params` (Boolean — does the method declare kwargs?),
+        #   `params` (Array<Hash> — Story 13.4: one `{ "name" => String,
+        #   "required" => Boolean }` per declared `keyreq`/`key` keyword, in
+        #   declaration order; empty when none), `params_rest` (Boolean —
+        #   Story 13.4: does the method declare a `**keyrest`?),
         #   `controller` (the query class name — for collision origins),
         #   `action` (the Ruby method name).
         # @raise [Ruact::ConfigurationError] on a query×query naming collision.
@@ -84,27 +88,50 @@ module Ruact
         private
 
         def build_entry(route, action, query_class)
+          params, params_rest = param_metadata(query_class, action)
           {
             "js_identifier" => NameBridge.to_js_identifier(action),
             "kind" => "query",
             "http_method" => "GET",
             "path" => clean_path(route),
             "segments" => [],
-            "accepts_params" => accepts_params?(query_class, action),
+            # Story 13.4 — keep `accepts_params` (derived) for back-compat: any
+            # named kwarg OR a `**keyrest` means the accessor takes params.
+            "accepts_params" => !params.empty? || params_rest,
+            "params" => params,
+            "params_rest" => params_rest,
             "controller" => query_class.name,
             "action" => action
           }
         end
 
-        # Does the query method declare any keyword arguments (FR88 params)?
-        # Drives the emitted TS signature: `(params) => Promise<unknown>` when
-        # true, `() => Promise<unknown>` when false (AC1).
-        def accepts_params?(query_class, action)
-          query_class.instance_method(action).parameters.any? do |(type, _name)|
-            KEYWORD_PARAM_TYPES.include?(type)
+        # Story 13.4 — per-kwarg metadata driving the typed TS `params` object
+        # (AC1). Reflects `Method#parameters` (names + required/optional only —
+        # Ruby exposes no types/defaults): `:keyreq` → required prop, `:key` →
+        # optional prop (both in declaration order, the stable order
+        # `parameters` returns), `:keyrest` (`**opts`) → an open-record marker
+        # so a legitimate dynamic key is never narrowed away (fail open).
+        # Positional/block params are not FR88 query params and are ignored.
+        #
+        # @param query_class [Class]
+        # @param action [String]
+        # @return [Array(Array<Hash>, Boolean)] the per-kwarg descriptors and
+        #   whether a `**keyrest` is present.
+        def param_metadata(query_class, action)
+          params = []
+          rest = false
+          query_class.instance_method(action).parameters.each do |(type, name)|
+            next unless KEYWORD_PARAM_TYPES.include?(type)
+
+            if type == :keyrest
+              rest = true
+            else
+              params << { "name" => name.to_s, "required" => type == :keyreq }
+            end
           end
+          [params, rest]
         rescue NameError
-          false
+          [[], false]
         end
 
         # query×query collision — two mounted query classes whose methods map

data/lib/ruact/server_functions/route_source.rb

@@ -9,9 +9,8 @@ module Ruact
     #
     # The route table is the single source of truth (FR61): every non-GET routed
     # action on a controller that includes {Ruact::Server} is a callable server
-    # function. This module is the route-driven replacement for the v1 registry
-    # source consumed by {Ruact::ServerFunctions::Snapshot} — it reads routes,
-    # not `ruact_action` declarations.
+    # function. As of Story 9.9 this is the SOLE codegen source consumed by
+    # {Ruact::ServerFunctions::Snapshot} — it reads the drawn routes directly.
     #
     # Pure by construction: {.collect} takes the route set and two resolver
     # callables (host predicate + override lookup). The railtie passes the real
@@ -96,7 +95,7 @@ module Ruact
         # (after rename overrides) would emit two `export const` lines the same
         # name; fail loudly at boot naming BOTH origins so the dev knows exactly
         # which routes to disambiguate (via `ruact_function_name`). Mirrors the
-        # cross-registry collision raise in {Ruact::ServerFunctions::Snapshot}.
+        # merged-namespace collision raise in {Ruact::ServerFunctions}.
         def detect_collisions!(entries)
           entries.group_by { |entry| entry["js_identifier"] }.each do |js_id, group|
             next if group.size < 2

data/lib/ruact/server_functions/snapshot.rb

@@ -5,98 +5,19 @@ require "time"
 
 module Ruact
   module ServerFunctions
-    # Pure functions that build the JSON-shaped Hash representing both server-
-    # function registries. Serialized to `tmp/cache/ruact/server-functions.json`
-    # by {.generate!}; the Vite plugin reads that file and emits the TS module.
+    # Pure functions that build the JSON-shaped Hash representing the route-
+    # driven server-function bridge. Serialized to
+    # `tmp/cache/ruact/server-functions.json` by {.generate_v2!}; the Vite
+    # plugin reads that file and emits the TS module.
     #
-    # The "functions" array is sorted by `ruby_symbol` for deterministic output
-    # so that fingerprint comparisons (used by the write-if-changed guard) are
-    # stable across runs. Cross-registry JS-identifier collisions are detected
-    # here (the per-registry `Registry#register` only sees its own entries; a
-    # `ruact_action :foo` colliding with a `ruact_query :foo` is invisible to
-    # both registries in isolation).
+    # Story 9.9 — the v1 registry path was demolished; only the route-driven
+    # (version-2) schema remains.
     module Snapshot
-      # Bump only when the on-disk schema changes incompatibly. The Vite plugin
-      # must be updated in lockstep.
-      VERSION = 1
-
       # Story 9.3 — the route-driven snapshot schema. v2 entries are produced by
-      # {Ruact::ServerFunctions::RouteSource} (route table), not the registries.
+      # {Ruact::ServerFunctions::RouteSource} (route table), not registries.
       VERSION_V2 = 2
 
       class << self
-        # Builds the snapshot Hash for both registries. Pure. See also
-        # {.generate!} (writes to disk) and {.functions_payload} (fingerprint
-        # surface).
-        #
-        # @param action_registry [Ruact::ServerFunctions::Registry]
-        # @param query_registry  [Ruact::ServerFunctions::Registry]
-        # @param now [Time] timestamp to stamp into `generated_at` (UTC, ISO-8601).
-        # @return [Hash] the serializable snapshot.
-        # @raise [Ruact::ConfigurationError] when a JS identifier is registered
-        #   in both registries (cross-registry collision; see {.functions_payload}).
-        def dump(action_registry, query_registry, now: Time.now.utc)
-          {
-            version: VERSION,
-            generated_at: now.utc.iso8601,
-            functions: functions_payload(action_registry, query_registry)
-          }
-        end
-
-        # Returns the payload-only array of function entries, sorted by
-        # `ruby_symbol`. Used both inside {.dump} and as the fingerprint surface
-        # by {.generate!}'s short-circuit (so timestamp churn alone never causes
-        # a rewrite). Detects cross-registry JS-identifier collisions and
-        # raises before emitting — a `ruact_action :foo` and `ruact_query :foo`
-        # would emit two `export const foo` lines at codegen, which `tsc` rejects.
-        #
-        # @return [Array<Hash>] each entry has string keys per the JSON contract.
-        # @raise [Ruact::ConfigurationError] when the action and query registries
-        #   both contain entries that map to the same JS identifier.
-        def functions_payload(action_registry, query_registry)
-          combined = action_registry.entries.values + query_registry.entries.values
-          detect_cross_registry_collision!(combined)
-          combined.sort_by { |entry| entry.ruby_symbol.to_s }.map do |entry|
-            {
-              "ruby_symbol" => entry.ruby_symbol.to_s,
-              "js_identifier" => entry.js_identifier,
-              "kind" => entry.kind.to_s,
-              "controller" => describe_controller(entry.controller)
-            }
-          end
-        end
-
-        # Builds the snapshot and writes it to +path+, but only if the
-        # functions list differs from the on-disk snapshot. This is the central
-        # short-circuit that prevents `config.to_prepare` from rewriting the
-        # file on every request (Story 8.0a pitfall #1): the JSON's
-        # `generated_at` is freshly stamped only when the registry actually
-        # changed; otherwise the on-disk content stays byte-identical.
-        #
-        # The short-circuit compares **both** `version` and `functions` against
-        # the on-disk snapshot — a schema bump (`VERSION` increment) forces a
-        # rewrite even when the registry payload is unchanged, so the Vite
-        # plugin never reads a stale-version snapshot after a gem upgrade.
-        #
-        # @param action_registry [Ruact::ServerFunctions::Registry]
-        # @param query_registry  [Ruact::ServerFunctions::Registry]
-        # @param path [String, Pathname] absolute path to the snapshot JSON.
-        # @param now [Time] timestamp used when (and only when) the file is rewritten.
-        # @return [Boolean] true if the file was written; false if no change.
-        def generate!(action_registry:, query_registry:, path:, now: Time.now.utc)
-          new_functions = functions_payload(action_registry, query_registry)
-
-          existing_version, existing_functions = read_existing_snapshot(path)
-          return false if existing_version == VERSION && existing_functions == new_functions
-
-          snapshot = {
-            version: VERSION,
-            generated_at: now.utc.iso8601,
-            functions: new_functions
-          }
-          SnapshotWriter.write_if_changed!(path: path, content: "#{JSON.pretty_generate(snapshot)}\n")
-        end
-
         # Story 9.3 — wraps route-derived +entries+ into a version-2 snapshot
         # Hash (the shape {Codegen.render} dispatches on). Pure.
         #
@@ -110,11 +31,11 @@ module Ruact
           }
         end
 
-        # Story 9.3 — write-if-changed for the route-driven (v2) bridge. Mirrors
-        # {.generate!}: `generated_at` is freshly stamped only when the entries
-        # changed, so a stable route table never churns the file (and never
-        # re-triggers downstream TS rendering). A schema mismatch (`version`)
-        # forces a rewrite even when entries are unchanged.
+        # Story 9.3 — write-if-changed for the route-driven (v2) bridge.
+        # `generated_at` is freshly stamped only when the entries changed, so a
+        # stable route table never churns the file (and never re-triggers
+        # downstream TS rendering). A schema mismatch (`version`) forces a
+        # rewrite even when entries are unchanged.
         #
         # @param entries [Array<Hash>] from {RouteSource.collect}.
         # @param path [String, Pathname] absolute path to the v2 bridge JSON.
@@ -127,56 +48,8 @@ module Ruact
           SnapshotWriter.write_if_changed!(path: path, content: "#{JSON.pretty_generate(snapshot)}\n")
         end
 
-        # Story 9.3 — the Decision-#6 ownership primitive. True when the app has
-        # ANY v1 declaration (`ruact_action` / `ruact_query`). Story 9.8 consults
-        # this to decide whether route-driven codegen takes over the real
-        # `server-functions.ts`; in Story 9.3 the v2 codegen always writes the
-        # parallel `.next` target regardless, so this is informational here.
-        #
-        # @return [Boolean]
-        def v1_declarations?(action_registry, query_registry)
-          !(action_registry.entries.empty? && query_registry.entries.empty?)
-        end
-
         private
 
-        def detect_cross_registry_collision!(entries)
-          by_js_id = entries.group_by(&:js_identifier).select { |_, group| group.size >= 2 }
-          return if by_js_id.empty?
-
-          # If both rows are the same Ruby symbol it is a within-registry duplicate
-          # (caught by Registry#register's own collision detection). A genuine
-          # cross-registry collision is any group whose entries span more than
-          # one kind — i.e. one action + one query share the same js_identifier.
-          cross = by_js_id.find do |_, group|
-            kinds = group.map(&:kind).uniq
-            kinds.size > 1
-          end
-          return unless cross
-
-          js_id, group = cross
-          # AC7 exact shape: `:foo_bar (in FooController) and :foo__bar (in BarController)`
-          # — no `kind:` annotation. The kind differentiation is implicit in
-          # the cross-registry collision being detected at all.
-          parts = group.map do |entry|
-            ":#{entry.ruby_symbol} (in #{describe_controller(entry.controller)})"
-          end
-          # AC7 shape: "[ruact] error: server-function naming collision: ..."
-          # The rake task wraps the bare message with "[ruact] error: " — keep
-          # the prefix in sync with the within-registry message in
-          # Registry#detect_collision! so the rake stdout reads identically
-          # for both kinds of collision.
-          raise Ruact::ConfigurationError,
-                "server-function naming collision: " \
-                "#{parts.join(' and ')} both map to JS identifier \"#{js_id}\""
-        end
-
-        def describe_controller(controller)
-          return nil if controller.nil?
-
-          controller.respond_to?(:name) && controller.name ? controller.name : controller.inspect
-        end
-
         # Reads `(version, functions)` from the on-disk snapshot. Returns
         # `[nil, nil]` when the file is missing, vanished between the stat and
         # the read (TOCTOU race fix — `File.exist?` removed; we catch `ENOENT`

data/lib/ruact/server_functions/validation_errors.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Ruact
+  module ServerFunctions
+    # Story 13.3 (FR98) — pure normalizer for the Inertia-style validation
+    # `errors` round-trip. Turns whatever a host action has on hand after a save
+    # attempt — an ActiveModel-ish record (responds to `#errors`), a raw
+    # `ActiveModel::Errors`, or a pre-shaped Hash — into ONE canonical wire
+    # shape — e.g. `"title" => ["Title can't be blank"]` and
+    # `"base" => ["is invalid overall"]` collected into one
+    # `Hash{String=>Array<String>}` — attribute names as strings (a
+    # `base`-level error keys under `"base"`), values arrays of human-readable
+    # **full messages**. A valid record (empty `#errors`) yields `{}`, never
+    # `nil`/`undefined`, so a single client code path handles both success and
+    # failure (the "always present" invariant of AC1).
+    #
+    # Pure: no `Rails` constant references at load, no `Ruact.config` / request
+    # reads — duck-typing only (mirrors the caller/builder split of
+    # {ErrorPayload} / {BucketTwoPayload}). The caller (`Ruact::Server#ruact_errors`)
+    # owns the per-request collector and the bucket/flash wiring; this module
+    # only answers "what is the canonical shape of this source?".
+    module ValidationErrors
+      class << self
+        # Normalize a validation-error source into the canonical Hash shape.
+        #
+        # Accepts, in precedence order:
+        #   - `nil` → `{}`
+        #   - a Hash already shaped `{attr => [msgs]}` → keys coerced to String,
+        #     scalar values wrapped in a one-element Array, every message
+        #     coerced to String; idempotent on already-canonical input.
+        #   - an object responding to `#group_by_attribute` (a raw
+        #     `ActiveModel::Errors`) → grouped into `{attr => [full_message]}`.
+        #   - an object responding to `#errors` (an ActiveModel-ish record) →
+        #     normalized from its `#errors`.
+        #   - anything else → `{}` (no errors discoverable).
+        #
+        # @param source [nil, Hash, #group_by_attribute, #errors] the error source
+        # @return [Hash{String=>Array<String>}] the canonical, always-present shape
+        def normalize(source)
+          return {} if source.nil?
+          return normalize_hash(source) if source.is_a?(Hash)
+          return group_errors(source) if source.respond_to?(:group_by_attribute)
+          return normalize(source.errors) if source.respond_to?(:errors)
+
+          {}
+        end
+
+        private
+
+        # A raw `ActiveModel::Errors`: group its `Error` objects by attribute and
+        # render each as a full message (`"Title can't be blank"`).
+        def group_errors(errors)
+          errors.group_by_attribute.each_with_object({}) do |(attribute, attribute_errors), acc|
+            acc[attribute.to_s] = attribute_errors.map(&:full_message)
+          end
+        end
+
+        # A pre-shaped Hash: stringify keys, wrap scalar values in a one-element
+        # array, stringify every message. `Array()` makes a `nil` value collapse
+        # to `[]` and is a no-op on an existing Array (idempotent on canonical
+        # input).
+        def normalize_hash(hash)
+          hash.each_with_object({}) do |(key, value), acc|
+            acc[key.to_s] = Array(value).map(&:to_s)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruact/server_functions.rb

@@ -1,52 +1,48 @@
 # frozen_string_literal: true
 
-# Namespace for the server-functions subsystem (Story 8.0a — codegen surface that
-# emits app/javascript/.ruact/server-functions.ts from the gem-side registries).
+# Namespace for the server-functions subsystem (Story 8.0a — codegen surface
+# that emits app/javascript/.ruact/server-functions.ts from the Rails route
+# table). Story 9.9 demolished the v1 registry path; the route table is now the
+# sole source of truth.
 #
 # - {Ruact::ServerFunctions::NameBridge} — Ruby symbol → JS identifier translation
 #   (single source of truth; the Vite plugin reads the already-translated identifier
 #   from the JSON snapshot and emits it as-is).
-# - {Ruact::ServerFunctions::RegistryEntry} — immutable record for a single
-#   registered server function.
-# - {Ruact::ServerFunctions::Registry} — storage + register/clear + collision
-#   detection. Populated by Story 8.1 (`ruact_action`) and Story 9.1 (`ruact_query`).
-# - {Ruact::ServerFunctions::Snapshot} — pure function: registries → JSON-shaped Hash.
+# - {Ruact::ServerFunctions::RouteSource} — collects mutation (non-GET) actions
+#   from the drawn route table.
+# - {Ruact::ServerFunctions::QuerySource} — collects read queries from the
+#   `ruact_queries`-drawn GET routes.
+# - {Ruact::ServerFunctions::Snapshot} — pure function: route entries → JSON-shaped Hash.
 # - {Ruact::ServerFunctions::SnapshotWriter} — atomic, write-if-changed file I/O.
 # - {Ruact::ServerFunctions::Codegen} — snapshot Hash → TypeScript module string.
-#
-# Empty registries are valid (Story 8.0a ships them empty; 8.1 and 9.1 populate).
 require "json"
 
 module Ruact
   module ServerFunctions
     autoload :NameBridge,         "ruact/server_functions/name_bridge"
-    autoload :RegistryEntry,      "ruact/server_functions/registry_entry"
-    autoload :Registry,           "ruact/server_functions/registry"
     autoload :Snapshot,           "ruact/server_functions/snapshot"
     autoload :SnapshotWriter,     "ruact/server_functions/snapshot_writer"
     autoload :Codegen,            "ruact/server_functions/codegen"
     autoload :RouteSource,        "ruact/server_functions/route_source"
     autoload :QuerySource,        "ruact/server_functions/query_source"
     autoload :ErrorRendering,     "ruact/server_functions/error_rendering"
-    autoload :EndpointController, "ruact/server_functions/endpoint_controller"
-    autoload :StandaloneContext, "ruact/server_functions/standalone_context"
-    autoload :StandaloneDispatcher, "ruact/server_functions/standalone_dispatcher"
+    autoload :ValidationErrors,   "ruact/server_functions/validation_errors"
     autoload :QueryContext, "ruact/server_functions/query_context"
     autoload :QueryDispatch, "ruact/server_functions/query_dispatch"
 
-    # Story 9.3 — orchestrates the route-driven (v2) codegen target. Reads the
-    # route table via {RouteSource}, writes the version-2 bridge to the PARALLEL
-    # `.next` path (write-if-changed), and renders the inspection TS via the
-    # Ruby {Codegen} (Vite does not watch `.next`). Per AC5 the `.next` target is
-    # for parity tests + inspection only — never imported by application code —
-    # so the real `server-functions.ts` (v1, rendered by Vite) is untouched
-    # (AC6). The Decision-#6 ownership flip (zero v1 declarations → v2 owns the
-    # real file) is Story 9.8's job.
+    # Story 9.3 / 9.9 — orchestrates the route-driven (v2) codegen. Reads the
+    # route table via {RouteSource} + {QuerySource}, writes the version-2 bridge
+    # to the REAL path (write-if-changed), and renders the TS via the Ruby
+    # {Codegen}. As of Story 9.9 this is the SOLE writer of the real bridge —
+    # the v1 registry path and the parallel `.next` target were demolished
+    # (epic decision #6: route-driven codegen owns `server-functions.ts`
+    # unconditionally; the module path `@/.ruact/server-functions` never changed,
+    # so React imports are unchanged by construction).
     #
     # AC2 — transparency over silence: the exposed names are ALWAYS logged so a
     # routed non-GET action never becomes a callable server function silently.
     #
-    # Story 9.5 — the `entries` array now carries BOTH mutation actions (from
+    # Story 9.5 — the `entries` array carries BOTH mutation actions (from
     # {RouteSource}) and read queries (from {QuerySource}); they share ONE
     # merged JS namespace. {.detect_merged_namespace_collisions!} catches a
     # route×query clash (each source already catches its own intra-kind
@@ -64,8 +60,8 @@ module Ruact
       entries = (actions + queries).sort_by { |entry| entry["js_identifier"] }
       detect_merged_namespace_collisions!(entries)
 
-      json_path = root.join("tmp/cache/ruact/server-functions.next.json")
-      ts_path   = root.join("app/javascript/.ruact/server-functions.next.ts")
+      json_path = root.join("tmp/cache/ruact/server-functions.json")
+      ts_path   = root.join("app/javascript/.ruact/server-functions.ts")
 
       # Read back from the on-disk bridge (not a fresh dump) so a stable route
       # table never churns the timestamp baked into the rendered TS header.