ruact 0.0.13 → 0.0.15

data/vendor/javascript/vite-plugin-ruact/flight-client.test.mjs

@@ -36,6 +36,7 @@ import path from "node:path";
 import {
   buildTree,
   createFromFlightPayload,
+  createRowParser,
   clearPendingChunks,
 } from "./runtime/flight-client.js";
 
@@ -319,3 +320,133 @@ describe("Story 17.0a — the contract, driven by a gem-produced fixture", () =>
     expect(tree.props.posts).toEqual([{ id: 1, title: "$5 plan" }]);
   });
 });
+
+// Story 17-0d — every string of 1024+ bytes travels as a `T` row framed by its
+// BYTE length, with no trailing newline. The decoder split on "\n" and so lost
+// the root row: one long post body blanked the whole page. The fixtures are
+// what the Ruby serializer emits (spec/ruact/flight/text_framing_fixtures_spec.rb
+// writes and guards them).
+describe("text rows (Story 17-0d)", () => {
+  const FIXTURES = path.join(import.meta.dirname, "../../../spec/fixtures/flight");
+  const read = (name) => fs.readFileSync(path.join(FIXTURES, name));
+  const expected = JSON.parse(read("text_framing_expected.json").toString("utf8"));
+
+  const rowsOf = (chunks) => {
+    const rows = new Map();
+    const parser = createRowParser(({ id, row }) => rows.set(id, row));
+    for (const chunk of chunks) parser.push(chunk);
+    parser.end();
+    return rows;
+  };
+
+  it("decodes every value the serializer framed, byte for byte", () => {
+    const tree = createFromFlightPayload(read("text_framing.txt").toString("utf8"), MODULE_REGISTRY);
+    expect(tree).toEqual(expected);
+  });
+
+  it("puts long text inside Suspense content where the deferred row points", () => {
+    const tree = createFromFlightPayload(read("text_framing_suspense.txt").toString("utf8"), MODULE_REGISTRY);
+    const deferred = tree.props.children.type; // the already-arrived deferred row, wrapped
+    expect(deferred().props.children).toBe(expected.multibyte);
+  });
+
+  it("does not depend on where the network splits the bytes", () => {
+    const bytes = new Uint8Array(read("text_framing.txt"));
+    const whole = rowsOf([bytes]);
+
+    // Every single split point: inside ids, `T` lengths, text bodies and
+    // multibyte code points, and between rows.
+    for (let cut = 1; cut < bytes.length; cut += 1) {
+      const split = rowsOf([bytes.subarray(0, cut), bytes.subarray(cut)]);
+      expect(split).toEqual(whole);
+    }
+
+    // And one byte at a time.
+    expect(rowsOf([...bytes].map((b) => Uint8Array.of(b)))).toEqual(whole);
+  });
+
+  it("refuses a truncated text row instead of rendering part of the page", () => {
+    const bytes = new Uint8Array(read("text_framing.txt"));
+    const firstText = Buffer.from(bytes).indexOf(":T") + 10;
+    expect(() => rowsOf([bytes.subarray(0, firstText)])).toThrow(/Truncated Flight payload/);
+  });
+
+  it("refuses a malformed text length", () => {
+    const enc = new TextEncoder();
+    expect(() => rowsOf([enc.encode("1:Tzz,abc0:\"$T1\"\n")])).toThrow(/Malformed text row length/);
+  });
+
+  it("names a text reference whose row never arrived", () => {
+    expect(() => createFromFlightPayload('0:{"body":"$T7"}\n', MODULE_REGISTRY))
+      .toThrow(/Text row 7 is referenced but was never received/);
+  });
+
+  it("skips a stray line without a colon instead of losing the row after it", () => {
+    const rows = rowsOf([new TextEncoder().encode('garbage\n0:{"a":1}\n')]);
+    expect(rows.get(0)).toEqual({ kind: "model", value: { a: 1 } });
+  });
+
+  it("reads a large row arriving in small chunks in linear time", () => {
+    const big = JSON.stringify({ items: Array.from({ length: 60000 }, (_, i) => ({ id: i, name: `item ${i}` })) });
+    const bytes = new TextEncoder().encode(`0:${big}\n`);
+    const chunks = [];
+    for (let i = 0; i < bytes.length; i += 4096) chunks.push(bytes.subarray(i, i + 4096));
+    const started = performance.now();
+    const rows = rowsOf(chunks);
+    expect(rows.get(0).value.items).toHaveLength(60000);
+    // ~2.3 MB in 4 KB chunks; quadratic re-copying took seconds.
+    expect(performance.now() - started).toBeLessThan(1000);
+  });
+
+  it("still reads a last row that lost its trailing newline", () => {
+    const rows = rowsOf([new TextEncoder().encode('0:{"a":1}')]);
+    expect(rows.get(0)).toEqual({ kind: "model", value: { a: 1 } });
+  });
+});
+
+// Story 17-0c — the serializer emits Ruby Time/DateTime as "$D<ISO>" and
+// integers beyond ±(2^53 − 1) as "$n<decimal>". Components got the marker
+// strings. The fixture is the Ruby serializer's own output
+// (spec/ruact/flight/scalar_fixtures_spec.rb writes and guards it).
+describe("dates and big integers (Story 17-0c)", () => {
+  const FIXTURES = path.join(import.meta.dirname, "../../../spec/fixtures/flight");
+  const payload = fs.readFileSync(path.join(FIXTURES, "scalar_round_trip.txt"), "utf8");
+  const expected = JSON.parse(fs.readFileSync(path.join(FIXTURES, "scalar_round_trip_expected.json"), "utf8"));
+
+  // Expected JSON tags what JSON cannot hold: { date: ISO } and { bigint: "…" }.
+  const revive = (value) => {
+    if (Array.isArray(value)) return value.map(revive);
+    if (value && typeof value === "object") {
+      if ("date" in value) return new Date(value.date);
+      if ("bigint" in value) return BigInt(value.bigint);
+      return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, revive(v)]));
+    }
+    return value;
+  };
+
+  it("rebuilds every value with its JS type, nested ones included", () => {
+    const tree = createFromFlightPayload(payload, MODULE_REGISTRY);
+    expect(tree).toEqual(revive(expected));
+  });
+
+  it("gives a Date the same instant, offset applied, to the millisecond", () => {
+    const tree = createFromFlightPayload(payload, MODULE_REGISTRY);
+    expect(tree.time).toBeInstanceOf(Date);
+    expect(tree.time.toISOString()).toBe("2026-09-08T12:30:45.123Z");
+    expect(tree.zoned.toISOString()).toBe("2026-09-08T12:30:00.000Z");
+  });
+
+  it("keeps safe integers as numbers and only the unsafe ones as BigInt", () => {
+    const tree = createFromFlightPayload(payload, MODULE_REGISTRY);
+    expect(typeof tree.max_safe).toBe("number");
+    expect(typeof tree.min_safe).toBe("number");
+    expect(typeof tree.big).toBe("bigint");
+    expect(tree.big).toBe(9007199254740993n);
+    expect(tree.negative_big).toBe(-18446744073709551616n);
+  });
+
+  it("leaves a literal string that starts with $D a string", () => {
+    const tree = createFromFlightPayload(payload, MODULE_REGISTRY);
+    expect(tree.literal).toBe("$D2026-01-01 is a string");
+  });
+});

data/vendor/javascript/vite-plugin-ruact/ruact-router.test.mjs

@@ -11,6 +11,8 @@
 // classifier is never a silent no-op; and a Flight response still renders.
 
 import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import fs from "node:fs";
+import path from "node:path";
 import { setupRouter, teardownRouter } from "./runtime/ruact-router.js";
 
 const ORIGIN = "http://localhost:3000";
@@ -431,3 +433,85 @@ describe("ruact-router — the navigation boundary (Story 17.0f)", () => {
     });
   });
 });
+
+// Story 17-0d — a navigation reads the same byte parser as the initial load.
+// The stream is cut inside a `T` length, inside a multibyte code point and
+// inside a text body; the page must still render with the exact text.
+describe("ruact-router — long text in a streamed navigation (Story 17-0d)", () => {
+  const FIXTURES = path.join(import.meta.dirname, "../../../spec/fixtures/flight");
+  let dom;
+  let onNavigate;
+  let onError;
+
+  beforeEach(() => {
+    dom = installDom();
+    onNavigate = vi.fn();
+    onError = vi.fn();
+    globalThis.fetch = vi.fn();
+    vi.spyOn(console, "error").mockImplementation(() => {});
+    setupRouter({ onNavigate, moduleRegistry: {}, onError });
+  });
+
+  afterEach(() => {
+    teardownRouter();
+    vi.restoreAllMocks();
+  });
+
+  it("renders every framed string, whatever the chunk boundaries", async () => {
+    const bytes = new Uint8Array(fs.readFileSync(path.join(FIXTURES, "text_framing.txt")));
+    const expected = JSON.parse(fs.readFileSync(path.join(FIXTURES, "text_framing_expected.json"), "utf8"));
+    const firstLength = Buffer.from(bytes).indexOf(":T") + 3;      // inside the first hex length
+    const multibyte = Buffer.from(bytes).indexOf(Buffer.from("ç")) + 1; // between the two bytes of "ç"
+    const cuts = [0, firstLength, multibyte, multibyte + 700, bytes.length];
+    const body = new ReadableStream({
+      start(controller) {
+        for (let i = 0; i < cuts.length - 1; i += 1) controller.enqueue(bytes.slice(cuts[i], cuts[i + 1]));
+        controller.close();
+      },
+    });
+    const headers = new Headers({ "content-type": "text/x-component" });
+    fetch.mockResolvedValue({ ok: true, status: 200, statusText: "200", url: `${ORIGIN}/posts`, headers, body });
+
+    click(dom.listeners, "/posts");
+    await settle();
+
+    expect(onError).not.toHaveBeenCalled();
+    expect(onNavigate).toHaveBeenCalledTimes(1);
+    expect(onNavigate.mock.calls[0][0]).toEqual(expected);
+  });
+});
+
+// Story 17-0c — a navigation decodes dates and big integers like the first load.
+describe("ruact-router — dates and big integers in a navigation (Story 17-0c)", () => {
+  const FIXTURES = path.join(import.meta.dirname, "../../../spec/fixtures/flight");
+  let dom;
+  let onNavigate;
+
+  beforeEach(() => {
+    dom = installDom();
+    onNavigate = vi.fn();
+    globalThis.fetch = vi.fn();
+    vi.spyOn(console, "error").mockImplementation(() => {});
+    setupRouter({ onNavigate, moduleRegistry: {}, onError: vi.fn() });
+  });
+
+  afterEach(() => {
+    teardownRouter();
+    vi.restoreAllMocks();
+  });
+
+  it("hands the component a Date and a BigInt", async () => {
+    const body = fs.readFileSync(path.join(FIXTURES, "scalar_round_trip.txt"), "utf8");
+    fetch.mockResolvedValue(respond({ body, url: `${ORIGIN}/events` }));
+
+    click(dom.listeners, "/events");
+    await settle();
+
+    const tree = onNavigate.mock.calls[0][0];
+    expect(tree.time).toBeInstanceOf(Date);
+    expect(tree.time.toISOString()).toBe("2026-09-08T12:30:45.123Z");
+    expect(tree.big).toBe(9007199254740993n);
+    expect(tree.nested.ids).toEqual([1152921504606846976n, 7]);
+  });
+});
+

data/vendor/javascript/vite-plugin-ruact/runtime/flight-client.js

@@ -4,6 +4,19 @@
  * Handles the subset we emit from the Ruby server:
  *   - Model rows:  <hex_id>:<json>\n
  *   - Import rows: <hex_id>:I[moduleId, exportName, chunks]\n
+ *   - Error rows:  <hex_id>:E<json>\n
+ *   - Text rows:   <hex_id>:T<hex_byte_length>,<utf-8 text>   (NO newline)
+ *
+ * Every string of 1024 bytes or more travels as a text row, framed by its
+ * byte length, and is referenced from a model row as "$T<hex_id>". Both the
+ * initial load and the router read rows through ONE incremental byte parser
+ * ({@link createRowParser}), so a payload decodes the same whichever way it
+ * arrives and wherever the network splits it.
+ *
+ * Values JSON cannot hold travel as "$"-prefixed strings and are rebuilt:
+ * "$D<ISO 8601>" → Date, "$n<decimal>" → BigInt, "$NaN"/"$Infinity"/… →
+ * the number, "$undefined" → undefined. A literal string that starts with
+ * "$" arrives escaped as "$$…".
  *
  * Returns a React element tree by recursively converting
  * ["$", type, key, props] tuples into React.createElement calls.
@@ -72,6 +85,7 @@ export function parseLine(line) {
 
   const colonIdx = line.indexOf(":");
   if (colonIdx === -1) return null;
+  if (colonIdx === 0) return null; // hint row (":H…") — a preload signal, no id
 
   const id   = parseInt(line.slice(0, colonIdx), 16);
   const rest = line.slice(colonIdx + 1);
@@ -97,6 +111,140 @@ export function parseLine(line) {
   }
 }
 
+// ---------------------------------------------------------------------------
+// Incremental row parser (bytes in, rows out)
+// ---------------------------------------------------------------------------
+
+const COLON   = 0x3a;
+const COMMA   = 0x2c;
+const NEWLINE = 0x0a;
+const TAG_T   = 0x54;
+const HEX     = /^[0-9a-fA-F]+$/;
+
+const utf8 = new TextDecoder("utf-8");
+
+/**
+ * An incremental Flight row parser. Feed it the payload's bytes in any number
+ * of chunks — split anywhere, including inside a header, a length or a UTF-8
+ * code point — and it calls `onRow({ id, row })` once per complete row.
+ *
+ * Text rows are framed by their BYTE length, so the parser works on bytes,
+ * never on decoded strings: a string's `length` counts UTF-16 units and would
+ * misread any non-ASCII text.
+ *
+ * `end()` must be called when the input is complete. A truncated text row or
+ * a malformed length throws instead of yielding a partial payload.
+ *
+ * @param {(parsed: { id: number, row: object }) => void} onRow
+ * @returns {{ push(bytes: Uint8Array): void, end(): void }}
+ */
+export function createRowParser(onRow) {
+  // A growable byte buffer: `buf[pos, len)` is what is not parsed yet. It
+  // grows by doubling and is compacted only when full, so a large row arriving
+  // in many small chunks costs linear time, not a copy per chunk.
+  let buf = new Uint8Array(4096);
+  let len = 0;
+  let pos = 0;
+  // How far the newline search for the row at `pos` already got, so a long
+  // model row is not re-scanned from its start on every chunk.
+  let scanned = 0;
+
+  const append = (bytes) => {
+    if (len + bytes.length > buf.length) {
+      const rest = len - pos;
+      if (rest + bytes.length <= buf.length) {
+        buf.copyWithin(0, pos, len);
+      } else {
+        let capacity = buf.length * 2;
+        while (capacity < rest + bytes.length) capacity *= 2;
+        const next = new Uint8Array(capacity);
+        next.set(buf.subarray(pos, len));
+        buf = next;
+      }
+      scanned = Math.max(0, scanned - pos);
+      len = rest;
+      pos = 0;
+    }
+    buf.set(bytes, len);
+    len += bytes.length;
+  };
+
+  const advance = (to) => {
+    pos = to;
+    scanned = 0;
+  };
+
+  // Parses one row starting at `pos`. Returns false when it needs more bytes.
+  const step = () => {
+    const view  = buf.subarray(0, len);
+    const colon = view.indexOf(COLON, pos);
+
+    // A line with no colon before its end is not a row (a stray line from a
+    // proxy, say): skip it rather than let it swallow the row after it.
+    const headerEnd = colon === -1 ? len : colon;
+    const stray = view.subarray(pos, headerEnd).indexOf(NEWLINE);
+    if (stray !== -1) {
+      advance(pos + stray + 1);
+      return true;
+    }
+    if (colon === -1 || colon + 1 >= len) return false;
+
+    const header = utf8.decode(view.subarray(pos, colon)).trim();
+
+    if (HEX.test(header) && view[colon + 1] === TAG_T) {
+      const comma = view.indexOf(COMMA, colon + 2);
+      if (comma === -1) return false;
+      const lengthHex = utf8.decode(view.subarray(colon + 2, comma));
+      if (!HEX.test(lengthHex)) {
+        throw new Error(`[flight-client] Malformed text row length "${lengthHex}" for row ${header}`);
+      }
+      const length = parseInt(lengthHex, 16);
+      const start  = comma + 1;
+      if (start + length > len) return false;
+      onRow({ id: parseInt(header, 16), row: { kind: "text", value: utf8.decode(view.subarray(start, start + length)) } });
+      advance(start + length);
+      return true;
+    }
+
+    const newline = view.indexOf(NEWLINE, Math.max(colon + 1, scanned));
+    if (newline === -1) {
+      scanned = len;
+      return false;
+    }
+    const parsed = parseLine(utf8.decode(view.subarray(pos, newline)));
+    if (parsed) onRow(parsed);
+    advance(newline + 1);
+    return true;
+  };
+
+  return {
+    push(bytes) {
+      append(bytes);
+      while (pos < len) {
+        // Blank separators between rows carry nothing.
+        while (pos < len && (buf[pos] === NEWLINE || buf[pos] === 0x0d)) advance(pos + 1);
+        if (pos >= len || !step()) break;
+      }
+    },
+
+    end() {
+      const rest = utf8.decode(buf.subarray(pos, len));
+      if (!rest.trim()) return;
+      // A last model/import/error row without its trailing newline is complete
+      // as far as JSON can tell; a cut-off text row or header is not.
+      const colon = rest.indexOf(":");
+      const header = colon === -1 ? "" : rest.slice(0, colon).trim();
+      if (colon !== -1 && HEX.test(header) && rest[colon + 1] === "T") {
+        throw new Error(`[flight-client] Truncated Flight payload: text row ${header} is incomplete`);
+      }
+      const parsed = colon === -1 ? null : parseLine(rest);
+      if (!parsed) throw new Error(`[flight-client] Truncated Flight payload: "${rest.slice(0, 40)}"`);
+      onRow(parsed);
+      advance(len);
+    },
+  };
+}
+
 // ---------------------------------------------------------------------------
 // Tree building
 // ---------------------------------------------------------------------------
@@ -136,11 +284,10 @@ export function buildTree(value, rows, moduleRegistry) {
  * @param {Object}  moduleRegistry
  */
 export function createFromFlightPayload(payload, moduleRegistry) {
-  const rows = new Map();
-  for (const line of payload.split("\n")) {
-    const parsed = parseLine(line);
-    if (parsed) rows.set(parsed.id, parsed.row);
-  }
+  const rows   = new Map();
+  const parser = createRowParser(({ id, row }) => rows.set(id, row));
+  parser.push(new TextEncoder().encode(payload));
+  parser.end();
   return buildTreeFromRows(rows, moduleRegistry);
 }
 
@@ -159,6 +306,21 @@ function _buildTree(value, rows, moduleRegistry) {
     if (value === "$Infinity")    return Infinity;
     if (value === "$-Infinity")   return -Infinity;
     if (value === "$-0")          return -0;
+    if (value.startsWith("$T")) {
+      const refId = parseInt(value.slice(2), 16);
+      const row   = rows.get(refId);
+      if (!row || row.kind !== "text") {
+        throw new Error(`[flight-client] Text row ${value.slice(2)} is referenced but was never received`);
+      }
+      return row.value;
+    }
+    // Story 17-0c — the serializer emits Ruby Time/DateTime as "$D<ISO 8601>"
+    // and integers outside JS's safe range as "$n<decimal>". The component
+    // gets the type, not the marker. (A literal string starting with "$" was
+    // escaped to "$$…" on the server and is handled above.)
+    if (value.startsWith("$D")) return new Date(value.slice(2));
+    // Guarded: a malformed marker must not throw and take the page down.
+    if (value.startsWith("$n") && /^-?\d+$/.test(value.slice(2))) return BigInt(value.slice(2));
     if (value.startsWith("$L")) {
       const refId = parseInt(value.slice(2), 16);
       const row   = rows.get(refId);

data/vendor/javascript/vite-plugin-ruact/runtime/ruact-router.js

@@ -10,7 +10,7 @@
  */
 
 import {
-  parseLine,
+  createRowParser,
   buildTreeFromRows,
   buildTree,
   resolvePendingChunk,
@@ -564,11 +564,10 @@ async function _processFlightResponse(response, {
   let   initialTreeSet = false;
   let   redirected     = false;
 
-  const processLine = (line) => {
-    const parsed = parseLine(line);
-    if (!parsed) return;
-
+  const processRow = (parsed) => {
     rows.set(parsed.id, parsed.row);
+    // A text row is data a model row points at; nothing renders on its own.
+    if (parsed.row.kind === "text") return;
 
     if (!initialTreeSet && rows.has(0)) {
       const rootRow = rows.get(0);
@@ -606,25 +605,17 @@ async function _processFlightResponse(response, {
     }
   };
 
-  const reader  = response.body.getReader();
-  const decoder = new TextDecoder();
-  let   buffer  = "";
+  // The same byte parser the initial load uses: text rows are framed by byte
+  // length, so the stream is never decoded line by line.
+  const parser = createRowParser(processRow);
+  const reader = response.body.getReader();
 
   while (true) {
     const { done, value } = await reader.read();
     if (done) break;
-
-    buffer += decoder.decode(value, { stream: true });
-
-    let newlineIdx;
-    while ((newlineIdx = buffer.indexOf("\n")) !== -1) {
-      processLine(buffer.slice(0, newlineIdx));
-      buffer = buffer.slice(newlineIdx + 1);
-    }
+    parser.push(value);
   }
-
-  // Handle any remaining content without a trailing newline
-  if (buffer.trim()) processLine(buffer);
+  parser.end();
 
   // Fallback: if row 0 never triggered (shouldn't happen with valid server)
   if (!initialTreeSet && !redirected && rows.has(0)) {

data/vendor/javascript/vite-plugin-ruact/tsconfig.scaffold-agnostic.json

@@ -1,6 +1,6 @@
 {
   "//": "Story 14.4 (AC5) — type-check the GENERATED design-system-AGNOSTIC `<Model>{List,Form,DeleteDialog}.tsx` fixtures in ISOLATION against an ambient stub (type-tests/scaffold/agnostic/ambient.d.ts) that declares ONLY React + @/.ruact/server-functions and NO @/components/ui/* module. A stray shadcn import would fail to resolve → the typecheck goes red, proving the agnostic default needs zero design-system resolution. Mirrors tsconfig.scaffold.json (the shadcn isolated typecheck), but scoped to the agnostic subdir so the two ambient stubs never merge. Run via `npm run typecheck`.",
-  "//noImplicitAny": "Relaxed ONLY here: native-element event handler params (e.g. `onChange={(e) => …}`) get no contextual type from the permissive ambient `JSX.IntrinsicElements` (no @types/react / lib:dom). The load-bearing types — PostRow, the typed `search` accessor (FR99), the required `posts` prop, the controlled DeleteDialog contract — are all EXPLICITLY annotated and stay fully checked under `strict`.",
+  "//noImplicitAny": "Relaxed ONLY here: native-element event handler params (e.g. `onChange={(e) => …}`) get no contextual type from the permissive ambient `JSX.IntrinsicElements` (no @types/react / lib:dom). The load-bearing types — PostRow, the typed `searchPosts` accessor (FR99), the required `posts` prop, the controlled DeleteDialog contract — are all EXPLICITLY annotated and stay fully checked under `strict`.",
   "compilerOptions": {
     "strict": true,
     "noImplicitAny": false,

data/vendor/javascript/vite-plugin-ruact/type-tests/scaffold/PostList.tsx

@@ -18,7 +18,7 @@
 // freshly scaffolded app will not resolve these until 10.5 lands; that is
 // expected (the end-to-end live demo is Story 10.7).
 import { useState } from "react";
-import { search as searchPosts, destroyPost, useQuery } from "@/.ruact/server-functions";
+import { searchPosts, destroyPost, useQuery } from "@/.ruact/server-functions";
 import { PostDeleteDialog } from "./PostDeleteDialog";
 import { Badge } from "@/components/ui/badge";
 import { Button } from "@/components/ui/button";
@@ -194,7 +194,7 @@ function RowActions({ record, onDeleted }: {
 }
 
 export function PostList({
-  posts = [],
+  posts: initialRows = [],
   emptyLabel = "No posts yet — create one.",
 }: { posts?: PostRow[]; emptyLabel?: string }) {
   const [q, setQ] = useState("");
@@ -215,7 +215,7 @@ export function PostList({
   // the box is idle and we fall back to the server-rendered rows.
   const { data: searchData, loading: searchLoading } = useQuery<PostRow[]>(searchPosts, { q: q.trim() });
 
-  const source = searching ? searchData ?? [] : posts;
+  const source = searching ? searchData ?? [] : initialRows;
   const rows = removedIds.length === 0 ? source : source.filter((row) => !removedIds.includes(row.id));
   // Always sort a COPY — never mutate the prop/source array.
   const sortedRows = sort ? [...rows].sort((a, b) => compareRows(a, b, sort)) : rows;

data/vendor/javascript/vite-plugin-ruact/type-tests/scaffold/agnostic/PostList.tsx

@@ -13,7 +13,7 @@
 // sort/pagination is Phase-3 territory. (The richer shadcn DataTable styling is
 // the opt-in `--shadcn` path — Story 14.5.)
 import { useState } from "react";
-import { search as searchPosts, destroyPost, useQuery } from "@/.ruact/server-functions";
+import { searchPosts, destroyPost, useQuery } from "@/.ruact/server-functions";
 import { PostDeleteDialog } from "./PostDeleteDialog";
 
 type PostRow = { id: number; title: string | null; body: string | null; published: boolean | null; views: number | null; published_on: string | null; published_at: string | null; author_id: number | null };
@@ -139,7 +139,7 @@ function RowActions({ record, onDeleted }: {
 }
 
 export function PostList({
-  posts = [],
+  posts: initialRows = [],
   emptyLabel = "No posts yet — create one.",
 }: { posts?: PostRow[]; emptyLabel?: string }) {
   const [q, setQ] = useState("");
@@ -160,7 +160,7 @@ export function PostList({
   // the box is idle and we fall back to the server-rendered rows.
   const { data: searchData, loading: searchLoading } = useQuery<PostRow[]>(searchPosts, { q: q.trim() });
 
-  const source = searching ? searchData ?? [] : posts;
+  const source = searching ? searchData ?? [] : initialRows;
   const rows = removedIds.length === 0 ? source : source.filter((row) => !removedIds.includes(row.id));
   // Always sort a COPY — never mutate the prop/source array.
   const sortedRows = sort ? [...rows].sort((a, b) => compareRows(a, b, sort)) : rows;

data/vendor/javascript/vite-plugin-ruact/type-tests/scaffold/agnostic/ambient.d.ts

@@ -53,10 +53,10 @@ declare module "@/.ruact/server-functions" {
   // FR88/FR99 wire union — the only param value type a query accessor accepts.
   type Wire = string | number | boolean | null;
 
-  // The codegen exports a generic `search` from `<Plural>Query#search(q:)`,
-  // typed from the declared `(q:)` kwarg (Story 13.4). The List aliases it
-  // `search<Plural>`.
-  export const search: (params: { q: Wire }) => Promise<unknown>;
+  // The codegen exports `searchPosts` from `PostsQuery#search_posts(q:)`,
+  // typed from the declared `(q:)` kwarg (Story 13.4). The scaffold names the
+  // query after the resource: query names share one namespace.
+  export const searchPosts: (params: { q: Wire }) => Promise<unknown>;
 
   // Action accessors the generated Form imports. Actions are NOT typed by FR99
   // (only queries are — Story 13.4 decision A), so the accessors take a loose

data/vendor/javascript/vite-plugin-ruact/type-tests/scaffold/ambient.d.ts

@@ -39,10 +39,10 @@ declare module "@/.ruact/server-functions" {
   // FR88/FR99 wire union — the only param value type a query accessor accepts.
   type Wire = string | number | boolean | null;
 
-  // The codegen exports a generic `search` from `<Plural>Query#search(q:)`,
-  // typed from the declared `(q:)` kwarg (Story 13.4). The List aliases it
-  // `search<Plural>`.
-  export const search: (params: { q: Wire }) => Promise<unknown>;
+  // The codegen exports `searchPosts` from `PostsQuery#search_posts(q:)` —
+  // the scaffold names the query after the resource, because query names
+  // share one namespace across every query class.
+  export const searchPosts: (params: { q: Wire }) => Promise<unknown>;
 
   // Action accessors the generated Form imports (Story 10.3). Actions are NOT
   // typed by FR99 (only queries are — Story 13.4 decision A), so the accessors

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruact
 version: !ruby/object:Gem::Version
-  version: 0.0.13
+  version: 0.0.15
 platform: ruby
 authors:
 - Luiz Garcia
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-09-28 00:00:00.000000000 Z
+date: 2026-10-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
@@ -76,6 +76,7 @@ files:
 - lib/ruact/configuration.rb
 - lib/ruact/controller.rb
 - lib/ruact/controller/document_rendering.rb
+- lib/ruact/controller/format_negotiation.rb
 - lib/ruact/controller/page_rendering.rb
 - lib/ruact/controller/pages.rb
 - lib/ruact/doctor.rb
@@ -83,11 +84,13 @@ files:
 - lib/ruact/erb_preprocessor_hook.rb
 - lib/ruact/errors.rb
 - lib/ruact/flight.rb
+- lib/ruact/flight/js_date.rb
 - lib/ruact/flight/react_element.rb
 - lib/ruact/flight/renderer.rb
 - lib/ruact/flight/request.rb
 - lib/ruact/flight/row_emitter.rb
 - lib/ruact/flight/serializer.rb
+- lib/ruact/flight/utf8.rb
 - lib/ruact/html_converter.rb
 - lib/ruact/layout_source.rb
 - lib/ruact/manifest_resolver.rb
@@ -95,6 +98,7 @@ files:
 - lib/ruact/packaging.rb
 - lib/ruact/query.rb
 - lib/ruact/railtie.rb
+- lib/ruact/redirect_path.rb
 - lib/ruact/render_context.rb
 - lib/ruact/render_pipeline.rb
 - lib/ruact/routing.rb