@jxsuite/studio 6.1.1 → 6.1.2

package/src/grid/edit-buffer.ts

@@ -92,15 +92,16 @@ export function createEditBuffer(opts: EditBufferOptions): EditBuffer {
   const coalesceMs = opts.coalesceMs ?? 800;
   const now = opts.now ?? (() => Date.now());
 
-  const state: EditBufferState = reactive({
-    deletes: new Set<string>(),
-    errors: new Map<string, Map<string, string>>(),
-    inserts: new Map<string, Record<string, GridCellValue>>(),
-    pending: new Map<string, Map<string, { value: GridCellValue }>>(),
-    redoStack: [] as BufferOp[],
-    stale: new Set<string>(),
-    undoStack: [] as BufferOp[],
-  }) as EditBufferState;
+  const initial: EditBufferState = {
+    deletes: new Set(),
+    errors: new Map(),
+    inserts: new Map(),
+    pending: new Map(),
+    redoStack: [],
+    stale: new Set(),
+    undoStack: [],
+  };
+  const state: EditBufferState = reactive(initial);
 
   let groupOps: BufferOp[] | null = null;
 

package/src/grid/grid-controller.ts

@@ -19,6 +19,7 @@ import { isRecentLocal } from "../files/fs-events";
 import { showConfirmDialog } from "../ui/layers";
 import { showProgressModal } from "../ui/progress-modal";
 import { errorMessage } from "@jxsuite/schema/parse";
+import { isNonNullObject, isNumber, isString } from "@jxsuite/schema/guards";
 import { createEditBuffer } from "./edit-buffer";
 import { cellToText } from "./schema-columns";
 import type { EditBuffer } from "./edit-buffer";
@@ -111,25 +112,26 @@ export interface GridController {
 /** Row-object key carrying the grid row identity through the engine. */
 export const ROW_KEY_FIELD = "__key";
 
-const _controllers = new WeakMap<object, GridController>();
+const _controllers = new WeakMap<Tab, GridController>();
 
 /** The grid controller for a tab, if it is a grid tab. */
 export function getGridController(tab: Tab | null): GridController | null {
-  return tab ? (_controllers.get(toRaw(tab as unknown as object)) ?? null) : null;
+  return tab ? (_controllers.get(toRaw(tab)) ?? null) : null;
 }
 
 /** Create and register the controller for a grid tab. One per tab; lives in the tab's scope. */
 export function createGridController(tab: Tab, source: GridSource): GridController {
-  const state: GridControllerState = reactive({
-    columns: [] as GridColumn[],
-    error: null as string | null,
-    grouping: null as string | null,
+  const initial: GridControllerState = {
+    columns: [],
+    error: null,
+    grouping: null,
     loading: false,
-    query: {} as GridQuery,
-    rows: [] as GridRow[],
+    query: {},
+    rows: [],
     saving: false,
     total: 0,
-  }) as GridControllerState;
+  };
+  const state: GridControllerState = reactive(initial);
 
   let rowByKey = new Map<string, GridRow>();
   const indexRows = (rows: GridRow[]) => {
@@ -181,7 +183,7 @@ export function createGridController(tab: Tab, source: GridSource): GridControll
 
   const compareCells = (a: GridCellValue, b: GridCellValue, kind: GridColumnKind | undefined) => {
     if (kind === "number") {
-      return (typeof a === "number" ? a : 0) - (typeof b === "number" ? b : 0);
+      return (isNumber(a) ? a : 0) - (isNumber(b) ? b : 0);
     }
     if (kind === "boolean") {
       return (a === true ? 1 : 0) - (b === true ? 1 : 0);
@@ -280,7 +282,7 @@ export function createGridController(tab: Tab, source: GridSource): GridControll
           }
           for (const column of textColumns) {
             const value = buffer.effectiveValue(rowKey, column.field);
-            if (typeof value === "string" && value.includes(find)) {
+            if (isString(value) && value.includes(find)) {
               buffer.setCell(rowKey, column.field, value.replaceAll(find, replace));
               changed += 1;
             }
@@ -296,17 +298,13 @@ export function createGridController(tab: Tab, source: GridSource): GridControll
     effectiveRows() {
       // Detach values from reactive proxies — the grid engine must never hold live proxies.
       const plain = (value: GridCellValue): GridCellValue =>
-        Array.isArray(value)
-          ? [...value]
-          : value !== null && typeof value === "object"
-            ? { $ref: value.$ref }
-            : value;
-      const rowObject = (key: string) => {
-        const cells: Record<string, GridCellValue> = { [ROW_KEY_FIELD]: key };
+        Array.isArray(value) ? [...value] : isNonNullObject(value) ? { $ref: value.$ref } : value;
+      const rowObject = (key: string): Record<string, GridCellValue> => {
+        const cells: [field: string, value: GridCellValue][] = [[ROW_KEY_FIELD, key]];
         for (const column of state.columns) {
-          cells[column.field] = plain(buffer.effectiveValue(key, column.field));
+          cells.push([column.field, plain(buffer.effectiveValue(key, column.field))]);
         }
-        return cells;
+        return Object.fromEntries(cells);
       };
       const rows = orderedKeys().map((key) => rowObject(key));
       for (const [tempKey] of buffer.state.inserts) {
@@ -547,11 +545,11 @@ export function createGridController(tab: Tab, source: GridSource): GridControll
 
     onScopeDispose(() => {
       setHistoryDelegate(tab, null);
-      _controllers.delete(toRaw(tab as unknown as object));
+      _controllers.delete(toRaw(tab));
       source.dispose?.();
     });
   });
 
-  _controllers.set(toRaw(tab as unknown as object), controller);
+  _controllers.set(toRaw(tab), controller);
   return controller;
 }

package/src/grid/grid-layout.ts

@@ -23,6 +23,7 @@
  * layout keep their relative position at the end; saved fields that no longer exist are ignored —
  * schemas drift).
  */
+import { isNonNullObject, isString } from "@jxsuite/schema/guards";
 
 /** One sort, as a saved view records it. The grid is single-key sorted; a second key is not saved. */
 export interface GridSortSpec {
@@ -70,7 +71,7 @@ const STORAGE_PREFIX = "jx-grid-layout:";
 
 function storage(): Storage | null {
   try {
-    return globalThis.localStorage ?? null;
+    return typeof localStorage === "undefined" ? null : localStorage;
   } catch {
     return null; // Storage disabled (privacy mode) — layouts just don't persist.
   }
@@ -83,8 +84,11 @@ function readRecord(gridId: string): GridLayoutRecord | null {
     return null;
   }
   try {
-    const parsed = JSON.parse(raw) as GridLayoutRecord;
-    return typeof parsed === "object" && parsed !== null ? parsed : null;
+    const parsed: unknown = JSON.parse(raw);
+    /* SAFETY: this key is written only by `writeRecord`, which stores a serialized
+       GridLayoutRecord, and every reader treats each field as possibly absent (`?.`, `??`, and
+       `listSavedViews` drops any entry that is not a named view). A non-object is refused here. */
+    return isNonNullObject(parsed) ? (parsed as GridLayoutRecord) : null;
   } catch {
     return null;
   }
@@ -153,7 +157,11 @@ export function resetGridLayout(gridId: string): void {
   if (!record) {
     return;
   }
-  writeRecord(gridId, { active: null, ...(record.views ? { views: record.views } : {}) });
+  const next: GridLayoutRecord = { active: null };
+  if (record.views) {
+    next.views = record.views;
+  }
+  writeRecord(gridId, next);
 }
 
 // ─── Named views ──────────────────────────────────────────────────────────────
@@ -161,7 +169,15 @@ export function resetGridLayout(gridId: string): void {
 /** The named views for a grid id, in save order. */
 export function listSavedViews(gridId: string): SavedGridView[] {
   const views = readRecord(gridId)?.views;
-  return Array.isArray(views) ? views.filter((view) => typeof view?.name === "string") : [];
+  return Array.isArray(views) ? views.filter((view) => isSavedGridView(view)) : [];
+}
+
+/**
+ * Whether a stored `views` entry is a named view. Storage outlives the code that wrote it, so an
+ * entry without a string `name` (null, a primitive, an older shape) is skipped rather than shown.
+ */
+function isSavedGridView(view: unknown): view is SavedGridView {
+  return isNonNullObject(view) && "name" in view && isString(view.name);
 }
 
 /** The name of the view last applied to this grid, or null when the layout is unnamed. */

package/src/grid/grid-open.ts

@@ -19,7 +19,7 @@ import {
   createPagesSource,
 } from "./sources/content-source";
 import { createConnectorSource } from "./sources/connector-source";
-import { makeGridTabId, parseGridTabId } from "./grid-source";
+import { GRID_STUB_DOCUMENT, makeGridTabId, parseGridTabId } from "./grid-source";
 import { libraryTabId } from "../browse/library-source";
 import { argsSchema, optionalStringArg, stringArg, stringProperty } from "../commands/command-args";
 import type { GridSource } from "./grid-source";
@@ -27,9 +27,6 @@ import type { GridOpenSurfaceHandle, GridSourceGroup } from "../surfaces/grid-op
 import type { Tab } from "../tabs/tab";
 import type { AnyCommand, CommandRegistry } from "../commands/registry";
 
-/** Placeholder document for grid tabs — the grid never reads it; save routes to the controller. */
-const GRID_STUB_DOCUMENT = { children: [], tagName: "div" };
-
 /**
  * Open (or activate) a `.csv` file as a grid tab.
  *
@@ -187,14 +184,14 @@ function sourceGroups(
       state: "listed",
       title: "Project",
     },
-    ...connections.map((conn) => ({
+    ...connections.map((conn): GridSourceGroup => ({
       emptyMessage: "No tables — push a schema first.",
       key: `data:${conn.name}`,
       rows: conn.tables.map((table) => ({
         id: makeGridTabId({ connection: conn.name, kind: "data", table }),
         label: table,
       })),
-      state: (conn.tables.length === 0 ? "empty" : "listed") as "empty" | "listed",
+      state: conn.tables.length === 0 ? "empty" : "listed",
       title: `Data · ${conn.name}`,
     })),
   ];

package/src/grid/grid-panel.ts

@@ -56,6 +56,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 +70,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 +86,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.
    *
@@ -692,6 +693,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 +710,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-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;
@@ -143,6 +137,12 @@ export function cellValuesEqual(a: GridCellValue, b: GridCellValue): boolean {
 
 const GRID_SCHEME = "grid://";
 
+/**
+ * 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 tab id can name.
  *

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";
@@ -89,7 +90,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 +99,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 +119,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 +129,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 +147,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,
@@ -254,7 +255,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 +268,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 +288,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)) {
@@ -390,12 +391,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);