@jxsuite/studio 6.1.1 → 8.0.0

package/src/grid/grid-panel.ts

@@ -41,6 +41,7 @@ import { createGridController, getGridController } from "./grid-controller";
 import { createCsvFileSource } from "./sources/csv-file-source";
 import { loadedGridEngine, loadGridEngine } from "./grid-lazy";
 import { parseGridTabId } from "./grid-source";
+import { clearGridReveal, pendingGridReveal } from "./grid-reveal";
 import { mountGridPanelSurface } from "../surfaces/grid-panel";
 import { openGridViewsSurface } from "../surfaces/grid-views";
 import { openGridReplaceSurface } from "../surfaces/grid-replace";
@@ -56,6 +57,7 @@ import {
   saveViewAs,
 } from "./grid-layout";
 import { argsSchema, stringArg, stringProperty } from "../commands/command-args";
+import type { CommandArgValues } from "../commands/command-args";
 import type { EffectScope } from "@vue/reactivity";
 import type { GridController } from "./grid-controller";
 import type { GridLayout, GridSortSpec } from "./grid-layout";
@@ -69,7 +71,7 @@ import type {
   GridPanelView,
 } from "../surfaces/grid-panel";
 import type { GridViewsSurfaceHandle, GridViewsView } from "../surfaces/grid-views";
-import type { GridReplaceSurfaceHandle } from "../surfaces/grid-replace";
+import type { PopoverSurfaceHandle } from "../ui/popover-surface";
 
 interface ActiveGridPanel {
   /** The pane whose stage this grid is drawn on. */
@@ -85,7 +87,7 @@ interface ActiveGridPanel {
   /** Where that panel was opened, so a re-projection cannot move it back to the origin. */
   viewsAt: { x: number; y: number };
   /** Find & replace while it is open. */
-  replace: GridReplaceSurfaceHandle | null;
+  replace: PopoverSurfaceHandle | null;
   /**
    * Rebuild the engine over the same controller.
    *
@@ -614,15 +616,66 @@ export function renderGridMode(surface: CanvasSurface, tab: Tab) {
           }
           restored = true;
           const layout = loadGridLayout(engine.source.id);
-          void engine.setSort(layout?.sort ?? null);
-          engine.setGrouping(layout?.groupBy ?? null);
+          restoreStoredOrder(engine, layout);
           view.setSearch(layout?.filter ?? "");
         });
       }
+      revealRequested(engine, panel, tab.documentPath);
     });
   });
 }
 
+/**
+ * Put the stored sort and grouping back on a freshly built engine, asking the controller only for
+ * what differs from the order it already holds.
+ *
+ * The controller outlives the panel: leaving the grid's workspace and coming back rebuilds the
+ * table but keeps the controller, so on every return after the first the stored order IS the
+ * controller's order. Asking for it anyway was not free. Each of `setSort` and `setGrouping`
+ * re-projects the rows into the view, and a view still building parks that as a refresh it runs the
+ * moment it is built, so every open rendered its rows twice (the second time measuring every row's
+ * height again); a remote-sorting source re-queried its backend for the same rows on top. An
+ * explicit change (a saved view applied, a header in the Views popover) still goes straight to the
+ * controller, so re-asking for the order you are looking at keeps its meaning there.
+ */
+export function restoreStoredOrder(engine: GridController, layout: GridLayout | null): void {
+  const sort = layout?.sort ?? null;
+  const { query, grouping } = engine.state;
+  const sortHeld =
+    sort === null
+      ? query.orderBy === undefined
+      : query.orderBy === sort.field && query.dir === sort.dir;
+  if (!sortHeld) {
+    void engine.setSort(sort);
+  }
+  const groupBy = layout?.groupBy ?? null;
+  if (grouping !== groupBy) {
+    engine.setGrouping(groupBy);
+  }
+}
+
+/**
+ * Land on the row a record's opener asked for (`grid-reveal.ts`), once the engine and the rows
+ * exist. The position counts the file's data rows as loaded, so it names a row whatever order a
+ * saved view sorts them into. The request is taken either way: a row that is gone is not revealed
+ * later by surprise.
+ */
+function revealRequested(
+  engine: GridController,
+  panel: ActiveGridPanel,
+  path: string | null | undefined,
+): void {
+  const position = pendingGridReveal(path);
+  if (position === undefined || !path || !panel.view || engine.state.loading) {
+    return;
+  }
+  clearGridReveal(path);
+  const row = engine.state.rows[position];
+  if (row) {
+    void panel.view.revealRow(row.key);
+  }
+}
+
 /** The frame a tab with no grid source draws: one sentence, and no controls to press. */
 function missingView(): GridPanelView {
   return {
@@ -692,6 +745,12 @@ function requireSurface(commandId: string) {
   return surface;
 }
 
+/** A saved view, addressed by the grid it was saved for. */
+interface SavedViewRef {
+  gridId: string;
+  name: string;
+}
+
 /**
  * Saved views, as commands.
  *
@@ -703,10 +762,10 @@ function requireSurface(commandId: string) {
  * @returns {AnyCommand[]}
  */
 export function gridViewCommands(): AnyCommand[] {
-  const viewNameArg = (commandId: string, args: unknown): { gridId: string; name: string } => {
+  const viewNameArg = (commandId: string, args: CommandArgValues): SavedViewRef => {
     const { controller } = requireSurface(commandId);
     const gridId = controller.source.id;
-    const name = stringArg(commandId, args as Record<string, unknown>, "name");
+    const name = stringArg(commandId, args, "name");
     const known = listSavedViews(gridId).map((view) => view.name);
     if (!known.includes(name)) {
       throw new RangeError(

package/src/grid/grid-reveal.ts

@@ -0,0 +1,34 @@
+/**
+ * The row a file's grid should land on when it opens: a file-backed collection's record.
+ *
+ * A collection whose `source` names one file (`./content/projects.csv`) is written in that file's
+ * grid, so opening one of its records in the Content home opens the file (`specs/studio.md` §22.5).
+ * Opening the whole table and leaving the reader to find the row they clicked is not opening the
+ * record, so the opener names the record's position here and the grid selects that row and scrolls
+ * it into view once its rows have loaded.
+ *
+ * Reactive and keyed by the file's path, so a request reaches a grid that is already on screen as
+ * well as one still loading: the grid panel's one effect reads it, applies it and takes it.
+ *
+ * @docs studio/projects/browse
+ */
+
+import { reactive } from "../reactivity";
+
+/** File path → the position of the row to reveal, among the file's data rows from 0. */
+const pending = reactive(new Map<string, number>());
+
+/** Ask the grid of `path` to reveal the row at `position` (its place among the data rows, from 0). */
+export function requestGridReveal(path: string, position: number): void {
+  pending.set(path, position);
+}
+
+/** The row the grid of `path` is asked to reveal, or `undefined`. Reading it tracks it. */
+export function pendingGridReveal(path: string | null | undefined): number | undefined {
+  return path ? pending.get(path) : undefined;
+}
+
+/** Drop the request for `path` once the grid has acted on it. */
+export function clearGridReveal(path: string): void {
+  pending.delete(path);
+}

package/src/grid/grid-source.ts

@@ -6,6 +6,7 @@
  * pending edits; they never see the grid engine. Grid tabs over non-file sources are "virtual" —
  * their tab id is a `grid://` URI rather than a document path.
  */
+import { isNonNullObject } from "@jxsuite/schema/guards";
 import type { JsonSchema } from "../ui/schema-form";
 
 /** A single cell value. JSON-shaped so batches serialize cleanly. */
@@ -126,14 +127,7 @@ export function cellValuesEqual(a: GridCellValue, b: GridCellValue): boolean {
   if (Array.isArray(a) && Array.isArray(b)) {
     return a.length === b.length && a.every((v, i) => v === b[i]);
   }
-  if (
-    a !== null &&
-    b !== null &&
-    typeof a === "object" &&
-    typeof b === "object" &&
-    !Array.isArray(a) &&
-    !Array.isArray(b)
-  ) {
+  if (isNonNullObject(a) && isNonNullObject(b) && !Array.isArray(a) && !Array.isArray(b)) {
     return a.$ref === b.$ref;
   }
   return false;
@@ -144,18 +138,14 @@ export function cellValuesEqual(a: GridCellValue, b: GridCellValue): boolean {
 const GRID_SCHEME = "grid://";
 
 /**
- * The virtual sources a tab id can name.
- *
- * `library` is the odd one and deliberately so: the Library is a source over this same contract
- * (`browse/library-source.ts`) but its tab's editor kind is `library`, not `grid` — Table is one of
- * its five layouts rather than its identity. It lives in this id space because "which virtual tab
- * is this?" has exactly one answer per window and there is no second scheme worth inventing.
- * Category and layout are VIEW state and are deliberately absent from the id: a Library that
- * changed identity when you clicked "Pages" would open a second tab per filter.
+ * Placeholder document for grid tabs: the grid never reads it, and save routes to the controller.
+ * Every tab takes its own `structuredClone` of it.
  */
+export const GRID_STUB_DOCUMENT = { children: [], tagName: "div" };
+
+/** The virtual sources a grid tab id can name. */
 export type GridTabRef =
   | { kind: "pages" }
-  | { kind: "library" }
   | { kind: "collection"; name: string }
   | { kind: "data"; connection: string; table: string };
 
@@ -165,9 +155,6 @@ export function makeGridTabId(ref: GridTabRef): string {
     case "pages": {
       return `${GRID_SCHEME}pages`;
     }
-    case "library": {
-      return `${GRID_SCHEME}library`;
-    }
     case "collection": {
       return `${GRID_SCHEME}collection/${encodeURIComponent(ref.name)}`;
     }
@@ -191,9 +178,6 @@ export function parseGridTabId(id: string): GridTabRef | null {
   if (parts[0] === "pages" && parts.length === 1) {
     return { kind: "pages" };
   }
-  if (parts[0] === "library" && parts.length === 1) {
-    return { kind: "library" };
-  }
   if (parts[0] === "collection" && parts.length === 2 && parts[1]) {
     return { kind: "collection", name: decodeURIComponent(parts[1]) };
   }
@@ -208,11 +192,8 @@ export function parseGridTabId(id: string): GridTabRef | null {
 }
 
 /**
- * Short human label for a virtual tab ("posts · grid", "users @ main · grid", "Pages · grid").
- *
- * The Library is just "Library": the `· grid` suffix distinguishes a grid over a source from the
- * document tab of the same name, and the Library has no document tab to be confused with — nor is a
- * grid what it is, only what one of its layouts draws.
+ * Short human label for a virtual tab ("posts · grid", "users @ main · grid", "Pages · grid"). The
+ * `· grid` suffix distinguishes a grid over a source from the document tab of the same name.
  */
 export function gridTabLabel(id: string): string | null {
   const ref = parseGridTabId(id);
@@ -223,9 +204,6 @@ export function gridTabLabel(id: string): string | null {
     case "pages": {
       return "Pages · grid";
     }
-    case "library": {
-      return "Library";
-    }
     case "collection": {
       return `${ref.name} · grid`;
     }

package/src/grid/grid-view.ts

@@ -37,6 +37,7 @@ import type {
   ColumnComponent,
   ColumnDefinition,
   RowComponent,
+  RowData,
 } from "tabulator-tables";
 import type { GridCellValue, GridColumn } from "./grid-source";
 import type { GridController } from "./grid-controller";
@@ -51,6 +52,12 @@ export interface GridView {
   getSelectedRowKeys: () => string[];
   /** Local text filter across all columns (empty clears). */
   setSearch: (term: string) => void;
+  /**
+   * Select one row's cells and scroll it into view, once the table is built.
+   *
+   * @returns False when no row the table shows carries the key (filtered out, or gone).
+   */
+  revealRow: (rowKey: string) => Promise<boolean>;
   destroy: () => void;
 }
 
@@ -89,7 +96,7 @@ function makeHost(className: string): HTMLElement {
   return host;
 }
 
-function sorterForColumn(column: GridColumn): ColumnDefinition["sorter"] {
+function sorterForColumn(column: GridColumn): ColumnDefinition<GridCellValue>["sorter"] {
   switch (column.kind) {
     case "number": {
       return "number";
@@ -98,8 +105,7 @@ function sorterForColumn(column: GridColumn): ColumnDefinition["sorter"] {
       return "boolean";
     }
     case "array": {
-      return (a: unknown, b: unknown) =>
-        cellToText(a as GridCellValue).localeCompare(cellToText(b as GridCellValue));
+      return (a: GridCellValue, b: GridCellValue) => cellToText(a).localeCompare(cellToText(b));
     }
     default: {
       return "string";
@@ -119,9 +125,9 @@ export function createGridView(host: HTMLElement, controller: GridController): G
   let built = false;
   let pendingRefresh = false;
 
-  const rowKeyOf = (row: RowComponent) => String(row.getData()[ROW_KEY_FIELD] ?? "");
+  const rowKeyOf = (row: RowComponent<GridCellValue>) => String(row.getData()[ROW_KEY_FIELD] ?? "");
 
-  const paintRow = (row: RowComponent) => {
+  const paintRow = (row: RowComponent<GridCellValue>) => {
     const rowState = buffer.rowState(rowKeyOf(row));
     const el = row.getElement();
     el.classList.toggle("jx-grid-row--pending-delete", rowState === "pending-delete");
@@ -129,7 +135,7 @@ export function createGridView(host: HTMLElement, controller: GridController): G
     el.classList.toggle("jx-grid-row--stale", rowState === "stale");
   };
 
-  const paintCell = (cell: CellComponent) => {
+  const paintCell = (cell: CellComponent<GridCellValue>) => {
     const cellState = buffer.cellState(rowKeyOf(cell.getRow()), cell.getField());
     const el = cell.getElement();
     el.classList.toggle("jx-grid-cell--dirty", cellState === "dirty");
@@ -147,10 +153,11 @@ export function createGridView(host: HTMLElement, controller: GridController): G
     (column.editable || (column.insertOnly === true && buffer.isInsertKey(rowKey))) &&
     buffer.rowState(rowKey) !== "pending-delete";
 
-  const columnDefs: ColumnDefinition[] = columns.map((column) => {
+  const columnDefs: ColumnDefinition<GridCellValue>[] = columns.map((column) => {
     const baseFormatter = formatterForColumn(column, makeHost);
     return {
-      editable: (cell: CellComponent) => cellEditable(column, rowKeyOf(cell.getRow())),
+      editable: (cell: CellComponent<GridCellValue>) =>
+        cellEditable(column, rowKeyOf(cell.getRow())),
       // Image/reference cells edit through an anchored popover (dblclick), not an editor session.
       editor: hasPopoverEditor(column) ? undefined : editorForColumn(column, makeHost),
       field: column.field,
@@ -215,12 +222,17 @@ export function createGridView(host: HTMLElement, controller: GridController): G
 
   controller.bindView({ refreshData });
 
-  table.on("tableBuilt", () => {
-    built = true;
-    if (pendingRefresh) {
-      pendingRefresh = false;
-      refreshData();
-    }
+  /* Settles once the table is built: a reveal asked for before then waits for it, because the
+     engine has no rows to find, and its default range would replace the one the reveal drew. */
+  const whenBuilt = new Promise<void>((resolve) => {
+    table.on("tableBuilt", () => {
+      built = true;
+      if (pendingRefresh) {
+        pendingRefresh = false;
+        refreshData();
+      }
+      resolve();
+    });
   });
 
   /*
@@ -254,7 +266,7 @@ export function createGridView(host: HTMLElement, controller: GridController): G
   };
   const unregisterProbe = registerGridProbe(probe);
 
-  table.on("cellEdited", (cell: CellComponent) => {
+  table.on("cellEdited", (cell: CellComponent<GridCellValue>) => {
     if (suppress) {
       return;
     }
@@ -267,7 +279,7 @@ export function createGridView(host: HTMLElement, controller: GridController): G
     const value = coerceCellInput(cell.getValue(), column);
     buffer.setCell(rowKey, field, value);
     // Normalize what the table shows to the typed value (e.g. pasted "42" in a number column).
-    if (!cellValuesEqual(value, cell.getValue() as GridCellValue)) {
+    if (!cellValuesEqual(value, cell.getValue())) {
       suppress = true;
       try {
         cell.setValue(value, true);
@@ -287,7 +299,7 @@ export function createGridView(host: HTMLElement, controller: GridController): G
     saveGridLayout(gridId, { order: ordered.map((c) => c.getField()) });
   });
 
-  table.on("cellDblClick", (_event: unknown, cell: CellComponent) => {
+  table.on("cellDblClick", (_event: MouseEvent, cell: CellComponent<GridCellValue>) => {
     const column = columnByField.get(cell.getField());
     const rowKey = rowKeyOf(cell.getRow());
     if (!column || !hasPopoverEditor(column) || !cellEditable(column, rowKey)) {
@@ -383,6 +395,20 @@ export function createGridView(host: HTMLElement, controller: GridController): G
 
     refreshData,
 
+    async revealRow(rowKey: string) {
+      await whenBuilt;
+      const row = table.getRow(rowKey);
+      const cells = row ? row.getCells() : [];
+      const [first] = cells;
+      const last = cells.at(-1);
+      if (!first || !last) {
+        return false;
+      }
+      table.addRange(first, last);
+      await table.scrollToRow(rowKey, "center", false).catch(() => {});
+      return true;
+    },
+
     setSearch(term: string) {
       const query = term.trim().toLowerCase();
       if (query === "") {
@@ -390,12 +416,8 @@ export function createGridView(host: HTMLElement, controller: GridController): G
         return;
       }
       const fields = columns.map((column) => column.field);
-      table.setFilter((data: Record<string, unknown>) =>
-        fields.some((field) =>
-          cellToText(data[field] as GridCellValue)
-            .toLowerCase()
-            .includes(query),
-        ),
+      table.setFilter((data: RowData<GridCellValue>) =>
+        fields.some((field) => cellToText(data[field]).toLowerCase().includes(query)),
       );
     },
   };

package/src/grid/redirects-grid.ts

@@ -41,6 +41,7 @@ import {
   validateRedirects,
 } from "./redirects";
 import { optionalStringArg, stringProperty } from "../commands/command-args";
+import { GRID_STUB_DOCUMENT } from "./grid-source";
 import type { RedirectConfig, RedirectRule, RedirectTarget } from "./redirects";
 import type {
   CommitResult,
@@ -67,8 +68,10 @@ export const REDIRECTS_TAB_ID = "grid://redirects";
 /** Who the Problems list attributes a redirect finding to. Also the key it clears them by. */
 export const REDIRECTS_PROBLEM_SOURCE = "Redirects";
 
-/** Placeholder document for the virtual tab — the grid never reads it; save routes to the source. */
-const GRID_STUB_DOCUMENT = { children: [], tagName: "div" };
+/** The one key a redirect commit patches; `undefined` removes `redirects` from project.json. */
+interface RedirectsPatch {
+  redirects: RedirectConfig | undefined;
+}
 
 /** Extensions the router treats as pages. Anything else under `pages/` is an asset, not a route. */
 const PAGE_EXTENSIONS = [".json", ".md", ".html"];
@@ -120,7 +123,7 @@ export function redirectRow(rule: RedirectRule, index: number): GridRow {
 
 /** The live redirects map, straight off the configuration document. */
 function currentConfig(): RedirectConfig | undefined {
-  return projectState?.projectConfig?.redirects as RedirectConfig | undefined;
+  return projectState?.projectConfig?.redirects;
 }
 
 /**
@@ -133,7 +136,10 @@ function parseTarget(raw: string): RedirectTarget {
     return REWRITE;
   }
   const value = Number(trimmed);
-  return Number.isInteger(value) ? (value as RedirectTarget) : (trimmed as RedirectTarget);
+  /* SAFETY: deliberately unchecked, per the doc above. Every rule built from cells reaches
+     `ruleErrors` in `commit()`, which tests `status` against REDIRECT_TARGETS and refuses the whole
+     batch before `configFromRules` can write an unrecognised target to project.json. */
+  return (Number.isInteger(value) ? value : trimmed) as RedirectTarget;
 }
 
 /** A cell bag back to a rule. An unrecognised target is refused by {@link ruleErrors}. */
@@ -327,9 +333,12 @@ export function createRedirectsSource(): GridSource {
       // `undefined` CLEARS the key (see `commitProjectConfig`): an empty table should leave no
       // `"redirects": {}` behind. The local type spells the undefined out, which
       // `exactOptionalPropertyTypes` will not let `Partial<ProjectConfig>` do.
-      const patch: { redirects: RedirectConfig | undefined } = {
+      const patch: RedirectsPatch = {
         redirects: next.length > 0 ? configFromRules(next) : undefined,
       };
+      /* SAFETY: `commitProjectConfig` spreads the patch onto the document and documents an own
+         `undefined` as "clear this key"; the only other value is a RedirectConfig, which is
+         structurally ProjectConfig["redirects"]. Only the spelling of "absent" differs. */
       const commit = await commitProjectConfig(patch as Partial<ProjectConfig>);
       if (!commit.ok) {
         // `commitProjectConfig` already filed the Problem; repeating it would list one failure

package/src/grid/redirects.ts

@@ -26,6 +26,7 @@
  */
 
 import { REDIRECT_STATUSES } from "@jxsuite/schema/defs";
+import { isString } from "@jxsuite/schema/guards";
 import { parseCsv } from "./csv-codec";
 
 /** One redirect rule, flattened out of `project.json`'s two accepted spellings. */
@@ -128,17 +129,17 @@ export function routePattern(route: string): string {
 /** Flatten `project.json`'s redirects map into rules, in declaration order. */
 export function rulesFromConfig(config: RedirectConfig | undefined): RedirectRule[] {
   return Object.entries(config ?? {}).map(([source, target]) => {
-    if (typeof target === "string") {
+    if (isString(target)) {
       return { destination: target, source, status: DEFAULT_REDIRECT_STATUS };
     }
     if ("rewrite" in target) {
       return { destination: target.destination, source, status: REWRITE };
     }
-    return {
-      destination: target.destination,
-      source,
-      status: (target.status ?? DEFAULT_REDIRECT_STATUS) as RedirectTarget,
-    };
+    /* SAFETY: project.json's schema declares `status` as `enum: [...REDIRECT_STATUSES]`, the same
+       constant RedirectTarget is built from. A hand-edited file that breaks it is still caught:
+       every rule passes the grid's `ruleErrors` status check before anything is written back. */
+    const status = (target.status ?? DEFAULT_REDIRECT_STATUS) as RedirectTarget;
+    return { destination: target.destination, source, status };
   });
 }
 
@@ -151,7 +152,7 @@ export function rulesFromConfig(config: RedirectConfig | undefined): RedirectRul
  * level down. A later duplicate source wins, which is what a JSON object means anyway; the grid
  * refuses duplicates before they get here.
  */
-export function configFromRules(rules: readonly RedirectRule[]): RedirectConfig {
+export function configFromRules(rules: readonly RedirectRule[]) {
   const config: RedirectConfig = {};
   for (const rule of rules) {
     if (rule.status === REWRITE) {
@@ -189,11 +190,14 @@ function ruleFor(rules: readonly RedirectRule[], path: string): RedirectRule | u
   );
 }
 
+/** The path a chain of rules walks, and whether it came back to a source it already visited. */
+interface RedirectWalk {
+  path: string[];
+  looped: boolean;
+}
+
 /** Follow destinations from a rule until they stop resolving. Returns the path walked. */
-function walk(
-  rules: readonly RedirectRule[],
-  start: RedirectRule,
-): { path: string[]; looped: boolean } {
+function walk(rules: readonly RedirectRule[], start: RedirectRule): RedirectWalk {
   const path = [start.source];
   const seen = new Set([normalizePath(start.source)]);
   let current = start;
@@ -309,9 +313,7 @@ function parseStatus(token: string | undefined): RedirectTarget | null {
     return REWRITE;
   }
   const value = Number(raw);
-  return (REDIRECT_STATUSES as readonly number[]).includes(value)
-    ? (value as RedirectTarget)
-    : null;
+  return REDIRECT_STATUSES.find((status) => status === value) ?? null;
 }
 
 /** Netlify/Cloudflare `_redirects`: `source destination [status]`, `#` comments, blank lines. */

package/src/grid/schema-columns.ts

@@ -8,6 +8,14 @@
  * parser extension's `coerceCSVRows` (currency-stripped numbers, `"true"` booleans, comma-split
  * arrays) so grid edits round-trip identically to the runtime content loader.
  */
+import {
+  isBoolean,
+  isJsonObject,
+  isNonNullObject,
+  isNumber,
+  isString,
+} from "@jxsuite/schema/guards";
+import type { ContentTypeSchema, JsonValue } from "@jxsuite/schema/types";
 import type { GridCellValue, GridColumn, GridColumnKind } from "./grid-source";
 import type { JsonSchema } from "../ui/schema-form";
 import { isMediaFormat } from "../utils/studio-utils";
@@ -93,17 +101,17 @@ export interface ColumnsFromSchemaOptions {
  * required properties in declaration order, then the rest in declaration order.
  */
 export function columnsFromSchema(
-  schema: { properties?: Record<string, unknown>; required?: string[] } | null | undefined,
+  schema: ContentTypeSchema | null | undefined,
   opts: ColumnsFromSchemaOptions = {},
 ): GridColumn[] {
-  const props = Object.entries(schema?.properties ?? {}) as [string, PropSchema][];
+  const props: [string, PropSchema][] = Object.entries(schema?.properties ?? {});
   const required = new Set(schema?.required);
   const readonly = new Set(opts.readonlyFields);
 
   const columns = props.map(([field, prop]): GridColumn => {
     const kind = readonly.has(field) ? "readonly" : kindForProp(prop);
     const enumLen = Array.isArray(prop.enum)
-      ? Math.max(...(prop.enum as unknown[]).map((v) => String(v).length), 4)
+      ? Math.max(...prop.enum.map((v) => String(v).length), 4)
       : 0;
     return {
       editable: kind !== "readonly",
@@ -144,9 +152,10 @@ export function inferColumnsFromRows(
   }
 
   return fields.map((field): GridColumn => {
-    const values = sample
-      .map((row) => row[field])
-      .filter((v): v is Exclude<GridCellValue, null> => v !== null && v !== undefined && v !== "");
+    const values = sample.flatMap((row) => {
+      const value = row[field];
+      return value === null || value === undefined || value === "" ? [] : [value];
+    });
     const kind = inferKind(values);
     const maxLen = Math.max(...values.map((v) => cellToText(v).length), field.length, 4);
     return {
@@ -167,14 +176,11 @@ function inferKind(values: Exclude<GridCellValue, null>[]): GridColumnKind {
     return "array";
   }
   const texts = values.map(String);
-  if (
-    values.every((v) => typeof v === "boolean") ||
-    texts.every((t) => /^(true|false)$/i.test(t))
-  ) {
+  if (values.every((v) => isBoolean(v)) || texts.every((t) => /^(true|false)$/i.test(t))) {
     return "boolean";
   }
   if (
-    values.every((v) => typeof v === "number") ||
+    values.every((v) => isNumber(v)) ||
     texts.every((t) => t.trim() !== "" && !Number.isNaN(Number(t.replaceAll(/[$€£¥,\s]/g, ""))))
   ) {
     return "number";
@@ -194,13 +200,13 @@ function inferKind(values: Exclude<GridCellValue, null>[]): GridColumnKind {
  * Coerce editor/clipboard input to the column's typed value. Empty input clears to null. Number and
  * array semantics mirror the parser extension's coerceCSVRows.
  */
-export function coerceCellInput(raw: unknown, col: GridColumn): GridCellValue {
+export function coerceCellInput(raw: JsonValue | undefined, col: GridColumn): GridCellValue {
   if (raw === null || raw === undefined) {
     return null;
   }
   switch (col.kind) {
     case "number": {
-      if (typeof raw === "number") {
+      if (isNumber(raw)) {
         return Number.isNaN(raw) ? null : raw;
       }
       const cleaned = String(raw)
@@ -213,7 +219,7 @@ export function coerceCellInput(raw: unknown, col: GridColumn): GridCellValue {
       return Number.isNaN(n) ? null : n;
     }
     case "boolean": {
-      if (typeof raw === "boolean") {
+      if (isBoolean(raw)) {
         return raw;
       }
       return String(raw).trim().toLowerCase() === "true";
@@ -233,9 +239,9 @@ export function coerceCellInput(raw: unknown, col: GridColumn): GridCellValue {
     case "reference": {
       // Relationship VALUES are plain target-entry ids ("jane-doe") — the $ref lives on the
       // Schema property, not in the data (specs/relationships.md; parser resolveContentTypeRefs).
-      if (typeof raw === "object" && raw !== null && "$ref" in raw) {
-        const ref = (raw as { $ref: unknown }).$ref;
-        return typeof ref === "string" && ref !== "" ? ref : null;
+      if (isJsonObject(raw) && "$ref" in raw) {
+        const ref = raw.$ref;
+        return isString(ref) && ref !== "" ? ref : null;
       }
       const text = String(raw).trim();
       return text === "" ? null : text;
@@ -248,14 +254,14 @@ export function coerceCellInput(raw: unknown, col: GridColumn): GridCellValue {
 }
 
 /** Plain-text projection of a cell value — display, clipboard, and CSV share it. */
-export function cellToText(value: GridCellValue): string {
+export function cellToText(value: GridCellValue | undefined): string {
   if (value === null || value === undefined) {
     return "";
   }
   if (Array.isArray(value)) {
     return value.join(", ");
   }
-  if (typeof value === "object") {
+  if (isNonNullObject(value)) {
     return value.$ref;
   }
   return String(value);