From 60057e4777dc1b626812e3a9048c42bb388abfde Mon Sep 17 00:00:00 2001
From: Brian Love <brian@liveloveapp.com>
Date: Sat, 15 Aug 2026 18:49:36 -0700
Subject: [PATCH 1/3] test(website): drive tabBehavior="wrap-rows" in real
 engines, and correct the Tab claim
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

`wrap-rows` was a WCAG 2.1.2 keyboard trap — Tab and Shift+Tab consumed
unconditionally, clamped at both corners, 120 presses never out. The fix
was to RELEASE at the corners, and until now that fix rested on a jsdom
test. jsdom has no sequential focus order at all, so it can only say which
presses the surface calls `preventDefault()` on; "the grid did not consume
the press" and "focus left the grid" are different statements, and only the
second is the absence of a trap. No page on the site rendered a `wrap-rows`
grid, so nobody had ever driven the one configuration that used to trap.

Adds `/fixtures/tab-wrap-rows` (3 columns x 4 rows, `wrap-rows`, bracketed
by two text inputs) and a spec that asserts EXACT press counts in Chromium
and WebKit. Text inputs rather than buttons as sentinels: macOS keeps bare
buttons out of Safari's tab order while CI's Linux WebKit includes them, so
a button sentinel pins an operating system. Naming the landing element is
what distinguishes a one-press release from a lap of the document.

Measured, identical in both engines:

- Tab from the top-left cell: 12 presses out — exactly rows x columns.
- Tab from mid-grid (r2,bravo): 8 presses out.
- Shift+Tab from the top-left cell: 1 press out.
- Shift+Tab from (r3,charlie): 9 presses out.
- Tab / Shift+Tab from a header cell, first column or last: 1 press, both
  directions.

So the header table's "in one press, whatever `tabBehavior` is set to" is
TRUE — it is scoped to the header, and the surface hands Tab back on a
header cell before it looks at the column index. What was false is the
page's opening summary, which promised "one more Tab leaves" without
qualification: under `wrap-rows` that is 8 and 12 presses on a grid of
twelve cells. That sentence now names the default and points at the walk,
the header row names its own scope, and the round-trip sentence says the
grid restores the cell it left FROM — the release corner, not where the
walk started.

Mutation-proved by restoring the corner clamp in `pretable-surface.tsx`:
10 of the 18 tests fail (5 per engine, `presses: null`), and the four
header tests per engine keep passing, which is correct — the header release
is a different branch. Reverted; no `packages/` change ships here.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
---
 .../app/fixtures/tab-wrap-rows/page.tsx       | 112 ++++++++
 apps/website/content/docs/grid/keyboard.mdx   |  17 +-
 apps/website/e2e/grid-tab-wrap-rows.spec.ts   | 261 ++++++++++++++++++
 3 files changed, 384 insertions(+), 6 deletions(-)
 create mode 100644 apps/website/app/fixtures/tab-wrap-rows/page.tsx
 create mode 100644 apps/website/e2e/grid-tab-wrap-rows.spec.ts

diff --git a/apps/website/app/fixtures/tab-wrap-rows/page.tsx b/apps/website/app/fixtures/tab-wrap-rows/page.tsx
new file mode 100644
index 00000000..513143d0
--- /dev/null
+++ b/apps/website/app/fixtures/tab-wrap-rows/page.tsx
@@ -0,0 +1,112 @@
+"use client";
+
+import { PretableSurface, type PretableColumn } from "@pretable/react";
+import { useMemo } from "react";
+
+/**
+ * Test fixture for `apps/website/e2e/grid-tab-wrap-rows.spec.ts`.
+ *
+ * `tabBehavior="wrap-rows"` was a WCAG 2.1.2 keyboard trap: it consumed Tab
+ * and Shift+Tab unconditionally and clamped at the two corners, so 120
+ * consecutive presses never left the grid in either engine. The fix was to
+ * RELEASE at the corners. Every claim the docs make about that release — that
+ * Tab eventually leaves forward, that Shift+Tab leaves backward, that a header
+ * cell leaves in one press — is a claim about a real browser's sequential
+ * focus order, and nothing on the docs site renders a `wrap-rows` grid to
+ * drive it in one.
+ *
+ * jsdom cannot stand in. It has no sequential focus order at all: `Tab` is an
+ * ordinary keydown there and nothing traverses unless a handler moves it by
+ * hand, so `packages/react/src/__tests__/tab-behavior.test.tsx` can only assert
+ * which presses the surface calls `preventDefault()` on. "Not prevented" and
+ * "focus actually left the grid" are different statements, and only the second
+ * one is the absence of a trap.
+ *
+ * ## Why it is laid out this way
+ *
+ * **Text inputs, not buttons, as the sentinels either side.** The exit tests
+ * assert *which element* focus landed on, and a bare `<button>` cannot carry
+ * that: macOS keeps bare buttons out of Safari's sequential tab order unless
+ * Full Keyboard Access is on, while Playwright's Linux WebKit in CI includes
+ * them — a button sentinel would pin somebody's operating system rather than
+ * this grid (the same split that failed CI in
+ * `grid-keyboard-a11y.spec.ts`). A text field is a tab stop in every engine
+ * under every setting.
+ *
+ * **A landing element at all, rather than "focus is no longer in the grid".**
+ * A tab walk wraps the document — WebKit laps a page several times in 30
+ * presses — so a counter that only asks "outside yet?" cannot tell a
+ * one-stop exit from a full lap back around. Naming the sentinel makes the
+ * lap visible.
+ *
+ * **Three columns and four rows.** A wrap-rows exit costs up to rows ×
+ * columns presses, so the shape is what makes the bound a number instead of
+ * "eventually": 12 cells means the walk from the entry cell to the release
+ * corner is exactly 12 presses, and a regression that clamps again cannot hide
+ * inside a generous limit. It is deliberately not the 140-row demo grid the
+ * keyboard docs use — that grid's corner is 1,000+ presses away, which is only
+ * assertable as a timeout.
+ *
+ * **Every row is inside `viewportHeight`.** Each press of the walk moves the
+ * focus address, and each move runs scroll-into-view; a shape taller than its
+ * viewport would put a scroll and a re-render between consecutive presses for
+ * no gain, since the corner release has nothing to do with virtualization.
+ *
+ * Deliberately not part of the product surface, and kept out of search engines:
+ * `wrap-rows` is not the default and this page is not advice.
+ */
+
+interface WrapRow {
+  id: string;
+  alpha: string;
+  bravo: string;
+  charlie: number;
+}
+
+// The next two are the shape the spec's press counts are derived from — four
+// rows by three columns — and the ids it addresses cells by. They are spelled
+// out again there rather than imported: a Next page module may not export
+// anything but its component and route config, so changing either here means
+// changing the constants at the top of grid-tab-wrap-rows.spec.ts too.
+const ROW_IDS = ["r1", "r2", "r3", "r4"] as const;
+
+const COLUMNS: PretableColumn<WrapRow>[] = [
+  { id: "alpha", header: "Alpha", widthPx: 120 },
+  { id: "bravo", header: "Bravo", widthPx: 120 },
+  { id: "charlie", header: "Charlie", type: "number", widthPx: 120 },
+];
+
+function makeRows(): WrapRow[] {
+  return ROW_IDS.map((id, i) => ({
+    id,
+    alpha: `A${i + 1}`,
+    bravo: i % 2 === 0 ? "West" : "East",
+    charlie: (i + 1) * 7,
+  }));
+}
+
+export default function TabWrapRowsFixturePage() {
+  const rows = useMemo(() => makeRows(), []);
+  const columns = useMemo(() => COLUMNS, []);
+  return (
+    <main style={{ padding: 24 }}>
+      <h1 style={{ fontSize: 18, marginBottom: 12 }}>Tab wrap-rows fixture</h1>
+      <p style={{ marginBottom: 12 }}>
+        <label htmlFor="before-grid">Before the grid </label>
+        <input id="before-grid" name="before-grid" type="text" />
+      </p>
+      <PretableSurface<WrapRow>
+        ariaLabel="Tab wrap-rows fixture grid"
+        columns={columns}
+        getRowId={(row) => row.id}
+        rows={rows}
+        tabBehavior="wrap-rows"
+        viewportHeight={320}
+      />
+      <p style={{ marginTop: 12 }}>
+        <label htmlFor="after-grid">After the grid </label>
+        <input id="after-grid" name="after-grid" type="text" />
+      </p>
+    </main>
+  );
+}
diff --git a/apps/website/content/docs/grid/keyboard.mdx b/apps/website/content/docs/grid/keyboard.mdx
index 32d8c336..802ef6d8 100644
--- a/apps/website/content/docs/grid/keyboard.mdx
+++ b/apps/website/content/docs/grid/keyboard.mdx
@@ -4,7 +4,7 @@ description: "Full keyboard contract — 2D arrow nav, shift-extend, cmd-jump, T
 nav: Grid
 ---
 
-`<PretableSurface>` ships the full ARIA grid keyboard pattern out of the box. The grid is a single tab stop — **header included**: one Tab enters it, the arrow keys navigate inside it, and one more Tab leaves. Nothing below needs additional wiring. `Cmd/Ctrl` is treated as either platform's primary modifier.
+`<PretableSurface>` ships the full ARIA grid keyboard pattern out of the box. The grid is a single tab stop — **header included**: one Tab enters it, and the arrow keys navigate inside it. On the default `tabBehavior="exit"` one more Tab leaves. [`"wrap-rows"`](#tabbehavior-config) spends Tab on the walk to a release corner instead, so from a body cell leaving costs up to rows × columns presses — though from the header it is one press either way, whichever behavior is set. Nothing below needs additional wiring. `Cmd/Ctrl` is treated as either platform's primary modifier.
 
 <Callout type="note">
   The header is part of the same roving group as the body, so the per-column
@@ -62,7 +62,7 @@ The header is a row of the same focus model, reached with `↑` from the first d
 | `Shift + Enter`       | Add this column to a multi-column sort, as shift-clicking does.                                      |
 | `Alt + ↓`             | Open this column's [filter](/docs/grid/filtering) popover. `Esc` closes it and returns focus here.   |
 | `Shift + F10`         | Open this column's menu, where one is offered. `ContextMenu` does the same.                          |
-| `Tab` / `Shift + Tab` | Leave the grid, in one press, whatever `tabBehavior` is set to.                                      |
+| `Tab` / `Shift + Tab` | Leave the grid in one press, `"wrap-rows"` included — the wrap walk is a body behavior.              |
 
 `Alt + ↓` is scoped to the header: on a data cell `Alt + ↓` is still an ordinary move-down, and no binding in the table above uses `Alt`.
 
@@ -91,12 +91,17 @@ Resizing and column reordering stay pointer affordances — there is no key for
 ```
 
 <Callout type="warning">
-  `"wrap-rows"` has to walk to a corner before it can release, which is up to
-  rows × columns presses. That is not a keyboard trap, but it is a long walk —
-  prefer the default on anything larger than a small, form-like grid.
+  `"wrap-rows"` has to walk to a corner before it can release, and that walk is
+  what Tab costs. Leaving **forward** from the top-left cell is exactly rows ×
+  columns presses — every cell in the grid — because that corner is the furthest
+  point from the forward release; leaving **backward** from the same cell is one
+  press, because it is the backward release corner. Every cell between the two
+  is somewhere in between. That is not a keyboard trap, but on anything larger
+  than a small, form-like grid it is a long enough walk to feel like one —
+  prefer the default there.
 </Callout>
 
-Both behaviors keep the grid a single tab stop, and both preserve the focused cell across a round trip: once Tab leaves, the grid remembers where it was, and coming back via Shift+Tab restores focus to that exact cell. From the header, `Tab` always releases — a header cell has no wrap walk to do.
+Both behaviors keep the grid a single tab stop, and both preserve the focused cell across a round trip: once Tab leaves, the grid remembers where it was, and coming back via Shift+Tab restores focus to the cell it left **from**. Under `"wrap-rows"` that is the release corner rather than wherever the walk started, since every press in between moved the cursor. From the header, `Tab` releases in one press in either direction, under both behaviors — a header cell has no wrap walk to do.
 
 ## Single tab stop / focus model
 
diff --git a/apps/website/e2e/grid-tab-wrap-rows.spec.ts b/apps/website/e2e/grid-tab-wrap-rows.spec.ts
new file mode 100644
index 00000000..e64fa53c
--- /dev/null
+++ b/apps/website/e2e/grid-tab-wrap-rows.spec.ts
@@ -0,0 +1,261 @@
+import { expect, test, type Page } from "@playwright/test";
+
+import { waitForGridReady } from "./helpers";
+
+/**
+ * `tabBehavior="wrap-rows"` is not a keyboard trap — driven with real Tab
+ * presses, in both engines. WCAG 2.1.2 regression guard.
+ *
+ * This configuration was a trap: it consumed Tab and Shift+Tab unconditionally
+ * and clamped at the two corners, so 120 consecutive presses never left the
+ * grid in either engine, and no key could get focus back out of the page. The
+ * fix was to RELEASE at the corners instead of clamping, and this file is the
+ * only place that claim is checked against a browser's own sequential focus
+ * order.
+ *
+ * It cannot be checked anywhere else. jsdom has no sequential focus order at
+ * all — `Tab` there is an ordinary keydown and nothing traverses unless a
+ * handler moves it by hand — so `packages/react/src/__tests__/
+ * tab-behavior.test.tsx` can only ask which presses the surface calls
+ * `preventDefault()` on. "The grid did not consume the press" and "focus left
+ * the grid" are different statements, and only the second is the absence of a
+ * trap. And no page on the docs site renders a `wrap-rows` grid, which is why
+ * this drives `/fixtures/tab-wrap-rows` instead.
+ *
+ * Every count below is EXACT, not a ceiling. A trap regression re-clamps at a
+ * corner, and a generous `toBeLessThan` bound would be satisfied by a walk
+ * that spent its slack looping — the number is the assertion.
+ */
+
+const FIXTURE = "/fixtures/tab-wrap-rows";
+
+/** The fixture's shape. A wrap-rows exit costs at most this many presses. */
+const ROWS = 4;
+const COLUMNS = 3;
+const CELLS = ROWS * COLUMNS;
+
+/**
+ * Well past any legitimate count on a 3 x 4 grid, so a clamped corner shows up
+ * as `null` rather than as a timeout, and the failure message can say how far
+ * the walk actually got.
+ */
+const LIMIT = 40;
+
+/**
+ * Where DOM focus is, as one string.
+ *
+ * Naming the landing element is not decoration: a tab walk WRAPS THE DOCUMENT.
+ * WebKit laps a page several times in 30 presses, so a counter that only asks
+ * "outside the grid yet?" cannot tell a one-press release from a full lap back
+ * around to the same place. The fixture's two text inputs bracket the grid so
+ * that a forward release and a backward one are distinguishable, and `"NONE"`
+ * (`<body>` or nothing) marks the browser-chrome step of a lap.
+ */
+function focusLocation(page: Page): Promise<string> {
+  return page.evaluate(() => {
+    const active = document.activeElement;
+    // `null` and `<body>` both mean "no focus owner". Spelling this as
+    // `active?.closest(...) != null` inverts it — optional chaining yields
+    // `undefined`, which is not `null` — and a walk parked on `<body>` would
+    // then report itself as still inside the grid forever.
+    if (active === null || active === document.body) return "NONE";
+    if (active.id !== "") return `#${active.id}`;
+    const cell = active.closest("[data-pretable-cell]");
+    if (cell !== null) {
+      const rowId = cell
+        .closest("[data-pretable-row]")
+        ?.getAttribute("data-pretable-row-id");
+      return `cell:${rowId},${cell.getAttribute("data-pretable-column-id")}`;
+    }
+    const header = active.closest("[data-pretable-header-cell]");
+    if (header !== null) {
+      return `header:${header.getAttribute("data-pretable-column-id")}`;
+    }
+    const inGrid = active.closest("[data-pretable-scroll-viewport]") !== null;
+    return `${inGrid ? "ingrid" : "outside"}:${active.tagName.toLowerCase()}`;
+  });
+}
+
+function isInGrid(location: string): boolean {
+  return location.startsWith("cell:") || location.startsWith("header:");
+}
+
+/**
+ * Press `key` until focus is out of the grid, returning the press count and the
+ * element it landed on, plus the trace for the failure message.
+ */
+async function walkOut(page: Page, key: string) {
+  const trace: string[] = [];
+  for (let i = 1; i <= LIMIT; i++) {
+    await page.keyboard.press(key);
+    const at = await focusLocation(page);
+    trace.push(at);
+    if (!isInGrid(at)) return { presses: i, landedOn: at, trace };
+  }
+  return { presses: null, landedOn: null, trace };
+}
+
+/**
+ * Enter the grid the way a keyboard user does, and assert where that lands.
+ *
+ * Focus is established by KEYBOARD, never by a click, and that is load-bearing
+ * rather than tidy. Safari does not treat a mouse-or-programmatic focus as the
+ * sequential-navigation starting point, so a backward-exit test that started
+ * from a CLICKED cell measured stuck-for-120-presses in WebKit on a grid that
+ * releases in one press from the same cell reached by Tab. A keyboard-only
+ * user's trap is also the honest scenario for a keyboard-trap test.
+ */
+async function enterGrid(page: Page) {
+  await page.goto(FIXTURE, { waitUntil: "domcontentloaded" });
+  await waitForGridReady(page);
+  await page.locator("#before-grid").focus();
+  await page.keyboard.press("Tab");
+  // One press from outside puts the cursor on the top-left cell: the grid is a
+  // single tab stop, and an untouched grid hands the first press its entry
+  // cell. Every count below is measured from here, so it is asserted rather
+  // than assumed.
+  expect(await focusLocation(page)).toBe("cell:r1,alpha");
+}
+
+/** Move the cursor with the ARROW keys, which never leave the grid. */
+async function arrowTo(page: Page, moves: string[]) {
+  for (const move of moves) await page.keyboard.press(move);
+}
+
+test.describe("wrap-rows exit — WCAG 2.1.2 No Keyboard Trap", () => {
+  test("Tab walks to the bottom-right corner and releases, in exactly rows x columns presses", async ({
+    page,
+  }) => {
+    await enterGrid(page);
+
+    const { presses, landedOn, trace } = await walkOut(page, "Tab");
+
+    // The worst case for this configuration, and the number the docs quote:
+    // from the top-left cell, forward release costs rows x columns presses —
+    // 11 to walk the 12 cells, and a 12th that the grid hands back to the
+    // browser. Anything more is a clamp; anything less means the walk skipped
+    // cells.
+    expect({ presses, landedOn }).toEqual({
+      presses: CELLS,
+      landedOn: "#after-grid",
+    });
+
+    // The positive twin: a wrap-rows that released EVERYWHERE — i.e. did
+    // nothing at all — would leave the grid on press 1 and is the opposite
+    // failure. The walk has to actually wrap a row boundary.
+    expect(trace.slice(0, 3)).toEqual([
+      "cell:r1,bravo",
+      "cell:r1,charlie",
+      "cell:r2,alpha",
+    ]);
+  });
+
+  test("Shift+Tab releases at the top-left corner in one press", async ({
+    page,
+  }) => {
+    await enterGrid(page);
+
+    const { presses, landedOn } = await walkOut(page, "Shift+Tab");
+
+    // The entry cell IS the top-left corner, so there is no walk to do: the
+    // grid hands the very first press back. This is the corner that used to
+    // clamp — Shift+Tab sat on the first cell forever, consumed but doing
+    // nothing, with no key that could get focus out of the page.
+    expect({ presses, landedOn }).toEqual({
+      presses: 1,
+      landedOn: "#before-grid",
+    });
+  });
+
+  test("Shift+Tab from mid-grid walks back to the first cell and releases", async ({
+    page,
+  }) => {
+    await enterGrid(page);
+    // (r3, charlie) — row index 2, column index 2, so a backward release is 8
+    // walk presses plus the release.
+    await arrowTo(page, ["ArrowDown", "ArrowDown", "End"]);
+    expect(await focusLocation(page)).toBe("cell:r3,charlie");
+
+    const { presses, landedOn } = await walkOut(page, "Shift+Tab");
+
+    expect({ presses, landedOn }).toEqual({
+      presses: 2 * COLUMNS + 2 + 1,
+      landedOn: "#before-grid",
+    });
+  });
+
+  test("Tab from mid-grid walks forward to the last cell and releases", async ({
+    page,
+  }) => {
+    await enterGrid(page);
+    await arrowTo(page, ["ArrowDown", "ArrowRight"]);
+    expect(await focusLocation(page)).toBe("cell:r2,bravo");
+
+    const { presses, landedOn } = await walkOut(page, "Tab");
+
+    // From (row index 1, column index 1): two rows of remaining cells and one
+    // more in this row, then the release.
+    expect({ presses, landedOn }).toEqual({
+      presses: 2 * COLUMNS + 1 + 1,
+      landedOn: "#after-grid",
+    });
+  });
+});
+
+test.describe("wrap-rows exit — from the column header", () => {
+  // Both ends of the header, because the release is meant to be independent of
+  // where in the header the cursor is: the surface hands Tab back on a header
+  // cell before it ever looks at the column index. The last column is the one
+  // that would betray a walk — under the body's rule a last-column Tab wraps
+  // to the next row rather than releasing.
+  for (const [column, arrows] of [
+    ["alpha", ["ArrowUp"]],
+    ["charlie", ["End", "ArrowUp"]],
+  ] as const) {
+    test(`Tab leaves in one press from the ${column} header`, async ({
+      page,
+    }) => {
+      await enterGrid(page);
+      await arrowTo(page, [...arrows]);
+      expect(await focusLocation(page)).toBe(`header:${column}`);
+
+      const { presses, landedOn } = await walkOut(page, "Tab");
+      expect({ presses, landedOn }).toEqual({
+        presses: 1,
+        landedOn: "#after-grid",
+      });
+    });
+
+    test(`Shift+Tab leaves in one press from the ${column} header`, async ({
+      page,
+    }) => {
+      await enterGrid(page);
+      await arrowTo(page, [...arrows]);
+      expect(await focusLocation(page)).toBe(`header:${column}`);
+
+      const { presses, landedOn } = await walkOut(page, "Shift+Tab");
+      expect({ presses, landedOn }).toEqual({
+        presses: 1,
+        landedOn: "#before-grid",
+      });
+    });
+  }
+});
+
+test.describe("wrap-rows round trip", () => {
+  test("Shift+Tab back in restores the cell the walk released from", async ({
+    page,
+  }) => {
+    await enterGrid(page);
+    await arrowTo(page, ["ArrowDown", "ArrowRight"]);
+
+    const { landedOn } = await walkOut(page, "Tab");
+    expect(landedOn).toBe("#after-grid");
+
+    await page.keyboard.press("Shift+Tab");
+    // The grid remembers where it LEFT — the bottom-right corner it released
+    // from — not the cell the walk started at. Under `wrap-rows` those are
+    // different cells, which is the whole difference from the default.
+    expect(await focusLocation(page)).toBe("cell:r4,charlie");
+  });
+});

From 725ccbb89d56a4344ab48a7f72d2f29061acd8f1 Mon Sep 17 00:00:00 2001
From: Brian Love <brian@liveloveapp.com>
Date: Sat, 15 Aug 2026 19:09:33 -0700
Subject: [PATCH 2/3] fix(types): give the engine's declarations one emission,
 and delete the casts
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

`@pretable/core` bundles `@pretable-internal/grid-core` and
`@pretable-internal/row-model` (`noExternal`), so `tsup`'s bundled `.d.ts`
re-emits their declarations alongside the copies `tsc` writes into each
package's own `dist`. `@pretable/react` compiled against BOTH, and paid for it
with three casts in `pretable-model.ts`.

Two things made two emissions two types:

1. `unique symbol` brands, which are nominal PER DECLARATION FILE. Four were
   affected — `groupIdBrand`, `rowModelDescriptor`, `columnDescriptor`,
   `gridUiCoreType` — plus `rowLayoutControllerType` in renderer-dom, which had
   not leaked yet. All are now string-literal keys (`~pretableGroupId`), which
   are structural, so N copies are one type. Nominality is unchanged: the
   branded types are intersections nothing inhabits without a cast, and `~`
   cannot be written as an identifier. The silent half mattered more than the
   casts: `RowOf` / `RowIdOf` / `ColumnsOf` match structurally on the row-model
   brand and resolved to `never` across the seam with no diagnostic.

2. Deferred conditional types, which TypeScript relates by ALIAS IDENTITY —
   `PretableAggregateOutputOf<TAggregate>` cannot be fixed by any brand change.
   So the packages that compile alongside `@pretable/core` now reach the engine
   THROUGH it: `@pretable/react` imports `ɵcreateGridUiCore` and friends from
   `@pretable/core` rather than from `@pretable-internal/grid-core`, and
   `@pretable-internal/renderer-dom` types its row model from `@pretable/core`
   too. One declaration emission, and one runtime copy of the engine instead of
   two.

Also fixes the hand-copied `moveFocus` union: `PretableReactGrid.moveFocus`
imports `PretableIndexedFocusMovement` instead of respelling it (the copy was
two members behind and the repair had been a cast at the call site in
`pretable-surface.tsx`), the duplicated `{pageRows?: number}` becomes the new
`PretableIndexedMoveFocusOptions`, `pretable-surface.tsx` stops shadowing
`PretableFocusDirection` with a local copy and stops respelling
`PretableMoveFocusOptions`, and `PretableGridUiSnapshot` becomes an alias of
`PretableGridUiState` rather than a 74-line structural copy of it (which also
retires `PretableReactRowRange(Index)`, second names for
`PretableIndexedRowRange(Index)`).

Guards:
- `scripts/__tests__/public-api-symbol-brands.test.mjs` fails if a symbol-keyed
  brand reappears in any published API report; the package set is discovered
  from `api-extractor.json`, so a new package is covered the day it is added.
- `packages/react/src/__tests__/cross-emission-type-identity.types.ts` asserts
  the two emissions are the same types, including `RowOf` not collapsing.
- `type-tests/react/focus-movement-union.types.tsx` pins the movement union and
  its options to the engine's, in both directions.
- `packages/react/src/__tests__/move-focus-movements.test.tsx` asserts every
  movement still moves focus where it should, and that `pageRows` arrives.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
---
 package.json                                  |   2 +-
 packages/core/core.api.md                     |  57 ++++--
 packages/core/src/public_api.ts               |  22 +++
 packages/core/src/types.ts                    |   2 +
 packages/grid-core/src/create-grid-ui-core.ts |   8 +
 packages/grid-core/src/index.ts               |   1 +
 packages/grid-core/src/indexed-focus.ts       |   2 +
 packages/grid-core/src/indexed-selection.ts   |   9 +
 packages/grid-core/src/types.ts               |  27 ++-
 packages/react/react.api.md                   | 112 +++--------
 .../cross-emission-type-identity.types.ts     | 177 +++++++++++++++++
 .../__tests__/move-focus-movements.test.tsx   | 180 ++++++++++++++++++
 packages/react/src/pretable-model.ts          | 167 ++++------------
 packages/react/src/pretable-surface.tsx       |  34 ++--
 packages/react/src/public_api.ts              |   4 +-
 packages/renderer-dom/package.json            |  14 +-
 .../src/__tests__/indexed-renderer.test.ts    |  12 +-
 .../window-spacer-coordinates.test.ts         |   2 +-
 packages/renderer-dom/src/create-renderer.ts  |   8 +-
 .../renderer-dom/src/row-layout-controller.ts |   3 +-
 packages/renderer-dom/src/types.ts            |  23 ++-
 packages/renderer-dom/tsconfig.json           |   9 +-
 packages/renderer-dom/vitest.config.ts        |  37 ++++
 packages/row-model/src/column-types.ts        |  29 ++-
 packages/row-model/src/types.ts               |  33 +++-
 pnpm-lock.yaml                                |  13 +-
 .../public-api-symbol-brands.test.mjs         | 146 ++++++++++++++
 .../react/focus-movement-union.types.tsx      | 121 ++++++++++++
 28 files changed, 952 insertions(+), 302 deletions(-)
 create mode 100644 packages/react/src/__tests__/cross-emission-type-identity.types.ts
 create mode 100644 packages/react/src/__tests__/move-focus-movements.test.tsx
 create mode 100644 packages/renderer-dom/vitest.config.ts
 create mode 100644 scripts/__tests__/public-api-symbol-brands.test.mjs
 create mode 100644 type-tests/react/focus-movement-union.types.tsx

diff --git a/package.json b/package.json
index f7dab0b8..afa7d971 100644
--- a/package.json
+++ b/package.json
@@ -32,7 +32,7 @@
     "lint": "pnpm -r lint",
     "lint:packaging": "pnpm --filter @pretable/core lint:packaging && pnpm --filter @pretable/react lint:packaging && pnpm --filter @pretable/stream-adapter lint:packaging && pnpm --filter @pretable/ui lint:packaging",
     "publish:preflight": "node ./scripts/publish-preflight.mjs",
-    "test": "node --test scripts/__tests__/bench-comparator-provenance.test.mjs scripts/__tests__/bench-e2e.test.mjs scripts/__tests__/bench-matrix.test.mjs scripts/__tests__/check-bench-budgets.test.mjs scripts/__tests__/check-prod-deploy.test.mjs scripts/__tests__/check-type-performance.test.mjs scripts/__tests__/public-api-forgotten-exports.test.mjs scripts/__tests__/publish-preflight.test.mjs scripts/__tests__/publish-public-packages.test.mjs && pnpm -r --filter './packages/*' test && pnpm -r --workspace-concurrency=1 --filter './apps/*' test",
+    "test": "node --test scripts/__tests__/bench-comparator-provenance.test.mjs scripts/__tests__/bench-e2e.test.mjs scripts/__tests__/bench-matrix.test.mjs scripts/__tests__/check-bench-budgets.test.mjs scripts/__tests__/check-prod-deploy.test.mjs scripts/__tests__/check-type-performance.test.mjs scripts/__tests__/public-api-forgotten-exports.test.mjs scripts/__tests__/public-api-symbol-brands.test.mjs scripts/__tests__/publish-preflight.test.mjs scripts/__tests__/publish-public-packages.test.mjs && pnpm -r --filter './packages/*' test && pnpm -r --workspace-concurrency=1 --filter './apps/*' test",
     "typecheck": "pnpm -r --filter './packages/*' typecheck && pnpm -r --workspace-concurrency=1 --filter './apps/*' typecheck",
     "typecheck:performance": "pnpm --filter @pretable/core build && node ./scripts/check-type-performance.mjs",
     "typecheck:public": "pnpm --filter @pretable/core build && pnpm --filter @pretable/react build && pnpm exec tsc -p type-tests/tsconfig.json --noEmit && pnpm exec tsc -p type-tests/tsconfig.react.json --noEmit"
diff --git a/packages/core/core.api.md b/packages/core/core.api.md
index cc7e01b7..072e219b 100644
--- a/packages/core/core.api.md
+++ b/packages/core/core.api.md
@@ -48,7 +48,7 @@ export interface ColumnOption {
 
 // @public (undocumented)
 export type ColumnsOf<TModel> = TModel extends {
-    readonly [rowModelDescriptor]: {
+    readonly ["~pretableRowModel"]: {
         readonly columns: infer TColumns;
     };
 } ? TColumns : never;
@@ -338,7 +338,7 @@ export interface PretableColumn<TRow extends PretableRow = PretableRow> {
 // @public
 export interface PretableColumnAccessorKind<TKind extends "direct" | "computed"> {
     // (undocumented)
-    readonly [columnDescriptor]: {
+    readonly "~pretableColumn": {
         readonly accessorKind: TKind;
     };
 }
@@ -360,7 +360,7 @@ export interface PretableColumnCallbackContext<TRow extends object, TId extends
 // @public (undocumented)
 export interface PretableColumnDefinition<TRow extends object, TId extends string, TValue, TType extends PretableColumnType, TAggregate = undefined> {
     // (undocumented)
-    readonly [columnDescriptor]: {
+    readonly ["~pretableColumn"]: {
         readonly row: TRow;
         readonly id: TId;
         readonly value: TValue;
@@ -392,7 +392,7 @@ export interface PretableColumnDefinition<TRow extends object, TId extends strin
 // @public (undocumented)
 export interface PretableColumnDerivation<TRow extends object, TId extends string, TValue, TType extends PretableColumnType, TAggregate> {
     // (undocumented)
-    readonly [columnDescriptor]: {
+    readonly ["~pretableColumn"]: {
         readonly row: TRow;
         readonly id: TId;
         readonly value: TValue;
@@ -416,7 +416,7 @@ export interface PretableColumnDerivation<TRow extends object, TId extends strin
 // @public (undocumented)
 export interface PretableColumnHelper<TRow extends object> {
     // (undocumented)
-    accessor<const TId extends string, const TAccessor extends (...args: never[]) => unknown, const TType extends (unknown extends NoInfer<TValue> ? never : PretableColumnTypeFor<NoInfer<TValue>>) | ([TValue] extends [typeof columnDescriptor] ? [ReturnType<TAccessor>] extends [never] ? never : PretableColumnType : never), TValue = typeof columnDescriptor, const TAggregate extends PretableAggregateSpec<TRow, NoInfer<TValue>> | ([TValue] extends [typeof columnDescriptor] ? [ReturnType<TAccessor>] extends [never] ? never : PretableAggregateSpec<TRow, never> | "sum" | "avg" | "min" | "max" : never) | undefined = undefined>(id: TId, accessor: TAccessor & ((row: TRow) => TValue), options: {
+    accessor<const TId extends string, const TAccessor extends (...args: never[]) => unknown, const TType extends (unknown extends NoInfer<TValue> ? never : PretableColumnTypeFor<NoInfer<TValue>>) | ([TValue] extends [PretableUninferredColumnValue] ? [ReturnType<TAccessor>] extends [never] ? never : PretableColumnType : never), TValue = PretableUninferredColumnValue, const TAggregate extends PretableAggregateSpec<TRow, NoInfer<TValue>> | ([TValue] extends [PretableUninferredColumnValue] ? [ReturnType<TAccessor>] extends [never] ? never : PretableAggregateSpec<TRow, never> | "sum" | "avg" | "min" | "max" : never) | undefined = undefined>(id: TId, accessor: TAccessor & ((row: TRow) => TValue), options: {
         readonly type: TType;
         readonly header?: string;
         readonly compare?: (left: TValue, right: TValue) => number;
@@ -716,7 +716,7 @@ export interface PretableGridUiColumnLayout<TColumnId extends string> {
 // @public
 export interface PretableGridUiCore<TRow extends object, TRowId extends PretableRowId, TColumns, TColumnId extends string = ColumnIdOf<TColumns>> {
     // @internal
-    readonly [gridUiCoreType]?: (value: readonly [TRow, TRowId, TColumns, TColumnId]) => readonly [TRow, TRowId, TColumns, TColumnId];
+    readonly "~pretableGridUiCore"?: (value: readonly [TRow, TRowId, TColumns, TColumnId]) => readonly [TRow, TRowId, TColumns, TColumnId];
     readonly beginEdit: <TEditColumnId extends ColumnIdOf<TColumns>>(input: {
         readonly rowId: TRowId;
         readonly columnId: TEditColumnId;
@@ -736,9 +736,7 @@ export interface PretableGridUiCore<TRow extends object, TRowId extends Pretable
     // (undocumented)
     readonly isRowSelected: (rowId: TRowId) => boolean;
     // (undocumented)
-    readonly moveFocus: (movement: PretableIndexedFocusMovement, options?: {
-        readonly pageRows?: number;
-    }) => void;
+    readonly moveFocus: (movement: PretableIndexedFocusMovement, options?: PretableIndexedMoveFocusOptions) => void;
     // @internal
     readonly observeRowModelRevision: (revision: number) => void;
     // (undocumented)
@@ -796,7 +794,7 @@ export interface PretableGroupColumnOptions {
 
 // @public (undocumented)
 export type PretableGroupId = string & {
-    readonly [groupIdBrand]: "PretableGroupId";
+    readonly "~pretableGroupId": "PretableGroupId";
 };
 
 // @public
@@ -877,6 +875,12 @@ export interface PretableIndexedFocusState<TRowId extends PretableRowId, TColumn
     readonly ref: PretableIndexedFocusRef<TRowId> | null;
 }
 
+// @public
+export interface PretableIndexedMoveFocusOptions {
+    // (undocumented)
+    readonly pageRows?: number;
+}
+
 // @public
 export interface PretableIndexedRowRange<TRowId extends PretableRowId> {
     // (undocumented)
@@ -1067,7 +1071,7 @@ export class PretableRowIdentityChangeError extends PretableRowModelError {
 // @public (undocumented)
 export interface PretableRowModel<TRow extends object, TRowId extends PretableRowId, TColumns> {
     // (undocumented)
-    readonly [rowModelDescriptor]: {
+    readonly ["~pretableRowModel"]: {
         readonly row: TRow;
         readonly rowId: TRowId;
         readonly columns: TColumns;
@@ -1267,6 +1271,12 @@ export class PretableTransitionCancelledError extends Error {
     readonly transitionId: number;
 }
 
+// @public
+export interface PretableUninferredColumnValue {
+    // (undocumented)
+    readonly "~pretableUninferredColumnValue": true;
+}
+
 // @public (undocumented)
 export class PretableUnsupportedRowUpdateError extends PretableRowModelError {
     constructor(rowId: PretableRowId, cause?: unknown);
@@ -1308,18 +1318,39 @@ export type Prettify<T> = {
 
 // @public (undocumented)
 export type RowIdOf<TModel> = TModel extends {
-    readonly [rowModelDescriptor]: {
+    readonly ["~pretableRowModel"]: {
         readonly rowId: infer TRowId extends PretableRowId;
     };
 } ? TRowId : never;
 
 // @public (undocumented)
 export type RowOf<TModel> = TModel extends {
-    readonly [rowModelDescriptor]: {
+    readonly ["~pretableRowModel"]: {
         readonly row: infer TRow extends object;
     };
 } ? TRow : never;
 
+// Warning: (ae-internal-missing-underscore) The name "ɵcreateGridUiCore" should be prefixed with an underscore because the declaration is marked as @internal
+//
+// @internal
+export function ɵcreateGridUiCore<TRow extends object, TRowId extends PretableRowId, TColumns, TColumnId extends string = ColumnIdOf<TColumns>>(options: CreateGridUiCoreOptions<TRow, TRowId, TColumns, TColumnId>): PretableGridUiCore<TRow, TRowId, TColumns, TColumnId>;
+
+// Warning: (ae-internal-missing-underscore) The name "ɵgetIndexedCellSelectionSummary" should be prefixed with an underscore because the declaration is marked as @internal
+//
+// @internal
+export function ɵgetIndexedCellSelectionSummary<TRow extends object, TRowId extends PretableRowId, TColumns, TColumnId extends string>(selection: PretableIndexedSelectionState<TRowId, TColumnId>, snapshot: PretableRowModelSnapshot<TRow, TRowId, TColumns>, loadedWindow?: ɵPretableIndexedSelectionWindow | null): PretableIndexedCellSelectionSummary;
+
+// Warning: (ae-internal-missing-underscore) The name "ɵHEADER_FOCUS_REF" should be prefixed with an underscore because the declaration is marked as @internal
+//
+// @internal
+export const ɵHEADER_FOCUS_REF: PretableHeaderRowRef;
+
+// Warning: (ae-internal-missing-underscore) The name "ɵindexedRangeContainsCell" should be prefixed with an underscore because the declaration is marked as @internal
+//
+// @internal
+export function ɵindexedRangeContainsCell<TRow extends object, TRowId extends PretableRowId, TColumns, TColumnId extends string>(range: PretableIndexedCellRange<TRowId, TColumnId>, ref: PretableVisibleRowRef<TRowId>, columnId: TColumnId, snapshot: PretableRowModelSnapshot<TRow, TRowId, TColumns>, columns: readonly TColumnId[],
+loadedWindow?: ɵPretableIndexedSelectionWindow | null): boolean;
+
 // Warning: (ae-internal-missing-underscore) The name "ɵPretableIndexedSelectionWindow" should be prefixed with an underscore because the declaration is marked as @internal
 //
 // @internal
diff --git a/packages/core/src/public_api.ts b/packages/core/src/public_api.ts
index a06a9894..5c6f1ea7 100644
--- a/packages/core/src/public_api.ts
+++ b/packages/core/src/public_api.ts
@@ -111,6 +111,7 @@ export type {
   PretableSortFor,
   PretableTransaction,
   PretableTransitionCancellationReason,
+  PretableUninferredColumnValue,
   PretableViewportState,
   PretableHeaderRowRef,
   PretableGridUiColumn,
@@ -123,6 +124,7 @@ export type {
   PretableIndexedDatasetRowSpan,
   PretableIndexedEditingState,
   PretableIndexedFocusMovement,
+  PretableIndexedMoveFocusOptions,
   PretableIndexedFocusRef,
   PretableIndexedFocusState,
   PretableIndexedRowRange,
@@ -139,6 +141,26 @@ export type {
 } from "./types";
 
 // Internal-but-exported (ɵ-prefix marks these as not API-stable)
+//
+// The indexed UI engine, for `@pretable/react` ONLY. `@pretable/core` already
+// bundles `@pretable-internal/grid-core` (`noExternal`), so a react that also
+// imports the package directly compiles against a SECOND emission of the same
+// declarations and ships a SECOND copy of the engine at runtime. Two emissions
+// are two types to TypeScript wherever a declaration is not purely structural —
+// nominally for a `unique symbol` brand, and structurally for a deferred
+// conditional like `PretableAggregateOutputOf<TAggregate>`, which is compared by
+// alias identity while its argument is still generic. That is what the
+// `as unknown as` casts in `pretable-model.ts` were paying for. Reaching the
+// engine through this re-export gives react one declaration and one runtime
+// copy; `CreateGridUiCoreOptions` and `PretableGridUiCore` were already public,
+// so this only adds the factory that produces them.
+export {
+  createGridUiCore as ɵcreateGridUiCore,
+  getIndexedCellSelectionSummary as ɵgetIndexedCellSelectionSummary,
+  indexedRangeContainsCell as ɵindexedRangeContainsCell,
+  HEADER_FOCUS_REF as ɵHEADER_FOCUS_REF,
+} from "@pretable-internal/grid-core";
+
 // Named by `CreateGridUiCoreOptions.getSelectionWindow`'s signature, so it has
 // to ship with it — `scripts/__tests__/public-api-forgotten-exports.test.mjs`
 // fails otherwise. The option is `@internal`: the loaded span is how the engine
diff --git a/packages/core/src/types.ts b/packages/core/src/types.ts
index 9653d0bb..32278f18 100644
--- a/packages/core/src/types.ts
+++ b/packages/core/src/types.ts
@@ -38,6 +38,7 @@ export type {
   PretableIndexedDatasetRowSpan,
   PretableIndexedEditingState,
   PretableIndexedFocusMovement,
+  PretableIndexedMoveFocusOptions,
   PretableIndexedFocusRef,
   PretableIndexedFocusState,
   PretableIndexedRowRange,
@@ -104,6 +105,7 @@ export type {
   PretableSortFor,
   PretableTransaction,
   PretableTransitionCancellationReason,
+  PretableUninferredColumnValue,
   PretableVisibleRow,
   PretableVisibleRowField,
   PretableVisibleRowRef,
diff --git a/packages/grid-core/src/create-grid-ui-core.ts b/packages/grid-core/src/create-grid-ui-core.ts
index 76dafa04..ae7409a1 100644
--- a/packages/grid-core/src/create-grid-ui-core.ts
+++ b/packages/grid-core/src/create-grid-ui-core.ts
@@ -361,6 +361,14 @@ function sameSelection<TRowId extends PretableRowId, TColumnId extends string>(
   );
 }
 
+/**
+ * Creates the framework-independent indexed UI store.
+ *
+ * @internal Re-exported by `@pretable/core` as `ɵcreateGridUiCore` for
+ * `@pretable/react`, which must reach the engine through the same declaration
+ * emission `@pretable/core` publishes rather than through this package
+ * directly. See the note on that re-export in `packages/core/src/public_api.ts`.
+ */
 export function createGridUiCore<
   TRow extends object,
   TRowId extends PretableRowId,
diff --git a/packages/grid-core/src/index.ts b/packages/grid-core/src/index.ts
index 35859472..5c611fd4 100644
--- a/packages/grid-core/src/index.ts
+++ b/packages/grid-core/src/index.ts
@@ -61,6 +61,7 @@ export type {
   PretableIndexedDatasetRowSpan,
   PretableIndexedEditingState,
   PretableIndexedFocusMovement,
+  PretableIndexedMoveFocusOptions,
   PretableIndexedFocusRef,
   PretableIndexedFocusState,
   PretableIndexedRowRange,
diff --git a/packages/grid-core/src/indexed-focus.ts b/packages/grid-core/src/indexed-focus.ts
index bdd41c07..11931a3f 100644
--- a/packages/grid-core/src/indexed-focus.ts
+++ b/packages/grid-core/src/indexed-focus.ts
@@ -24,6 +24,8 @@ import type {
  * Frozen and shared so identity comparison short-circuits — `sameRef` in
  * `create-grid-ui-core` still compares structurally, because a consumer may
  * hand in its own `{kind: "header"}` literal through `setFocus`.
+ *
+ * @internal Re-exported by `@pretable/core` as `ɵHEADER_FOCUS_REF`.
  */
 export const HEADER_FOCUS_REF: PretableHeaderRowRef = Object.freeze({
   kind: "header",
diff --git a/packages/grid-core/src/indexed-selection.ts b/packages/grid-core/src/indexed-selection.ts
index b3467301..a4ef8f6e 100644
--- a/packages/grid-core/src/indexed-selection.ts
+++ b/packages/grid-core/src/indexed-selection.ts
@@ -1866,6 +1866,9 @@ function rangeDatasetSpan<
  * `loadedWindow` is the same honesty-gated span `reconcileIndexedSelection`
  * takes; omitting it (local mode) restricts the count to what the snapshot
  * can resolve, exactly as before eviction existed.
+ *
+ * @internal Re-exported by `@pretable/core` as
+ * `ɵgetIndexedCellSelectionSummary`.
  */
 export function getIndexedCellSelectionSummary<
   TRow extends object,
@@ -1906,6 +1909,12 @@ export function getIndexedCellSelectionSummary<
   return Object.freeze({ rowCount, verified });
 }
 
+/**
+ * Whether a cell range covers `ref` / `columnId`, resolved against the drawn
+ * column order.
+ *
+ * @internal Re-exported by `@pretable/core` as `ɵindexedRangeContainsCell`.
+ */
 export function indexedRangeContainsCell<
   TRow extends object,
   TRowId extends PretableRowId,
diff --git a/packages/grid-core/src/types.ts b/packages/grid-core/src/types.ts
index 0e654266..372b6b7a 100644
--- a/packages/grid-core/src/types.ts
+++ b/packages/grid-core/src/types.ts
@@ -647,6 +647,19 @@ export type PretableIndexedFocusMovement =
   | "shift-tab"
   | "parent";
 
+/**
+ * Optional modifiers for {@link PretableIndexedFocusMovement}.
+ *
+ * Named rather than spelled inline at each `moveFocus` so the react handle can
+ * import it: an inline object literal is a copy, and a copy drifts. `pageRows`
+ * is how many rows `"page-up"` / `"page-down"` travel.
+ *
+ * @public
+ */
+export interface PretableIndexedMoveFocusOptions {
+  readonly pageRows?: number;
+}
+
 /** Visual-column input; derivation behavior remains in the row model. @public */
 export interface PretableGridUiColumn<TColumnId extends string> {
   readonly id: TColumnId;
@@ -713,8 +726,6 @@ export interface PretableGridUiState<
   readonly observedRowModelRevision: number | null;
 }
 
-declare const gridUiCoreType: unique symbol;
-
 /**
  * Framework-independent UI-only indexed grid store.
  *
@@ -739,7 +750,7 @@ export interface PretableGridUiCore<
   ) => void;
   readonly moveFocus: (
     movement: PretableIndexedFocusMovement,
-    options?: { readonly pageRows?: number },
+    options?: PretableIndexedMoveFocusOptions,
   ) => void;
   readonly setSelection: (
     selection: PretableIndexedSelectionState<TRowId, TColumnId>,
@@ -801,8 +812,14 @@ export interface PretableGridUiCore<
   /** @internal Called only after renderer geometry for this exact revision exists. */
   readonly observeRowModelRevision: (revision: number) => void;
   readonly dispose: () => void;
-  /** @internal Compile-time-only invariant descriptor. */
-  readonly [gridUiCoreType]?: (
+  /**
+   * @internal Compile-time-only invariant descriptor. Keyed by a string
+   * literal, not a `unique symbol` — see `PretableGroupId` in
+   * `@pretable-internal/row-model`'s `types.ts` for why a symbol brand does not
+   * survive `tsup`'s bundled `.d.ts` re-emitting this declaration into
+   * `core/dist`.
+   */
+  readonly "~pretableGridUiCore"?: (
     value: readonly [TRow, TRowId, TColumns, TColumnId],
   ) => readonly [TRow, TRowId, TColumns, TColumnId];
 }
diff --git a/packages/react/react.api.md b/packages/react/react.api.md
index 5a0eea0f..c0c3e1a4 100644
--- a/packages/react/react.api.md
+++ b/packages/react/react.api.md
@@ -60,7 +60,7 @@ export interface ColumnOption {
 
 // @public (undocumented)
 export type ColumnsOf<TModel> = TModel extends {
-    readonly [rowModelDescriptor]: {
+    readonly ["~pretableRowModel"]: {
         readonly columns: infer TColumns;
     };
 } ? TColumns : never;
@@ -644,7 +644,7 @@ export interface PretableColumn<TRow extends PretableRow = PretableRow> {
 // @public
 export interface PretableColumnAccessorKind<TKind extends "direct" | "computed"> {
     // (undocumented)
-    readonly [columnDescriptor]: {
+    readonly "~pretableColumn": {
         readonly accessorKind: TKind;
     };
 }
@@ -652,7 +652,7 @@ export interface PretableColumnAccessorKind<TKind extends "direct" | "computed">
 // @public (undocumented)
 export interface PretableColumnDefinition<TRow extends object, TId extends string, TValue, TType extends PretableColumnType, TAggregate = undefined> {
     // (undocumented)
-    readonly [columnDescriptor]: {
+    readonly ["~pretableColumn"]: {
         readonly row: TRow;
         readonly id: TId;
         readonly value: TValue;
@@ -684,7 +684,7 @@ export interface PretableColumnDefinition<TRow extends object, TId extends strin
 // @public (undocumented)
 export interface PretableColumnDerivation<TRow extends object, TId extends string, TValue, TType extends PretableColumnType, TAggregate> {
     // (undocumented)
-    readonly [columnDescriptor]: {
+    readonly ["~pretableColumn"]: {
         readonly row: TRow;
         readonly id: TId;
         readonly value: TValue;
@@ -1193,7 +1193,7 @@ export interface PretableGridUiColumnLayout<TColumnId extends string> {
 // @public
 export interface PretableGridUiCore<TRow extends object, TRowId extends PretableRowId, TColumns, TColumnId extends string = ColumnIdOf<TColumns>> {
     // @internal
-    readonly [gridUiCoreType]?: (value: readonly [TRow, TRowId, TColumns, TColumnId]) => readonly [TRow, TRowId, TColumns, TColumnId];
+    readonly "~pretableGridUiCore"?: (value: readonly [TRow, TRowId, TColumns, TColumnId]) => readonly [TRow, TRowId, TColumns, TColumnId];
     readonly beginEdit: <TEditColumnId extends ColumnIdOf<TColumns>>(input: {
         readonly rowId: TRowId;
         readonly columnId: TEditColumnId;
@@ -1213,9 +1213,7 @@ export interface PretableGridUiCore<TRow extends object, TRowId extends Pretable
     // (undocumented)
     readonly isRowSelected: (rowId: TRowId) => boolean;
     // (undocumented)
-    readonly moveFocus: (movement: PretableIndexedFocusMovement, options?: {
-        readonly pageRows?: number;
-    }) => void;
+    readonly moveFocus: (movement: PretableIndexedFocusMovement, options?: PretableIndexedMoveFocusOptions) => void;
     // @internal
     readonly observeRowModelRevision: (revision: number) => void;
     // (undocumented)
@@ -1249,65 +1247,7 @@ export interface PretableGridUiCore<TRow extends object, TRowId extends Pretable
 }
 
 // @public
-export interface PretableGridUiSnapshot<TRowId extends PretableRowId, TColumns, TColumnId extends string = ColumnIdOf<TColumns>> {
-    // (undocumented)
-    readonly columnLayout: readonly Readonly<{
-        readonly id: TColumnId;
-        readonly widthPx: number;
-        readonly pinned?: "left" | "right";
-    }>[];
-    // (undocumented)
-    readonly editing: {
-        readonly [TEditColumnId in ColumnIdOf<TColumns>]: {
-            readonly rowId: TRowId;
-            readonly columnId: TEditColumnId;
-            readonly value: ColumnValueOf<TColumns, TEditColumnId>;
-            readonly status: "editing" | "validating" | "saving" | "error";
-            readonly error?: string;
-        };
-    }[ColumnIdOf<TColumns>] | null;
-    // (undocumented)
-    readonly focus: Readonly<{
-        readonly ref: PretableIndexedFocusRef<TRowId> | null;
-        readonly columnId: TColumnId | null;
-    }>;
-    // (undocumented)
-    readonly observedRowModelRevision: number | null;
-    // (undocumented)
-    readonly selection: Readonly<{
-        readonly rows: {
-            readonly kind: "explicit";
-            readonly rowIds: ReadonlySet<TRowId>;
-            readonly ranges?: PretableReactRowRangeIndex<TRowId>;
-            readonly excludedRanges?: PretableReactRowRangeIndex<TRowId>;
-        } | {
-            readonly kind: "all";
-            readonly excludedRanges?: PretableReactRowRangeIndex<TRowId>;
-        };
-        readonly ranges: readonly {
-            readonly start: {
-                readonly rowId: TRowId;
-                readonly columnId: TColumnId;
-            };
-            readonly end: {
-                readonly rowId: TRowId;
-                readonly columnId: TColumnId;
-            };
-            readonly datasetRowSpan?: PretableIndexedDatasetRowSpan;
-        }[];
-        readonly anchor: {
-            readonly rowId: TRowId;
-            readonly columnId: TColumnId;
-        } | null;
-    }>;
-    // (undocumented)
-    readonly viewport: Readonly<{
-        readonly scrollTop: number;
-        readonly scrollLeft: number;
-        readonly height: number;
-        readonly width: number;
-    }>;
-}
+export type PretableGridUiSnapshot<TRowId extends PretableRowId, TColumns, TColumnId extends string = ColumnIdOf<TColumns>> = PretableGridUiState<TRowId, TColumns, TColumnId>;
 
 // @public
 export interface PretableGridUiState<TRowId extends PretableRowId, TColumns, TColumnId extends string = ColumnIdOf<TColumns>> {
@@ -1334,7 +1274,7 @@ export interface PretableGroupColumnOptions {
 
 // @public (undocumented)
 export type PretableGroupId = string & {
-    readonly [groupIdBrand]: "PretableGroupId";
+    readonly "~pretableGroupId": "PretableGroupId";
 };
 
 // @public
@@ -1429,6 +1369,12 @@ export interface PretableIndexedFocusState<TRowId extends PretableRowId, TColumn
     readonly ref: PretableIndexedFocusRef<TRowId> | null;
 }
 
+// @public
+export interface PretableIndexedMoveFocusOptions {
+    // (undocumented)
+    readonly pageRows?: number;
+}
+
 // @public
 export interface PretableIndexedRenderSnapshot<TRow extends object, TRowId extends PretableRowId, TColumns> {
     // (undocumented)
@@ -1720,9 +1666,7 @@ export type PretableReactGrid<TRow extends object, TRowId extends PretableRowId,
         readonly width: number;
     }) => void;
     readonly setFocus: (focus: PretableGridUiSnapshot<TRowId, TColumns, TColumnId>["focus"]) => void;
-    readonly moveFocus: (movement: "up" | "down" | "left" | "right" | "page-up" | "page-down" | "home" | "end" | "tab" | "shift-tab" | "parent", options?: {
-        readonly pageRows?: number;
-    }) => void;
+    readonly moveFocus: (movement: PretableIndexedFocusMovement, options?: PretableIndexedMoveFocusOptions) => void;
     readonly setSelection: (selection: PretableGridUiSnapshot<TRowId, TColumns, TColumnId>["selection"]) => void;
     readonly setRowSelection: (rows: PretableRowSelectionState<TRowId>) => void;
     readonly toggleRowSelection: (rowId: TRowId) => void;
@@ -1753,20 +1697,6 @@ export type PretableReactGrid<TRow extends object, TRowId extends PretableRowId,
     readonly setQuery: (query: PretableQueryFor<TColumns>) => PretableQueryTransition<TColumns> | void;
 };
 
-// @public
-export interface PretableReactRowRange<TRowId extends PretableRowId> {
-    // (undocumented)
-    readonly endRowId: TRowId;
-    // (undocumented)
-    readonly startRowId: TRowId;
-}
-
-// @public
-export interface PretableReactRowRangeIndex<TRowId extends PretableRowId> extends Iterable<PretableReactRowRange<TRowId>> {
-    // (undocumented)
-    readonly size: number;
-}
-
 // @public
 export interface PretableResultMeta {
     datasetKey?: string;
@@ -1838,7 +1768,7 @@ TRow
 // @public (undocumented)
 export interface PretableRowModel<TRow extends object, TRowId extends PretableRowId, TColumns> {
     // (undocumented)
-    readonly [rowModelDescriptor]: {
+    readonly ["~pretableRowModel"]: {
         readonly row: TRow;
         readonly rowId: TRowId;
         readonly columns: TColumns;
@@ -2432,6 +2362,12 @@ export interface PretableTransaction<TRow extends object, TRowId extends Pretabl
     readonly update?: readonly PretableRowUpdate<TRow, TRowId>[];
 }
 
+// @public
+export interface PretableUninferredColumnValue {
+    // (undocumented)
+    readonly "~pretableUninferredColumnValue": true;
+}
+
 // @public
 export interface PretableViewportOptions {
     // (undocumented)
@@ -2491,14 +2427,14 @@ export function resolveDataScope(input: Pick<DataHonestyInput, "loadedRowCount"
 
 // @public (undocumented)
 export type RowIdOf<TModel> = TModel extends {
-    readonly [rowModelDescriptor]: {
+    readonly ["~pretableRowModel"]: {
         readonly rowId: infer TRowId extends PretableRowId;
     };
 } ? TRowId : never;
 
 // @public (undocumented)
 export type RowOf<TModel> = TModel extends {
-    readonly [rowModelDescriptor]: {
+    readonly ["~pretableRowModel"]: {
         readonly row: infer TRow extends object;
     };
 } ? TRow : never;
diff --git a/packages/react/src/__tests__/cross-emission-type-identity.types.ts b/packages/react/src/__tests__/cross-emission-type-identity.types.ts
new file mode 100644
index 00000000..745e0adc
--- /dev/null
+++ b/packages/react/src/__tests__/cross-emission-type-identity.types.ts
@@ -0,0 +1,177 @@
+/**
+ * Type-only. Compiled by `tsconfig.typecheck.json` (which maps every workspace
+ * dependency to its built `.d.ts` and, unlike `tsconfig.json`, includes tests),
+ * so these assertions run under `pnpm typecheck`. There is nothing to execute:
+ * a failure here is a compile error, not a red test.
+ *
+ * **What it pins.** `@pretable/core` bundles `@pretable-internal/grid-core` and
+ * `@pretable-internal/row-model` (`noExternal`), so `tsup`'s bundled `.d.ts`
+ * re-emits their declarations alongside the copies `tsc` already wrote into
+ * each package's own `dist`. Two emissions of one declaration must be the SAME
+ * type. When they are not, this package pays for it: it compiles against both
+ * at once, and every crossing needs a cast.
+ *
+ * That is not a hypothetical. `pretable-model.ts` used to carry two
+ * `as unknown as` casts, and the first of them reported:
+ *
+ * ```
+ * Property '[groupIdBrand]' is missing in type
+ * 'String & { readonly [groupIdBrand]: "PretableGroupId"; }' but required in
+ * type '{ readonly [groupIdBrand]: "PretableGroupId"; }'.
+ * ```
+ *
+ * — the same declaration, twice, unrelated, because a `unique symbol` is
+ * nominal per declaration file.
+ *
+ * The `RowOf` / `ColumnsOf` assertions below cover the half that never produced
+ * an error at all: those match structurally on the row-model brand, so across
+ * the seam they quietly resolved to `never`.
+ *
+ * `scripts/__tests__/public-api-symbol-brands.test.mjs` is the other side of
+ * this: it fails if a symbol-keyed brand reappears in a published API report.
+ * This file fails if the two emissions drift apart by any mechanism at all —
+ * including the deferred-conditional-alias mismatch that a brand change cannot
+ * reach.
+ */
+import type {
+  PretableColumnAccessorKind as EngineColumnAccessorKind,
+  PretableColumnDefinition as EngineColumnDefinition,
+  PretableGroupId as EngineGroupId,
+  PretableRowModel as EngineRowModel,
+  PretableUninferredColumnValue as EngineUninferredColumnValue,
+  PretableVisibleRowRef as EngineVisibleRowRef,
+} from "@pretable-internal/row-model";
+import type {
+  ColumnsOf as CoreColumnsOf,
+  PretableColumnAccessorKind as CoreColumnAccessorKind,
+  PretableColumnDefinition as CoreColumnDefinition,
+  PretableGridUiCore as CoreGridUiCore,
+  PretableGroupId as CoreGroupId,
+  PretableRowModel as CoreRowModel,
+  PretableUninferredColumnValue as CoreUninferredColumnValue,
+  PretableVisibleRowRef as CoreVisibleRowRef,
+  RowIdOf as CoreRowIdOf,
+  RowOf as CoreRowOf,
+} from "@pretable/core";
+import type { PretableGridUiCore as EngineGridUiCore } from "@pretable-internal/grid-core";
+
+type Equal<TLeft, TRight> =
+  (<T>() => T extends TLeft ? 1 : 2) extends <T>() => T extends TRight ? 1 : 2
+    ? true
+    : false;
+
+type Expect<T extends true> = T;
+
+interface Position {
+  readonly id: string;
+  readonly symbol: string;
+  readonly quantity: number;
+}
+
+type Columns = readonly [
+  CoreColumnDefinition<Position, "symbol", string, "text"> &
+    CoreColumnAccessorKind<"direct">,
+];
+
+// --- the four brands that crossed the seam -------------------------------
+// `groupIdBrand`. The one the first cast paid for.
+type _GroupIdBrand = Expect<Equal<CoreGroupId, EngineGroupId>>;
+type _GroupRefBrand = Expect<
+  Equal<CoreVisibleRowRef<string>, EngineVisibleRowRef<string>>
+>;
+
+// `columnDescriptor`, in both of its roles: the carrier's key...
+type _ColumnBrand = Expect<
+  Equal<CoreColumnAccessorKind<"direct">, EngineColumnAccessorKind<"direct">>
+>;
+// ...and the "value not inferred yet" sentinel it also used to serve.
+type _ColumnSentinel = Expect<
+  Equal<CoreUninferredColumnValue, EngineUninferredColumnValue>
+>;
+
+// `gridUiCoreType`, the store's compile-time invariance marker. Asserted on the
+// KEY SET rather than with `Equal` on the whole store: the marker was optional,
+// so it never blocked an assignment even while split — a missing optional
+// property is assignable — and the key set is the thing the brand decided. A
+// split shows up here as two different `unique symbol`s in `keyof`.
+//
+// `Equal` on the whole interface is deliberately not the bar. It fails for a
+// reason that has nothing to do with brands: `beginEdit` is generic over
+// `ColumnValueOf<TColumns, TEditColumnId>`, and TypeScript relates a deferred
+// conditional type by the identity of its alias declaration, which two
+// emissions cannot share. Assignability — which is what any caller actually
+// needs, and what the two deleted casts were paying for — is asserted below.
+type _GridUiCoreBrand = Expect<
+  Equal<
+    keyof CoreGridUiCore<Position, string, Columns, "symbol">,
+    keyof EngineGridUiCore<Position, string, Columns, "symbol">
+  >
+>;
+
+declare const engineGridCore: EngineGridUiCore<
+  Position,
+  string,
+  Columns,
+  "symbol"
+>;
+export const engineGridCoreIsCoreGridCore: CoreGridUiCore<
+  Position,
+  string,
+  Columns,
+  "symbol"
+> = engineGridCore;
+
+// `rowModelDescriptor`. Asserted in the direction that FAILED SILENTLY: these
+// extractors match structurally on the brand, so a split resolved them to
+// `never` with no diagnostic anywhere. `Equal` is used rather than a bare
+// assignability check for exactly that reason — `never` is assignable to
+// everything, so a weaker assertion would have passed while broken.
+type _RowModelRowOf = Expect<
+  Equal<CoreRowOf<EngineRowModel<Position, string, Columns>>, Position>
+>;
+type _RowModelRowIdOf = Expect<
+  Equal<CoreRowIdOf<EngineRowModel<Position, string, Columns>>, string>
+>;
+type _RowModelColumnsOf = Expect<
+  Equal<CoreColumnsOf<EngineRowModel<Position, string, Columns>>, Columns>
+>;
+
+// --- and the whole model, both ways --------------------------------------
+// Assignability, not `Equal`: this is the crossing `usePretableModel` performs
+// when it hands its `PretableRowModel` to the engine, and it is what the second
+// `as unknown as` cast used to hide. It survives a brand fix alone only because
+// nothing else in the chain is compared by alias identity either — a deferred
+// conditional such as `PretableAggregateOutputOf<TAggregate>` is, which is why
+// `@pretable-internal/renderer-dom` reaches the engine through `@pretable/core`
+// rather than through the pre-bundle packages.
+declare const engineModel: EngineRowModel<Position, string, Columns>;
+declare const coreModel: CoreRowModel<Position, string, Columns>;
+
+export const engineModelIsCoreModel: CoreRowModel<Position, string, Columns> =
+  engineModel;
+export const coreModelIsEngineModel: EngineRowModel<Position, string, Columns> =
+  coreModel;
+
+// The column DEFINITION itself, which carries the same brand as its accessor
+// kind and is the type every `createColumnHelper` result is built from.
+type _ColumnDefinition = Expect<
+  Equal<
+    CoreColumnDefinition<Position, "symbol", string, "text">,
+    EngineColumnDefinition<Position, "symbol", string, "text">
+  >
+>;
+
+// Referenced so none of the aliases above can be deleted without a compile
+// error — an unreferenced `type _X = Expect<...>` is still checked, but this
+// makes the set explicit and reviewable in one place.
+export type CrossEmissionAssertions = [
+  _GroupIdBrand,
+  _GroupRefBrand,
+  _ColumnBrand,
+  _ColumnSentinel,
+  _ColumnDefinition,
+  _GridUiCoreBrand,
+  _RowModelRowOf,
+  _RowModelRowIdOf,
+  _RowModelColumnsOf,
+];
diff --git a/packages/react/src/__tests__/move-focus-movements.test.tsx b/packages/react/src/__tests__/move-focus-movements.test.tsx
new file mode 100644
index 00000000..9c9ae26c
--- /dev/null
+++ b/packages/react/src/__tests__/move-focus-movements.test.tsx
@@ -0,0 +1,180 @@
+// @vitest-environment jsdom
+import { act, cleanup, renderHook } from "@testing-library/react";
+import { afterEach, describe, expect, test } from "vitest";
+
+import { createColumnHelper, createLocalRowModel } from "@pretable/core";
+import type { PretableIndexedFocusMovement } from "@pretable/core";
+
+import { usePretableModelInternal } from "../pretable-model";
+
+/**
+ * `PretableReactGrid.moveFocus` used to declare a HAND-COPIED movement union
+ * that had fallen two members behind the engine's
+ * `PretableIndexedFocusMovement`; the copy is now the imported type
+ * (`type-tests/react/focus-movement-union.types.tsx` pins that).
+ *
+ * That change is type-only, and a type-only change is exactly the kind that
+ * passes every type test while breaking the program: `moveFocus` is reached
+ * through a prototype facade over the grid core (`Object.create(stores.gridCore)`
+ * in `pretable-model.ts`), so a movement that stopped being forwarded — or was
+ * forwarded with its options dropped — would still typecheck perfectly.
+ *
+ * So this asserts the OLD behavior survives, per movement, against the focus
+ * the engine actually publishes. Each case names the focus it expects rather
+ * than merely checking that something changed: a `moveFocus` that always went
+ * home would pass a "focus moved" assertion for nine of these.
+ */
+interface Row {
+  id: number;
+  label: string;
+  score: number;
+}
+
+const column = createColumnHelper<Row>();
+const columns = [
+  column.accessor("label", { type: "text" }),
+  column.accessor("score", { type: "number" }),
+] as const;
+const rows: readonly Row[] = [
+  { id: 1, label: "one", score: 1 },
+  { id: 2, label: "two", score: 2 },
+  { id: 3, label: "three", score: 3 },
+  { id: 4, label: "four", score: 4 },
+  { id: 5, label: "five", score: 5 },
+];
+
+const drawn = [
+  { id: "label", widthPx: 120 },
+  { id: "score", widthPx: 120 },
+] as const;
+
+function renderGrid() {
+  const rowModel = createLocalRowModel({ rows, columns });
+  const view = renderHook(() =>
+    usePretableModelInternal({
+      rowModel,
+      columns: drawn,
+      viewportHeight: 200,
+    }),
+  );
+  return { view, rowModel };
+}
+
+/** `{rowId, columnId}` of the engine's current focus, or `null` markers. */
+function focusOf(grid: {
+  getState: () => {
+    focus: {
+      ref: { kind: string; rowId?: number } | null;
+      columnId: string | null;
+    };
+  };
+}) {
+  const { ref, columnId } = grid.getState().focus;
+  return {
+    kind: ref?.kind ?? null,
+    rowId: ref?.kind === "data" ? (ref.rowId ?? null) : null,
+    columnId,
+  };
+}
+
+afterEach(cleanup);
+
+describe("moveFocus forwards every movement to the engine", () => {
+  /**
+   * Start on row 3 / `label` — the interior of both axes, so "moved to the
+   * first row" and "did not move" are distinguishable from every direction.
+   */
+  const cases: readonly {
+    readonly movement: PretableIndexedFocusMovement;
+    readonly expect: { rowId: number | null; columnId: string | null };
+    readonly kind?: string;
+  }[] = [
+    { movement: "up", expect: { rowId: 2, columnId: "label" } },
+    { movement: "down", expect: { rowId: 4, columnId: "label" } },
+    { movement: "right", expect: { rowId: 3, columnId: "score" } },
+    { movement: "home", expect: { rowId: 1, columnId: "label" } },
+    { movement: "end", expect: { rowId: 5, columnId: "label" } },
+    { movement: "last-column", expect: { rowId: 3, columnId: "score" } },
+    { movement: "first-column", expect: { rowId: 3, columnId: "label" } },
+    { movement: "tab", expect: { rowId: 3, columnId: "score" } },
+    { movement: "page-down", expect: { rowId: 5, columnId: "label" } },
+  ];
+
+  for (const { movement, expect: expected } of cases) {
+    test(`"${movement}"`, () => {
+      const { view, rowModel } = renderGrid();
+      const grid = view.result.current.grid;
+
+      act(() => {
+        grid.setFocus({
+          ref: { kind: "data", rowId: 3 },
+          columnId: "label",
+        });
+      });
+      expect(focusOf(grid)).toEqual({
+        kind: "data",
+        rowId: 3,
+        columnId: "label",
+      });
+
+      act(() => grid.moveFocus(movement));
+
+      expect(focusOf(grid)).toEqual({
+        kind: "data",
+        rowId: expected.rowId,
+        columnId: expected.columnId,
+      });
+
+      view.unmount();
+      rowModel.dispose();
+    });
+  }
+
+  /**
+   * `"left"` off the first column and `"up"` off the first row leave the data
+   * rows entirely — the second lands on the header, which is the case a
+   * consumer switching on `ref.kind` has to answer.
+   */
+  test('"up" from the first row lands on the header', () => {
+    const { view, rowModel } = renderGrid();
+    const grid = view.result.current.grid;
+
+    act(() => {
+      grid.setFocus({ ref: { kind: "data", rowId: 1 }, columnId: "label" });
+      grid.moveFocus("up");
+    });
+
+    expect(focusOf(grid).kind).toBe("header");
+
+    view.unmount();
+    rowModel.dispose();
+  });
+
+  /**
+   * The second parameter, which was a duplicated `{ pageRows?: number }` and is
+   * now the imported `PretableIndexedMoveFocusOptions`. Asserted because the
+   * call site that broke was repaired with a cast that dropped this argument
+   * entirely — a signature can be correct while the value never arrives.
+   */
+  test('"page-up" honours pageRows', () => {
+    const { view, rowModel } = renderGrid();
+    const grid = view.result.current.grid;
+
+    act(() => {
+      grid.setFocus({ ref: { kind: "data", rowId: 5 }, columnId: "label" });
+      grid.moveFocus("page-up", { pageRows: 2 });
+    });
+
+    expect(focusOf(grid).rowId).toBe(3);
+
+    act(() => {
+      grid.setFocus({ ref: { kind: "data", rowId: 5 }, columnId: "label" });
+      grid.moveFocus("page-up", { pageRows: 4 });
+    });
+
+    expect(focusOf(grid).rowId).toBe(1);
+
+    view.unmount();
+    rowModel.dispose();
+  });
+});
diff --git a/packages/react/src/pretable-model.ts b/packages/react/src/pretable-model.ts
index 2240fe2d..6caac4ca 100644
--- a/packages/react/src/pretable-model.ts
+++ b/packages/react/src/pretable-model.ts
@@ -1,10 +1,12 @@
-import { createGridUiCore } from "@pretable-internal/grid-core";
 import {
   createDomRenderSnapshot,
   createRowLayoutController,
   type DomLayoutColumn,
 } from "@pretable-internal/renderer-dom";
-import type { PretableRowModel as InternalRowModel } from "@pretable-internal/row-model";
+import {
+  ɵcreateGridUiCore as createGridUiCore,
+  type PretableGridUiState,
+} from "@pretable/core";
 import type {
   PretableQueryFor,
   PretableQueryTransition,
@@ -12,13 +14,13 @@ import type {
   ColumnValueOf,
   PretableGroupRow,
   PretableIndexedCellSelectionSummary,
-  PretableIndexedDatasetRowSpan,
+  PretableIndexedFocusMovement,
+  PretableIndexedMoveFocusOptions,
   PretableRowId,
   PretableRowModel,
   PretableRowModelSnapshot,
   PretableRowModelStatus,
   PretableRowSelectionState,
-  PretableIndexedFocusRef,
   PretableVisibleRowRef,
 } from "@pretable/core";
 import {
@@ -43,19 +45,6 @@ import {
   getGridSegmentMeasurer,
 } from "./text-metrics";
 
-/** Inclusive symbolic data-row span exposed by the indexed React grid. @public */
-export interface PretableReactRowRange<TRowId extends PretableRowId> {
-  readonly startRowId: TRowId;
-  readonly endRowId: TRowId;
-}
-
-/** Immutable normalized row-range index exposed by the indexed React grid. @public */
-export interface PretableReactRowRangeIndex<
-  TRowId extends PretableRowId,
-> extends Iterable<PretableReactRowRange<TRowId>> {
-  readonly size: number;
-}
-
 /**
  * Framework-independent indexed grid actions exposed by `usePretable`.
  *
@@ -87,20 +76,15 @@ export type PretableReactGrid<
   readonly setFocus: (
     focus: PretableGridUiSnapshot<TRowId, TColumns, TColumnId>["focus"],
   ) => void;
+  /**
+   * The movement union and the options are IMPORTED, never respelled here. A
+   * hand-copied union went two members stale when `first-column` /
+   * `last-column` were added and broke the build; the fix at the time was a
+   * cast at the call site, which is the same trade one step further away.
+   */
   readonly moveFocus: (
-    movement:
-      | "up"
-      | "down"
-      | "left"
-      | "right"
-      | "page-up"
-      | "page-down"
-      | "home"
-      | "end"
-      | "tab"
-      | "shift-tab"
-      | "parent",
-    options?: { readonly pageRows?: number },
+    movement: PretableIndexedFocusMovement,
+    options?: PretableIndexedMoveFocusOptions,
   ) => void;
   readonly setSelection: (
     selection: PretableGridUiSnapshot<TRowId, TColumns, TColumnId>["selection"],
@@ -169,90 +153,34 @@ export type PretableReactGrid<
 };
 
 /**
- * Immutable snapshot of indexed grid UI state.
+ * Immutable snapshot of indexed grid UI state — the engine's own
+ * {@link PretableGridUiState}, named for react consumers.
+ *
+ * An ALIAS, not a copy. This was a 74-line hand-written mirror that spelled out
+ * `PretableViewportState`, `PretableIndexedFocusState`,
+ * `PretableIndexedRowSelection`, `PretableIndexedCellRange`,
+ * `PretableIndexedCellAddress`, `PretableIndexedEditingState` and
+ * `PretableGridUiColumnLayout` inline — every one of them already re-exported
+ * by this package — and it published two more names,
+ * `PretableReactRowRange(Index)`, for types the engine already called
+ * `PretableIndexedRowRange(Index)`. It was structurally identical to
+ * `PretableGridUiState` field for field, so it bought nothing and could drift
+ * in either direction the moment the engine gained a field.
  *
  * See {@link PretableReactGrid} for why the schema column tuple (`TColumns`)
  * and the drawn column-id vocabulary (`TColumnId`) are separate parameters:
  * `columnLayout`, `focus.columnId` and the selection endpoints all address
- * DRAWN columns, while `editing` addresses a schema one.
+ * DRAWN columns, while `editing` addresses a schema one. `focus.ref` may be
+ * `{kind: "header"}` — a real value, since the cursor sits on a column header
+ * whenever the user has arrowed up off the first row.
  *
  * @public
  */
-export interface PretableGridUiSnapshot<
+export type PretableGridUiSnapshot<
   TRowId extends PretableRowId,
   TColumns,
   TColumnId extends string = ColumnIdOf<TColumns>,
-> {
-  readonly viewport: Readonly<{
-    readonly scrollTop: number;
-    readonly scrollLeft: number;
-    readonly height: number;
-    readonly width: number;
-  }>;
-  readonly focus: Readonly<{
-    /**
-     * `{kind: "header"}` is a real value here — the cursor sits on a column
-     * header whenever the user has arrowed up off the first row. A headless
-     * consumer switching on `ref.kind` has three cases to answer, and handing
-     * a header ref to `rowModel`'s `indexOf` / `nearestVisibleRef` is a
-     * category error: the row model has no header row to find.
-     */
-    readonly ref: PretableIndexedFocusRef<TRowId> | null;
-    readonly columnId: TColumnId | null;
-  }>;
-  readonly selection: Readonly<{
-    readonly rows:
-      | {
-          readonly kind: "explicit";
-          readonly rowIds: ReadonlySet<TRowId>;
-          readonly ranges?: PretableReactRowRangeIndex<TRowId>;
-          readonly excludedRanges?: PretableReactRowRangeIndex<TRowId>;
-        }
-      | {
-          readonly kind: "all";
-          readonly excludedRanges?: PretableReactRowRangeIndex<TRowId>;
-        };
-    readonly ranges: readonly {
-      readonly start: {
-        readonly rowId: TRowId;
-        readonly columnId: TColumnId;
-      };
-      readonly end: {
-        readonly rowId: TRowId;
-        readonly columnId: TColumnId;
-      };
-      /**
-       * Where these endpoints sit in the dataset, when the grid is serving a
-       * window that publishes a `datasetKey`. Declared for the same reason as
-       * `getCellSelectionSummary` above: this snapshot is what react-side
-       * code actually reads, and a field missing from it is a field no
-       * consumer can see.
-       */
-      readonly datasetRowSpan?: PretableIndexedDatasetRowSpan;
-    }[];
-    readonly anchor: {
-      readonly rowId: TRowId;
-      readonly columnId: TColumnId;
-    } | null;
-  }>;
-  readonly editing:
-    | {
-        readonly [TEditColumnId in ColumnIdOf<TColumns>]: {
-          readonly rowId: TRowId;
-          readonly columnId: TEditColumnId;
-          readonly value: ColumnValueOf<TColumns, TEditColumnId>;
-          readonly status: "editing" | "validating" | "saving" | "error";
-          readonly error?: string;
-        };
-      }[ColumnIdOf<TColumns>]
-    | null;
-  readonly columnLayout: readonly Readonly<{
-    readonly id: TColumnId;
-    readonly widthPx: number;
-    readonly pinned?: "left" | "right";
-  }>[];
-  readonly observedRowModelRevision: number | null;
-}
+> = PretableGridUiState<TRowId, TColumns, TColumnId>;
 
 /** Atomic indexed DOM-render snapshot. @public */
 export interface PretableIndexedRenderSnapshot<
@@ -552,13 +480,8 @@ export function usePretableModelInternal<
     );
   }
   const stores = useMemo(() => {
-    const internalModel = rowModel as unknown as InternalRowModel<
-      TRow,
-      TRowId,
-      TColumns
-    >;
     const gridCore = createGridUiCore<TRow, TRowId, TColumns, TColumnId>({
-      rowModel: internalModel,
+      rowModel,
       columns: initialColumns,
       viewport: {
         scrollTop: 0,
@@ -604,7 +527,7 @@ export function usePretableModelInternal<
       autoWidths.getState(),
     );
     const controller = createRowLayoutController<TRow, TRowId, TColumns>({
-      model: internalModel,
+      model: rowModel,
       columns: initialRenderColumns,
       // Estimates for rows the DOM has not rendered yet. Same value the
       // surface floors measured rows at, so the two agree under every theme.
@@ -899,27 +822,9 @@ export function usePretableModelInternal<
   return {
     grid,
     rowModel,
-    // NOT the schema-versus-drawn column confusion the `as never` casts here
-    // used to hide — that is now expressed by `TColumnId`, and the column ids
-    // on both sides of this line agree exactly. What survives is a nominal
-    // identity split in `PretableGroupId`: its `unique symbol` brand is
-    // emitted once by `tsc` into `grid-core/dist` and again by `tsup`'s
-    // bundled `.d.ts` into `core/dist`, and two `unique symbol`s from two
-    // declaration files are two different types. So `focus.ref`'s `group`
-    // variant is structurally identical and nominally distinct. Fixing it
-    // means changing how `@pretable/core` re-exports row-model's branded
-    // types, which is a different piece of work in different packages.
-    gridSnapshot: gridSnapshot as unknown as PretableGridUiSnapshot<
-      TRowId,
-      TColumns,
-      TColumnId
-    >,
+    gridSnapshot,
     rowModelSnapshot: rowModelState.snapshot,
-    renderSnapshot: renderSnapshot as PretableIndexedRenderSnapshot<
-      TRow,
-      TRowId,
-      TColumns
-    >,
+    renderSnapshot,
     status: rowModelState.status,
     setWindowSpacers,
   };
diff --git a/packages/react/src/pretable-surface.tsx b/packages/react/src/pretable-surface.tsx
index 424b1471..5d5bc456 100644
--- a/packages/react/src/pretable-surface.tsx
+++ b/packages/react/src/pretable-surface.tsx
@@ -53,21 +53,20 @@ import type {
   PretableRowChange as PretableTypedRowChange,
 } from "./types";
 import {
-  getIndexedCellSelectionSummary,
-  HEADER_FOCUS_REF,
-  indexedRangeContainsCell,
-} from "@pretable-internal/grid-core";
+  ɵgetIndexedCellSelectionSummary as getIndexedCellSelectionSummary,
+  ɵHEADER_FOCUS_REF as HEADER_FOCUS_REF,
+  ɵindexedRangeContainsCell as indexedRangeContainsCell,
+} from "@pretable/core";
 import type {
+  PretableFocusDirection,
   PretableIndexedFocusMovement,
-  PretableIndexedSelectionWindow,
-} from "@pretable-internal/grid-core";
+  PretableMoveFocusOptions,
+  ɵPretableIndexedSelectionWindow as PretableIndexedSelectionWindow,
+} from "@pretable/core";
 import {
   scrollLeftToReveal,
   scrollTopToReveal,
 } from "@pretable-internal/renderer-dom";
-
-type PretableFocusDirection = "up" | "down" | "left" | "right";
-
 import { planColumnLayout } from "@pretable-internal/renderer-dom";
 import { resolveColumnAlign } from "./column-align";
 import { computeColumnDropTarget } from "./column-drag-geometry";
@@ -407,7 +406,7 @@ interface SurfaceFacade<TRow extends PretableRow> {
   ): void;
   moveFocus(
     direction: PretableFocusDirection,
-    options?: { extend?: boolean; jumpToEdge?: boolean; byPage?: boolean },
+    options?: PretableMoveFocusOptions,
   ): void;
   setSelection(selection: PretableSelectionState): void;
   addRange(range: PretableCellRange): void;
@@ -2396,7 +2395,7 @@ export function PretableSurface<
       },
       moveFocus(
         direction: PretableFocusDirection,
-        options?: { extend?: boolean; jumpToEdge?: boolean; byPage?: boolean },
+        options?: PretableMoveFocusOptions,
       ) {
         // `Cmd/Ctrl + Arrow` jumps to the grid edge in the ARROW's direction,
         // which means the arrow chooses the axis as well as the end of it.
@@ -2418,18 +2417,7 @@ export function PretableSurface<
                   : "last-column"
             : direction;
         const before = indexedGrid.getState().focus;
-        // `usePretable`'s handle spells the movement union out inline instead
-        // of importing `PretableIndexedFocusMovement` (pretable-model.ts), so
-        // its copy is two members behind and rejects the column edges. The
-        // object underneath IS the grid-core engine and handles them; only the
-        // declaration is stale. Narrowed to this one call rather than widened
-        // across the handle, and typed to the real union so a future movement
-        // still has to be spelled correctly here.
-        (
-          indexedGrid.moveFocus as (
-            movement: PretableIndexedFocusMovement,
-          ) => void
-        )(movement);
+        indexedGrid.moveFocus(movement);
         if (options?.extend) {
           const after = indexedGrid.getState().focus;
           if (after.ref?.kind === "data" && after.columnId !== null) {
diff --git a/packages/react/src/public_api.ts b/packages/react/src/public_api.ts
index d228ca49..10be7ae5 100644
--- a/packages/react/src/public_api.ts
+++ b/packages/react/src/public_api.ts
@@ -92,8 +92,6 @@ export type {
   PretableGridUiSnapshot,
   PretableIndexedRenderSnapshot,
   PretableReactGrid,
-  PretableReactRowRange,
-  PretableReactRowRangeIndex,
 } from "./pretable-model";
 
 // React-extended column type + render-input shapes
@@ -244,6 +242,7 @@ export type {
   PretableIndexedDatasetRowSpan,
   PretableIndexedEditingState,
   PretableIndexedFocusMovement,
+  PretableIndexedMoveFocusOptions,
   PretableIndexedFocusRef,
   PretableIndexedFocusState,
   PretableIndexedRowRange,
@@ -253,6 +252,7 @@ export type {
   PretableIndexedSelectionSummary,
   PretableVisibleRowRef,
   Prettify,
+  PretableUninferredColumnValue,
   PretableViewportState,
   PretableVisibleRow,
   PretableVisibleRowField,
diff --git a/packages/renderer-dom/package.json b/packages/renderer-dom/package.json
index 0dfaaa76..4a279f08 100644
--- a/packages/renderer-dom/package.json
+++ b/packages/renderer-dom/package.json
@@ -18,15 +18,17 @@
     }
   },
   "dependencies": {
-    "@pretable-internal/grid-core": "workspace:*",
     "@pretable-internal/layout-core": "workspace:*",
-    "@pretable-internal/row-model": "workspace:*",
-    "@pretable-internal/text-core": "workspace:*"
+    "@pretable-internal/text-core": "workspace:*",
+    "@pretable/core": "workspace:*"
+  },
+  "devDependencies": {
+    "@pretable-internal/row-model": "workspace:*"
   },
   "scripts": {
-    "build": "pnpm --filter @pretable-internal/text-core build && pnpm --filter @pretable-internal/layout-core build && pnpm --filter @pretable-internal/grid-core build && tsc -b",
+    "build": "pnpm --filter @pretable-internal/text-core build && pnpm --filter @pretable-internal/layout-core build && pnpm --filter @pretable/core build && tsc -b",
     "lint": "eslint src --ext .ts,.tsx",
-    "test": "pnpm --filter @pretable-internal/text-core build && pnpm --filter @pretable-internal/layout-core build && pnpm --filter @pretable-internal/grid-core build && vitest run --passWithNoTests",
-    "typecheck": "pnpm --filter @pretable-internal/text-core build && pnpm --filter @pretable-internal/layout-core build && pnpm --filter @pretable-internal/grid-core build && tsc -b --pretty false && tsc -p tsconfig.typecheck.json --noEmit --pretty false"
+    "test": "pnpm --filter @pretable-internal/text-core build && pnpm --filter @pretable-internal/layout-core build && pnpm --filter @pretable/core build && vitest run --passWithNoTests",
+    "typecheck": "pnpm --filter @pretable-internal/text-core build && pnpm --filter @pretable-internal/layout-core build && pnpm --filter @pretable/core build && tsc -b --pretty false && tsc -p tsconfig.typecheck.json --noEmit --pretty false"
   }
 }
diff --git a/packages/renderer-dom/src/__tests__/indexed-renderer.test.ts b/packages/renderer-dom/src/__tests__/indexed-renderer.test.ts
index 78995d1c..4fcb3299 100644
--- a/packages/renderer-dom/src/__tests__/indexed-renderer.test.ts
+++ b/packages/renderer-dom/src/__tests__/indexed-renderer.test.ts
@@ -2,11 +2,19 @@ import { describe, expect, test, vi } from "vitest";
 
 import {
   createColumnHelper,
-  createLocalRowModel,
   type PretableChangeSet,
   type PretableGroupId,
   type PretableVisibleRowRef,
-} from "@pretable-internal/row-model";
+} from "@pretable/core";
+// The one import in this package that still reaches past `@pretable/core`, and
+// only because `changeJournalCapacity` is an internal knob the public factory
+// deliberately does not expose — the journal-overflow cases below need to set
+// it. Safe here in a way it is not in `src/`: the model is built with a
+// CONCRETE column tuple, so every conditional type in its shape resolves
+// eagerly and the two emissions agree by value rather than by alias identity.
+// Passing it to `createRowLayoutController`, which now types its `model`
+// through `@pretable/core`, is itself the assertion that they do.
+import { createLocalRowModel } from "@pretable-internal/row-model";
 import * as textCore from "@pretable-internal/text-core";
 
 import {
diff --git a/packages/renderer-dom/src/__tests__/window-spacer-coordinates.test.ts b/packages/renderer-dom/src/__tests__/window-spacer-coordinates.test.ts
index 3e2e3b75..52f1fef9 100644
--- a/packages/renderer-dom/src/__tests__/window-spacer-coordinates.test.ts
+++ b/packages/renderer-dom/src/__tests__/window-spacer-coordinates.test.ts
@@ -4,7 +4,7 @@ import {
   createColumnHelper,
   createLocalRowModel,
   type PretableVisibleRowRef,
-} from "@pretable-internal/row-model";
+} from "@pretable/core";
 
 import {
   createRowLayoutController,
diff --git a/packages/renderer-dom/src/create-renderer.ts b/packages/renderer-dom/src/create-renderer.ts
index c8a843f1..86085843 100644
--- a/packages/renderer-dom/src/create-renderer.ts
+++ b/packages/renderer-dom/src/create-renderer.ts
@@ -3,8 +3,12 @@ import {
   planColumns,
 } from "@pretable-internal/layout-core";
 import type { ColumnPlan } from "@pretable-internal/layout-core";
-import type { PretableColumn, PretableRow } from "@pretable-internal/grid-core";
-import type { PretableRowId } from "@pretable-internal/row-model";
+// One emission of the engine's declarations — see the note in `./types.ts`.
+import type {
+  PretableColumn,
+  PretableRow,
+  PretableRowId,
+} from "@pretable/core";
 import { layoutPreparedText, prepareText } from "@pretable-internal/text-core";
 import type { PreparedText } from "@pretable-internal/text-core";
 
diff --git a/packages/renderer-dom/src/row-layout-controller.ts b/packages/renderer-dom/src/row-layout-controller.ts
index 3f97e4db..6fd60a13 100644
--- a/packages/renderer-dom/src/row-layout-controller.ts
+++ b/packages/renderer-dom/src/row-layout-controller.ts
@@ -6,6 +6,7 @@ import {
   type RowHeightOperation,
   type RowHeightReplacementBuilder,
 } from "@pretable-internal/layout-core";
+// One emission of the engine's declarations — see the note in `./types.ts`.
 import type {
   PretableChangeOperation,
   PretableChangeSequence,
@@ -14,7 +15,7 @@ import type {
   PretableRowModelSnapshot,
   PretableVisibleRow,
   PretableVisibleRowRef,
-} from "@pretable-internal/row-model";
+} from "@pretable/core";
 
 import {
   DEFAULT_ROW_HEIGHT,
diff --git a/packages/renderer-dom/src/types.ts b/packages/renderer-dom/src/types.ts
index 658c2838..4a9ff604 100644
--- a/packages/renderer-dom/src/types.ts
+++ b/packages/renderer-dom/src/types.ts
@@ -4,6 +4,15 @@ import type {
   RowHeightIndex,
   RowMetricsReader,
 } from "@pretable-internal/layout-core";
+// Engine types come from `@pretable/core`, never from `@pretable-internal/*`
+// directly, even though the latter is where they are written. `@pretable/core`
+// re-emits those declarations into its own bundled `.d.ts` (`noExternal`), so
+// importing them from both places puts two emissions of one declaration in
+// front of the compiler at once — and TypeScript relates a deferred conditional
+// like `PretableAggregateOutputOf<TAggregate>` by the identity of its alias, not
+// its shape. `@pretable/react` compiles this package's `.d.ts` alongside
+// `core/dist`, so the mismatch landed there, as `as unknown as` casts crossing
+// its own row model into this controller. One emission, no crossing.
 import type {
   PretableGroupId,
   PretableGroupRow as IndexedPretableGroupRow,
@@ -12,7 +21,7 @@ import type {
   PretableRowModelSnapshot,
   PretableVisibleRow,
   PretableVisibleRowRef,
-} from "@pretable-internal/row-model";
+} from "@pretable/core";
 
 /** The vertical window owned by an indexed row-layout controller. */
 export interface RowLayoutViewport {
@@ -114,8 +123,6 @@ export interface RowLayoutControllerState<
   readonly leadingHeight: number;
 }
 
-declare const rowLayoutControllerType: unique symbol;
-
 export interface RowLayoutController<
   TRow extends object,
   TRowId extends PretableRowId,
@@ -132,8 +139,14 @@ export interface RowLayoutController<
     height: number,
   ) => void;
   readonly dispose: () => void;
-  /** @internal Compile-time-only invariant descriptor. */
-  readonly [rowLayoutControllerType]?: (
+  /**
+   * @internal Compile-time-only invariant descriptor. Keyed by a string
+   * literal, not a `unique symbol`, for the reason given over `PretableGroupId`
+   * in `@pretable-internal/row-model`'s `types.ts`: this package is `noExternal`
+   * in `@pretable/react`'s bundle, so its declarations get re-emitted, and a
+   * symbol brand is nominal per declaration file.
+   */
+  readonly "~pretableRowLayoutController"?: (
     value: readonly [TRow, TRowId, TColumns],
   ) => readonly [TRow, TRowId, TColumns];
 }
diff --git a/packages/renderer-dom/tsconfig.json b/packages/renderer-dom/tsconfig.json
index 3954b8e8..278b2869 100644
--- a/packages/renderer-dom/tsconfig.json
+++ b/packages/renderer-dom/tsconfig.json
@@ -7,12 +7,17 @@
   },
   "include": ["src"],
   "exclude": ["src/**/*.test.*", "src/**/__tests__/**"],
+  // No project reference to `../row-model` or `../grid-core`: this package
+  // reaches the engine's types through `@pretable/core`'s built `.d.ts`, which
+  // is not a `tsc -b` project. See the note in `src/types.ts` — one emission of
+  // those declarations is the point, and a reference here would reintroduce the
+  // second one.
   "references": [
     {
-      "path": "../row-model"
+      "path": "../layout-core"
     },
     {
-      "path": "../grid-core"
+      "path": "../text-core"
     }
   ]
 }
diff --git a/packages/renderer-dom/vitest.config.ts b/packages/renderer-dom/vitest.config.ts
new file mode 100644
index 00000000..e70df41f
--- /dev/null
+++ b/packages/renderer-dom/vitest.config.ts
@@ -0,0 +1,37 @@
+import { resolve } from "node:path";
+
+import { defineConfig } from "vitest/config";
+
+// Every workspace dependency is aliased to its TypeScript source, for the same
+// reason `packages/react/vitest.config.ts` does it: anything left out resolves
+// through `exports` to that package's `dist/`, so a bare `vitest run` would
+// test the last build instead of the working tree.
+//
+// The transitive `@pretable-internal/*` entries are not optional. This package
+// now reaches the engine through `@pretable/core` (see `src/types.ts`), and
+// aliasing `@pretable/core` to source does not cover what THAT source imports —
+// its re-exports of `@pretable-internal/grid-core` and
+// `@pretable-internal/row-model` are resolved from scratch.
+export default defineConfig({
+  resolve: {
+    alias: {
+      "@pretable/core": resolve(__dirname, "../core/src/index.ts"),
+      "@pretable-internal/grid-core": resolve(
+        __dirname,
+        "../grid-core/src/index.ts",
+      ),
+      "@pretable-internal/layout-core": resolve(
+        __dirname,
+        "../layout-core/src/index.ts",
+      ),
+      "@pretable-internal/row-model": resolve(
+        __dirname,
+        "../row-model/src/index.ts",
+      ),
+      "@pretable-internal/text-core": resolve(
+        __dirname,
+        "../text-core/src/index.ts",
+      ),
+    },
+  },
+});
diff --git a/packages/row-model/src/column-types.ts b/packages/row-model/src/column-types.ts
index a050ee25..c19f533d 100644
--- a/packages/row-model/src/column-types.ts
+++ b/packages/row-model/src/column-types.ts
@@ -55,13 +55,28 @@ export type PretableAggregateSpec<TRow extends object, TValue> =
   | PretableBuiltinAggregate<TValue>
   | PretableCompatibleAggregator<TRow, TValue, unknown>;
 
-declare const columnDescriptor: unique symbol;
+/**
+ * Compile-time-only sentinel for `PretableColumnHelper.accessor`'s `TValue`:
+ * it means "no value type has been inferred from the accessor yet", which is
+ * what lets the helper offer the widened `type` and `aggregate` choices in the
+ * accessor-form overload and the narrowed ones everywhere else.
+ *
+ * It is an interface with an unwritable key rather than the `unique symbol` it
+ * replaced, for the reason spelled out over `PretableGroupId` in `./types.ts`:
+ * a `unique symbol` is nominal per declaration file, and these declarations are
+ * re-emitted into `core/dist` by `tsup`'s bundled `.d.ts`.
+ *
+ * @public
+ */
+export interface PretableUninferredColumnValue {
+  readonly "~pretableUninferredColumnValue": true;
+}
 
 /** Compile-time-only accessor-form carrier emitted by the column helper. @public */
 export interface PretableColumnAccessorKind<
   TKind extends "direct" | "computed",
 > {
-  readonly [columnDescriptor]: { readonly accessorKind: TKind };
+  readonly "~pretableColumn": { readonly accessorKind: TKind };
 }
 
 /** @public */
@@ -141,7 +156,7 @@ export interface PretableColumnDefinition<
       PretableColumnDefinition<TRow, TId, TValue, TType, TAggregate>
     >,
   ) => string;
-  readonly [columnDescriptor]: {
+  readonly ["~pretableColumn"]: {
     readonly row: TRow;
     readonly id: TId;
     readonly value: TValue;
@@ -226,15 +241,15 @@ export interface PretableColumnHelper<TRow extends object> {
       | (unknown extends NoInfer<TValue>
           ? never
           : PretableColumnTypeFor<NoInfer<TValue>>)
-      | ([TValue] extends [typeof columnDescriptor]
+      | ([TValue] extends [PretableUninferredColumnValue]
           ? [ReturnType<TAccessor>] extends [never]
             ? never
             : PretableColumnType
           : never),
-    TValue = typeof columnDescriptor,
+    TValue = PretableUninferredColumnValue,
     const TAggregate extends
       | PretableAggregateSpec<TRow, NoInfer<TValue>>
-      | ([TValue] extends [typeof columnDescriptor]
+      | ([TValue] extends [PretableUninferredColumnValue]
           ? [ReturnType<TAccessor>] extends [never]
             ? never
             : PretableAggregateSpec<TRow, never> | "sum" | "avg" | "min" | "max"
@@ -585,7 +600,7 @@ export interface PretableColumnDerivation<
     TValue,
     TAggregate
   >;
-  readonly [columnDescriptor]: {
+  readonly ["~pretableColumn"]: {
     readonly row: TRow;
     readonly id: TId;
     readonly value: TValue;
diff --git a/packages/row-model/src/types.ts b/packages/row-model/src/types.ts
index ad70df1f..57930707 100644
--- a/packages/row-model/src/types.ts
+++ b/packages/row-model/src/types.ts
@@ -8,12 +8,31 @@ import type {
 } from "./column-types";
 import type { PretableRowModelError } from "./errors";
 
-declare const groupIdBrand: unique symbol;
-declare const rowModelDescriptor: unique symbol;
+/**
+ * Brand keys are STRING literals, not `unique symbol`s, and that is load-bearing
+ * packaging rather than style.
+ *
+ * These types ship to consumers three ways at once: `tsc` emits them into
+ * `row-model/dist`, and `tsup`'s bundled `.d.ts` re-emits them into
+ * `core/dist` (`noExternal`) — with `@pretable/react` compiling against BOTH at
+ * once. A `unique symbol` is nominal PER DECLARATION FILE, so each re-emission
+ * minted a fresh, incompatible brand: `PretableGroupId` from `row-model/dist`
+ * was not assignable to `PretableGroupId` from `core/dist` despite being the
+ * same declaration, and `RowOf<>`/`ColumnsOf<>` — which match structurally on
+ * `~pretableRowModel` — silently resolved to `never` across the seam. The
+ * repository carried two `as unknown as` casts to paper over exactly that.
+ *
+ * A string-literal key is structural, so N copies of the declaration are one
+ * type. Nominality is unchanged in practice: `PretableGroupId` is
+ * `string & {...}`, which no literal can inhabit without a cast, and the `~`
+ * prefix keeps the key unwritable as an identifier (the Standard Schema
+ * convention). `scripts/__tests__/public-api-symbol-brands.test.mjs` fails the
+ * build if a symbol-keyed brand reappears in a published API report.
+ */
 
 /** @public */
 export type PretableGroupId = string & {
-  readonly [groupIdBrand]: "PretableGroupId";
+  readonly "~pretableGroupId": "PretableGroupId";
 };
 
 /** @public */
@@ -332,7 +351,7 @@ export interface PretableRowModel<
   TRowId extends PretableRowId,
   TColumns,
 > {
-  readonly [rowModelDescriptor]: {
+  readonly ["~pretableRowModel"]: {
     readonly row: TRow;
     readonly rowId: TRowId;
     readonly columns: TColumns;
@@ -388,7 +407,7 @@ export interface PretableRowModel<
 
 /** @public */
 export type RowOf<TModel> = TModel extends {
-  readonly [rowModelDescriptor]: {
+  readonly ["~pretableRowModel"]: {
     readonly row: infer TRow extends object;
   };
 }
@@ -397,7 +416,7 @@ export type RowOf<TModel> = TModel extends {
 
 /** @public */
 export type RowIdOf<TModel> = TModel extends {
-  readonly [rowModelDescriptor]: {
+  readonly ["~pretableRowModel"]: {
     readonly rowId: infer TRowId extends PretableRowId;
   };
 }
@@ -406,7 +425,7 @@ export type RowIdOf<TModel> = TModel extends {
 
 /** @public */
 export type ColumnsOf<TModel> = TModel extends {
-  readonly [rowModelDescriptor]: { readonly columns: infer TColumns };
+  readonly ["~pretableRowModel"]: { readonly columns: infer TColumns };
 }
   ? TColumns
   : never;
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 52900ebe..837d94dd 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -323,18 +323,19 @@ importers:
 
   packages/renderer-dom:
     dependencies:
-      '@pretable-internal/grid-core':
-        specifier: workspace:*
-        version: link:../grid-core
       '@pretable-internal/layout-core':
         specifier: workspace:*
         version: link:../layout-core
-      '@pretable-internal/row-model':
-        specifier: workspace:*
-        version: link:../row-model
       '@pretable-internal/text-core':
         specifier: workspace:*
         version: link:../text-core
+      '@pretable/core':
+        specifier: workspace:*
+        version: link:../core
+    devDependencies:
+      '@pretable-internal/row-model':
+        specifier: workspace:*
+        version: link:../row-model
 
   packages/row-model:
     devDependencies:
diff --git a/scripts/__tests__/public-api-symbol-brands.test.mjs b/scripts/__tests__/public-api-symbol-brands.test.mjs
new file mode 100644
index 00000000..07392699
--- /dev/null
+++ b/scripts/__tests__/public-api-symbol-brands.test.mjs
@@ -0,0 +1,146 @@
+import assert from "node:assert/strict";
+import { readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+
+/**
+ * **The invariant: no published type may be branded by a `unique symbol`.**
+ *
+ * A `unique symbol` is nominal PER DECLARATION FILE. Pretable's published
+ * declarations exist in more than one file by construction: `tsc` emits
+ * `@pretable-internal/*` into each package's own `dist`, and `tsup`'s bundled
+ * `.d.ts` re-emits the same declarations into `packages/core/dist` (they are
+ * `noExternal`, so the bundle owns one runtime copy of each private engine).
+ * Every re-emission of a `declare const brand: unique symbol` mints a NEW type,
+ * so two spellings of one declaration stop being assignable to each other.
+ *
+ * That is not hypothetical. Four brands were affected — `groupIdBrand` and
+ * `rowModelDescriptor` (row-model `types.ts`), `columnDescriptor` (row-model
+ * `column-types.ts`) and `gridUiCoreType` (grid-core `types.ts`) — and two of
+ * them were live: `packages/react/src/pretable-model.ts` carried two
+ * `as unknown as` casts whose only job was to cross the seam. The silent half
+ * was worse than the casts: `RowOf<>` / `RowIdOf<>` / `ColumnsOf<>` match
+ * structurally on the row-model brand, so across the seam they resolved to
+ * `never` with no error at all.
+ *
+ * The remedy is a string-literal key (`readonly "~pretableGroupId"`), which is
+ * structural: N copies of the declaration are one type. Nominality survives
+ * because the branded types are intersections nothing can inhabit by accident,
+ * and the `~` prefix keeps the key unwritable as an identifier.
+ *
+ * **What this guard reads, and why.** The committed `.api.md` reports, not
+ * `dist/`. They are always present (a missing one already fails
+ * `public-api-forgotten-exports.test.mjs`), their freshness is separately gated
+ * by the required "API Extractor — report freshness" check, and — unlike a
+ * `dist/` scan — they show only what is actually PUBLISHED. A symbol brand
+ * surfaces there unmistakably: API Extractor prints the member's computed key
+ * verbatim (`readonly [groupIdBrand]: "PretableGroupId";`) while never emitting
+ * the ambient `declare const` it names, so the report is not even self-
+ * consistent.
+ *
+ * **What makes it self-enforcing.** The package set is discovered from
+ * `api-extractor.json` — the file that MAKES a package produce a report — so a
+ * newly published package is covered the day it is configured, with no edit
+ * here. Modelled on `scripts/__tests__/public-api-forgotten-exports.test.mjs`.
+ */
+
+const REPO_ROOT = fileURLToPath(new URL("../..", import.meta.url));
+const PACKAGES_DIR = join(REPO_ROOT, "packages");
+
+/**
+ * A member keyed by a computed identifier: `readonly [groupIdBrand]: ...`,
+ * `[rowModelDescriptor]?: ...`. Deliberately NOT anchored on `readonly` — a
+ * mutable or optional brand is the same defect.
+ *
+ * Well-known symbols (`[Symbol.iterator]`, `[Symbol.asyncIterator]`) are real,
+ * legitimate computed keys and are excluded: they are declared by the standard
+ * library, so every declaration file resolves them to the SAME symbol and none
+ * of the reasoning above applies.
+ */
+const SYMBOL_KEYED_MEMBER_RE =
+  /^\s*(?:readonly\s+)?\[([A-Za-z_$][A-Za-z0-9_$]*)\]\??\s*:/gm;
+
+const REMEDY = [
+  "Replace the `unique symbol` key with a string-literal key:",
+  "",
+  "  -declare const fooBrand: unique symbol;",
+  "  -export type Foo = string & { readonly [fooBrand]: 'Foo' };",
+  "  +export type Foo = string & { readonly '~pretableFoo': 'Foo' };",
+  "",
+  "It is structural, so the copy `tsup` re-emits into packages/core/dist is the",
+  "SAME type as the one `tsc` emits into the internal package's dist. A string",
+  "key is no weaker here: the branded types are intersections no literal can",
+  "inhabit without a cast, and `~` cannot be written as an identifier.",
+  "",
+  "Then: pnpm build && pnpm api   (build first, or a stale dist/ produces a",
+  "false report).",
+].join("\n");
+
+/**
+ * Packages that produce an API report, discovered from the config that makes
+ * them produce one. Returns `{ name, reportPath }`, sorted.
+ */
+function discoverReportedPackages() {
+  const found = [];
+
+  for (const entry of readdirSync(PACKAGES_DIR, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+
+    const dir = join(PACKAGES_DIR, entry.name);
+    let config;
+
+    try {
+      config = JSON.parse(
+        readFileSync(join(dir, "api-extractor.json"), "utf8"),
+      );
+    } catch {
+      continue; // No report configured for this package.
+    }
+
+    // `apiReport.enabled` is inherited from api-extractor.base.json when the
+    // package config does not restate it; only an explicit `false` opts out.
+    if (config.apiReport?.enabled === false) continue;
+
+    found.push({
+      name: entry.name,
+      reportPath: join(dir, `${entry.name}.api.md`),
+    });
+  }
+
+  return found.sort((a, b) => a.name.localeCompare(b.name));
+}
+
+const REPORTED_PACKAGES = discoverReportedPackages();
+
+test("the symbol-brand guard has reports to read", () => {
+  assert.ok(
+    REPORTED_PACKAGES.length > 0,
+    `Found no packages with an api-extractor.json under ${PACKAGES_DIR}. ` +
+      "This guard cannot check anything, which means it would pass vacuously. " +
+      "If the api-extractor config moved, update discoverReportedPackages().",
+  );
+});
+
+for (const { name, reportPath } of REPORTED_PACKAGES) {
+  test(`@pretable/${name} brands no published type with a unique symbol`, () => {
+    const raw = readFileSync(reportPath, "utf8");
+
+    const offenders = [...raw.matchAll(SYMBOL_KEYED_MEMBER_RE)]
+      .map((match) => ({
+        key: match[1],
+        line: raw.slice(0, match.index).split("\n").length,
+      }))
+      .filter((hit) => !hit.key.startsWith("Symbol"));
+
+    assert.deepEqual(
+      offenders.map((hit) => `${name}.api.md:${hit.line} [${hit.key}]`),
+      [],
+      `@pretable/${name} publishes ${offenders.length} type member(s) keyed by a symbol.\n` +
+        `A \`unique symbol\` is nominal per declaration file, and these declarations are\n` +
+        `emitted into more than one file, so each copy is a different type — which shows\n` +
+        `up as a cast at the seam, or as a conditional type silently resolving to never.\n\n` +
+        `${REMEDY}`,
+    );
+  });
+}
diff --git a/type-tests/react/focus-movement-union.types.tsx b/type-tests/react/focus-movement-union.types.tsx
new file mode 100644
index 00000000..1912b77b
--- /dev/null
+++ b/type-tests/react/focus-movement-union.types.tsx
@@ -0,0 +1,121 @@
+/**
+ * Consumer-level type tests: these resolve `@pretable/core` and
+ * `@pretable/react` to their BUILT `.d.ts`, which is the surface a published
+ * consumer sees. Run by `pnpm typecheck:public`.
+ *
+ * **What they pin.** `PretableReactGrid.moveFocus` used to spell its movement
+ * union out by hand instead of importing `PretableIndexedFocusMovement`. When
+ * `"first-column"` and `"last-column"` were added to the real union, the copy
+ * did not follow, the build broke, and the repair was a cast at the call site
+ * in `pretable-surface.tsx` — so the handle stayed two members behind while
+ * looking fine.
+ *
+ * The assertions below are `Equal`, not "accepts these strings". A test that
+ * only fed literals through would still pass against a stale copy that happened
+ * to contain them, and would keep passing if the handle were widened to
+ * `string`. `Equal` fails in BOTH directions: if a member is added to
+ * `PretableIndexedFocusMovement` and the handle does not follow, and if the
+ * handle grows a member the engine cannot execute.
+ *
+ * Adding a member to `PretableIndexedFocusMovement` must NOT require editing
+ * `pretable-model.ts`. It does require editing `EVERY_MOVEMENT` here, which is
+ * the point: that list is the runtime counterpart, exercised by
+ * `packages/react/src/__tests__/move-focus-movements.test.tsx`, and a movement
+ * nobody drives is a movement nobody has checked.
+ */
+import {
+  createColumnHelper,
+  type PretableIndexedFocusMovement,
+  type PretableIndexedMoveFocusOptions,
+} from "@pretable/core";
+import { usePretable, type PretableReactGrid } from "@pretable/react";
+import type { Equal, Expect } from "../shared/assert";
+
+interface Holding {
+  id: number;
+  symbol: string;
+  quantity: number;
+}
+
+const column = createColumnHelper<Holding>();
+const columns = [
+  column.accessor("symbol", { type: "text" }),
+  column.accessor("quantity", { type: "number" }),
+] as const;
+
+const rows: readonly Holding[] = [{ id: 1, symbol: "PRE", quantity: 10 }];
+
+const { grid } = usePretable({ rows, columns, viewportHeight: 320 });
+
+type Grid = typeof grid;
+type MoveFocus = Grid["moveFocus"];
+
+/**
+ * The handle's movement parameter IS the engine's union — not a superset, not a
+ * subset, and not `string`.
+ */
+type _MovementIsTheRealUnion = Expect<
+  Equal<Parameters<MoveFocus>[0], PretableIndexedFocusMovement>
+>;
+
+/** Same for the options, which were a duplicated `{ pageRows?: number }`. */
+type _OptionsAreTheRealOptions = Expect<
+  Equal<Parameters<MoveFocus>[1], PretableIndexedMoveFocusOptions | undefined>
+>;
+
+/**
+ * The column edges specifically: the two members the hand-copied union was
+ * missing. Kept as their own assertion so a regression names them.
+ */
+type _ColumnEdgesReachable = Expect<
+  Equal<
+    Extract<Parameters<MoveFocus>[0], "first-column" | "last-column">,
+    "first-column" | "last-column"
+  >
+>;
+
+/**
+ * Every member, enumerated. Exhaustive by construction: it is typed as the
+ * union itself, so dropping one makes the array's element type narrower than
+ * `PretableIndexedFocusMovement` and `_EveryMovementEnumerated` fails.
+ */
+export const EVERY_MOVEMENT = [
+  "up",
+  "down",
+  "left",
+  "right",
+  "page-up",
+  "page-down",
+  "home",
+  "end",
+  "first-column",
+  "last-column",
+  "tab",
+  "shift-tab",
+  "parent",
+] as const satisfies readonly PretableIndexedFocusMovement[];
+
+type _EveryMovementEnumerated = Expect<
+  Equal<(typeof EVERY_MOVEMENT)[number], PretableIndexedFocusMovement>
+>;
+
+for (const movement of EVERY_MOVEMENT) grid.moveFocus(movement);
+grid.moveFocus("page-down", { pageRows: 12 });
+
+/**
+ * `PretableReactGrid` names the same signature when spelled by a consumer
+ * generically, so the guarantee is not an artifact of inference at this one
+ * call site.
+ */
+type DeclaredGrid = PretableReactGrid<Holding, number, typeof columns>;
+type _DeclaredMovement = Expect<
+  Equal<Parameters<DeclaredGrid["moveFocus"]>[0], PretableIndexedFocusMovement>
+>;
+
+export type FocusMovementAssertions = [
+  _MovementIsTheRealUnion,
+  _OptionsAreTheRealOptions,
+  _ColumnEdgesReachable,
+  _EveryMovementEnumerated,
+  _DeclaredMovement,
+];

From 93e6491610e598844f22bfe59fe7bda31578df7f Mon Sep 17 00:00:00 2001
From: Brian Love <brian@liveloveapp.com>
Date: Sun, 16 Aug 2026 20:54:55 -0700
Subject: [PATCH 3/3] fix(react): forward moveFocus options, not just the
 movement
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

My merge resolution kept HEAD for all three conflicts in this file. That was
right for two of them, and wrong here: main's side did not merely add a cast,
it forwarded the options argument. Dropping it compiles and silently pages by
the engine's constant instead of the body viewport — caught by
page-key-navigation's 'sizes the page from the BODY viewport' test.
---
 packages/react/src/pretable-surface.tsx | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/packages/react/src/pretable-surface.tsx b/packages/react/src/pretable-surface.tsx
index d1894f4c..14f6dd92 100644
--- a/packages/react/src/pretable-surface.tsx
+++ b/packages/react/src/pretable-surface.tsx
@@ -2426,7 +2426,11 @@ export function PretableSurface<
                   : "last-column"
             : direction;
         const before = indexedGrid.getState().focus;
-        indexedGrid.moveFocus(movement);
+        // `pageRows` has to be forwarded, not just accepted: the page step is a
+        // screen's worth of the BODY viewport, which only the surface can
+        // measure, and the engine falls back to a constant without it. Dropping
+        // it here compiles and silently pages by the wrong amount.
+        indexedGrid.moveFocus(movement, options);
         if (options?.extend) {
           const after = indexedGrid.getState().focus;
           // A move the engine REFUSED must not move the selection either.