@jxsuite/studio 6.1.1 → 8.0.0

package/src/github/github-auth.ts

@@ -15,8 +15,8 @@
  * **This flow fails, and until now it failed silently.** `https://github.com/login/device/code`
  * sends no `Access-Control-Allow-Origin`, so a browser cannot call it: in Studio-in-a-browser the
  * very first request rejects with a bare `TypeError`. That rejection used to become a thrown
- * `Error` out of {@link authenticateGithub}, into `void createGithubRepository(…)` in
- * `panels/git-panel.ts`, and from there into an unhandled promise rejection — the user clicked
+ * `Error` out of {@link authenticateGithub}, into `void createGithubRepository(…)` in the Source
+ * Control panel of the time, and from there into an unhandled promise rejection — the user clicked
  * "Create GitHub repository" and the app did nothing at all, forever, with no message anywhere.
  *
  * Three failures now reach a surface, each as the kind of record §16 says it is:
@@ -59,8 +59,14 @@ import { errorMessage } from "@jxsuite/schema/parse";
 import { notify } from "../services/notify";
 import { layerHost } from "../ui/layers";
 import { openGithubAuthSurface } from "../surfaces/github-auth";
-import type { GithubAuthSurfaceHandle } from "../surfaces/github-auth";
-import { getGithubToken, nativeAuth, setNativeToken, STORAGE_KEY } from "./github-auth-status";
+import {
+  getGithubToken,
+  GITHUB_OAUTH_CLIENT_ID,
+  nativeAuth,
+  setNativeToken,
+  STORAGE_KEY,
+} from "./github-auth-status";
+import type { DialogLayerHandle } from "../ui/surface";
 
 // Every other caller in Studio still reaches these through this module.
 export {
@@ -71,8 +77,6 @@ export {
   hydrateGithubToken,
 } from "./github-auth-status";
 
-const CLIENT_ID = "Ov23liYVlMFpgjOEPXJH";
-
 /** One key for the whole sign-in, so a second attempt REPLACES the first report. */
 const NOTIFY_KEY = "github.auth";
 
@@ -108,10 +112,10 @@ interface TokenResponse {
 }
 
 /** The request never completed — a Problem, with the one sentence that covers both causes. */
-function reportUnreachable(error: unknown): void {
+function reportUnreachable(cause: unknown): void {
   notify.error("Could not reach GitHub to sign in.", {
     action: RETRY,
-    detail: `${UNREACHABLE_DETAIL}\n\n${errorMessage(error)}`,
+    detail: `${UNREACHABLE_DETAIL}\n\n${errorMessage(cause)}`,
     key: NOTIFY_KEY,
     source: SOURCE,
   });
@@ -132,7 +136,7 @@ async function requestDeviceCode(): Promise<DeviceCodeResponse | null> {
   let codeRes: Response;
   try {
     codeRes = await fetch("https://github.com/login/device/code", {
-      body: JSON.stringify({ client_id: CLIENT_ID, scope: "repo" }),
+      body: JSON.stringify({ client_id: GITHUB_OAUTH_CLIENT_ID, scope: "repo" }),
       headers: {
         Accept: "application/json",
         "Content-Type": "application/json",
@@ -151,6 +155,9 @@ async function requestDeviceCode(): Promise<DeviceCodeResponse | null> {
     );
     return null;
   }
+  /* SAFETY: a 2xx from GitHub's device-code endpoint (checked just above) is the JSON object
+     RFC 8628 §3.2 defines — `device_code`, `user_code`, `verification_uri` and an optional
+     `interval` — which is exactly what `DeviceCodeResponse` declares. */
   return (await codeRes.json()) as DeviceCodeResponse;
 }
 
@@ -247,7 +254,7 @@ export async function authenticateGithub() {
       try {
         const tokenRes = await fetch("https://github.com/login/oauth/access_token", {
           body: JSON.stringify({
-            client_id: CLIENT_ID,
+            client_id: GITHUB_OAUTH_CLIENT_ID,
             device_code,
             grant_type: "urn:ietf:params:oauth:grant-type:device_code",
           }),
@@ -257,6 +264,9 @@ export async function authenticateGithub() {
           },
           method: "POST",
         });
+        /* SAFETY: GitHub's token endpoint answers every poll with a JSON object carrying either an
+           `access_token` (RFC 6749 §5.1) or an `error` code (RFC 8628 §3.5); `TokenResponse` makes
+           Both optional, and every branch below reads them as possibly absent. */
         const tokenData = (await tokenRes.json()) as TokenResponse;
         failures = 0;
 
@@ -303,7 +313,7 @@ export async function authenticateGithub() {
      * the surface existed would find a binding that is not initialised yet — which a zero-second
      * device interval makes reachable rather than theoretical.
      */
-    const handle: GithubAuthSurfaceHandle = openGithubAuthSurface({
+    const handle: DialogLayerHandle = openGithubAuthSurface({
       layer: layerHost("dialog"),
       onCancel: () => {
         takeDown();

package/src/github/github-publish.ts

@@ -31,7 +31,8 @@ import { authenticateGithub } from "./github-auth";
 import { beginActivity } from "../panels/activity-panel";
 import { getPlatform } from "../platform";
 import { notify } from "../services/notify";
-import type { GithubPublishSurfaceHandle, RepoOptions } from "../surfaces/github-publish";
+import type { RepoOptions } from "../surfaces/github-publish";
+import type { DialogLayerHandle } from "../ui/surface";
 
 interface GithubErrorResponse {
   errors?: { message?: string }[];
@@ -77,7 +78,7 @@ function askForRepoOptions(projectName: string): Promise<RepoOptions | null> {
       answered = true;
       resolve(value);
     };
-    const handle: GithubPublishSurfaceHandle = openGithubPublishSurface({
+    const handle: DialogLayerHandle = openGithubPublishSurface({
       layer: layerHost("dialog"),
       name: projectName,
       onCancel: () => {
@@ -125,25 +126,24 @@ export async function createGithubRepository({ projectName }: { projectName: str
   });
 
   activity.step(REPO_STEPS[0]);
-  const createRes = await fetch("https://api.github.com/user/repos", {
-    body: JSON.stringify({
-      auto_init: false,
-      description: repoOpts.description,
-      name: repoOpts.name,
-      private: repoOpts.isPrivate,
-    }),
-    headers: {
-      Accept: "application/vnd.github+json",
-      Authorization: `Bearer ${token}`,
-      "Content-Type": "application/json",
-    },
-    method: "POST",
-  }).catch((error: unknown) => {
+  let createRes: Response;
+  try {
+    createRes = await fetch("https://api.github.com/user/repos", {
+      body: JSON.stringify({
+        auto_init: false,
+        description: repoOpts.description,
+        name: repoOpts.name,
+        private: repoOpts.isPrivate,
+      }),
+      headers: {
+        Accept: "application/vnd.github+json",
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json",
+      },
+      method: "POST",
+    });
+  } catch (error) {
     activity.log(errorMessage(error));
-    return null;
-  });
-
-  if (!createRes) {
     activity.fail("Could not reach GitHub to create the repository.", {
       action: "git.createGithubRepository",
     });
@@ -151,6 +151,8 @@ export async function createGithubRepository({ projectName }: { projectName: str
   }
 
   if (!createRes.ok) {
+    /* SAFETY: GitHub's REST API answers a failed request with a JSON body carrying `message` and,
+       For a validation failure, an `errors` array; both are optional here and read with fallbacks. */
     const err = (await createRes.json()) as GithubErrorResponse;
     activity.log(err.errors?.[0]?.message || err.message || `GitHub answered ${createRes.status}.`);
     activity.fail("Could not create the GitHub repository.", {
@@ -159,6 +161,8 @@ export async function createGithubRepository({ projectName }: { projectName: str
     return false;
   }
 
+  /* SAFETY: `createRes.ok` was checked above, and a successful `POST /user/repos` answers with the
+     Full repository object, of which `clone_url` and `html_url` are required members. */
   const repo = (await createRes.json()) as GithubRepoResponse;
   activity.log(`Created ${repo.html_url}`);
   const platform = getPlatform();
@@ -171,7 +175,8 @@ export async function createGithubRepository({ projectName }: { projectName: str
     // Surfaced as a push failure describing the push.
     activity.log(errorMessage(error));
     activity.fail("The repository was created, but the remote could not be added.", {
-      action: "panel.focus.git",
+      action: "view.setWorkspace",
+      actionArgs: { workspace: "publish" },
     });
     return false;
   }
@@ -187,8 +192,8 @@ export async function createGithubRepository({ projectName }: { projectName: str
     return false;
   }
 
-  // Lazy import breaks the github-publish ↔ git-panel module cycle
-  const { refreshGitStatus } = await import("../panels/git-panel");
+  // Lazy import breaks the github-publish ↔ source-control module cycle
+  const { refreshGitStatus } = await import("../publish/source-control");
   await refreshGitStatus();
   activity.done(repo.html_url);
   notify.success(`Repository created: ${repo.html_url}`, { key: "github.repo" });

package/src/grid/cell-editors.ts

@@ -58,15 +58,18 @@ import { live } from "lit-html/directives/live.js";
 import { cellToText, coerceCellInput } from "./schema-columns";
 import type { GridCellValue, GridColumn } from "./grid-source";
 
-/** The subset of Tabulator's CellComponent the editors/formatters touch. */
+/**
+ * The subset of Tabulator's CellComponent the editors/formatters touch. A cell's value is a
+ * {@link GridCellValue}: the grid's row data is the grid source's rows, which hold nothing else.
+ */
 export interface CellLike {
-  getValue: () => unknown;
+  getValue: () => GridCellValue;
 }
 
 export type CellEditorFn = (
   cell: CellLike,
   onRendered: (fn: () => void) => void,
-  success: (value: unknown) => void,
+  success: (value: GridCellValue) => void,
   cancel: () => void,
 ) => HTMLElement;
 
@@ -75,6 +78,17 @@ export type CellFormatterFn = (cell: CellLike) => HTMLElement;
 /** Detached-host factory — grid-view owns the one sanctioned document.createElement. */
 export type HostFactory = (className: string) => HTMLElement;
 
+/**
+ * The `<input>` a listener in this file is bound on.
+ *
+ * Every input listener here sits on the `<input>` its own template renders, and an input has no
+ * children, so a keydown, change or blur it hears was dispatched at the input itself.
+ */
+function inputOf(e: Event): HTMLInputElement {
+  // SAFETY: the listener is bound on an `<input>` (above), and a void element is its events' target.
+  return e.target as HTMLInputElement;
+}
+
 /** Commit/cancel wiring shared by every text-ish editor. */
 function inputEditor(makeHost: HostFactory, column: GridColumn, inputType: string): CellEditorFn {
   return (cell, onRendered, success, cancel) => {
@@ -94,8 +108,8 @@ function inputEditor(makeHost: HostFactory, column: GridColumn, inputType: strin
     };
     const initial =
       column.kind === "date"
-        ? cellToText(cell.getValue() as GridCellValue).slice(0, 10)
-        : cellToText(cell.getValue() as GridCellValue);
+        ? cellToText(cell.getValue()).slice(0, 10)
+        : cellToText(cell.getValue());
     render(
       html`<input
         class="jx-grid-input"
@@ -103,12 +117,12 @@ function inputEditor(makeHost: HostFactory, column: GridColumn, inputType: strin
         .value=${live(initial)}
         @keydown=${(e: KeyboardEvent) => {
           if (e.key === "Enter") {
-            commit((e.target as HTMLInputElement).value);
+            commit(inputOf(e).value);
           } else if (e.key === "Escape") {
             abort();
           }
         }}
-        @blur=${(e: Event) => commit((e.target as HTMLInputElement).value)}
+        @blur=${(e: Event) => commit(inputOf(e).value)}
       />`,
       host,
     );
@@ -133,7 +147,7 @@ function checkboxEditor(makeHost: HostFactory): CellEditorFn {
         @change=${(e: Event) => {
           if (!done) {
             done = true;
-            success((e.target as HTMLInputElement).checked);
+            success(inputOf(e).checked);
           }
         }}
         @keydown=${(e: KeyboardEvent) => {
@@ -142,13 +156,13 @@ function checkboxEditor(makeHost: HostFactory): CellEditorFn {
             cancel();
           } else if (e.key === "Enter" && !done) {
             done = true;
-            success((e.target as HTMLInputElement).checked);
+            success(inputOf(e).checked);
           }
         }}
         @blur=${(e: Event) => {
           if (!done) {
             done = true;
-            success((e.target as HTMLInputElement).checked);
+            success(inputOf(e).checked);
           }
         }}
       />`,
@@ -160,19 +174,19 @@ function checkboxEditor(makeHost: HostFactory): CellEditorFn {
 }
 
 function selectEditor(makeHost: HostFactory, column: GridColumn): CellEditorFn {
-  const options = Array.isArray(column.schema?.enum)
-    ? (column.schema.enum as unknown[]).map(String)
-    : [];
+  const options = Array.isArray(column.schema?.enum) ? column.schema.enum.map(String) : [];
   return (cell, onRendered, success, cancel) => {
     const host = makeHost("jx-grid-editor");
     let done = false;
-    const current = cellToText(cell.getValue() as GridCellValue);
+    const current = cellToText(cell.getValue());
     render(
       html`<select
         class="jx-grid-select"
         @change=${(e: Event) => {
           if (!done) {
             done = true;
+            // SAFETY: this listener is bound on the `<select>` rendered here, and `change` is
+            // Dispatched at the select itself, never at one of its options.
             const { value } = e.target as HTMLSelectElement;
             success(value === "" ? null : value);
           }
@@ -235,26 +249,27 @@ function pillEditor(makeHost: HostFactory, column: GridColumn): CellEditorFn {
       render(
         html`<span class="jx-grid-pills">
           ${chips.map(
-            (chip, i) => html`<span class="jx-grid-chip"
-              >${chip}<button
-                class="jx-grid-chip-x"
-                title="Remove"
-                @mousedown=${(e: Event) => e.preventDefault()}
-                @click=${() => {
-                  chips.splice(i, 1);
-                  doRender();
-                  inputEl()?.focus();
-                }}
-              >
-                ×
-              </button></span
-            >`,
+            (chip, i) =>
+              html`<span class="jx-grid-chip"
+                >${chip}<button
+                  class="jx-grid-chip-x"
+                  title="Remove"
+                  @mousedown=${(e: Event) => e.preventDefault()}
+                  @click=${() => {
+                    chips.splice(i, 1);
+                    doRender();
+                    inputEl()?.focus();
+                  }}
+                >
+                  ×
+                </button></span
+              >`,
           )}
           <input
             class="jx-grid-pill-input"
             placeholder=${chips.length === 0 ? "add…" : ""}
             @keydown=${(e: KeyboardEvent) => {
-              const input = e.target as HTMLInputElement;
+              const input = inputOf(e);
               if (e.key === "Enter" || e.key === ",") {
                 e.preventDefault();
                 if (addFromInput(input)) {
@@ -272,7 +287,7 @@ function pillEditor(makeHost: HostFactory, column: GridColumn): CellEditorFn {
               }
             }}
             @blur=${(e: Event) => {
-              addFromInput(e.target as HTMLInputElement);
+              addFromInput(inputOf(e));
               finish([...chips]);
             }}
           />
@@ -317,7 +332,7 @@ export function editorForColumn(
 /** Formatter factory — plain-text projection rendered as a real element (innerHTML-safe). */
 export function formatterForColumn(column: GridColumn, makeHost: HostFactory): CellFormatterFn {
   return (cell) => {
-    const value = cell.getValue() as GridCellValue;
+    const value = cell.getValue();
     const host = makeHost(`jx-grid-cell-content jx-grid-kind-${column.kind}`);
     if (column.kind === "boolean") {
       render(html`${value === true ? "✓" : ""}`, host);

package/src/grid/cell-popovers.ts

@@ -12,6 +12,7 @@
  * through the panel's island seam (specs/studio-ui-guidelines.md §9.4) — the box is drawn by one
  * document and filled by another, and nothing in this file renders anything.
  */
+import { isString } from "@jxsuite/schema/guards";
 import { openGridCellSurface } from "../surfaces/grid-cell";
 import { mountMediaPicker } from "../ui/media-picker";
 import { listCollectionEntryIds } from "./sources/content-source";
@@ -25,8 +26,9 @@ export function hasPopoverEditor(column: GridColumn): boolean {
 
 /** Target content-type name of a relationship column (`#/content/<name>` on the schema). */
 export function referenceTargetType(column: GridColumn): string | null {
-  const ref = (column.schema as { $ref?: string } | undefined)?.$ref;
-  if (typeof ref !== "string" || !ref.startsWith("#/content/")) {
+  // The schema is the project's own JSON, so `$ref` is checked rather than trusted to be a string.
+  const ref = column.schema?.$ref;
+  if (!isString(ref) || !ref.startsWith("#/content/")) {
     return null;
   }
   return ref.slice("#/content/".length);
@@ -47,7 +49,7 @@ export interface CellPopoverArgs {
  * The clamp is the panel's own width and a floor for its height, because a cell near the right edge
  * of a wide grid is exactly where a relationship column tends to be.
  */
-function placement(anchor: CellPopoverArgs["anchor"]): { x: number; y: number } {
+function placement(anchor: CellPopoverArgs["anchor"]) {
   return {
     x: Math.max(4, Math.min(anchor.left, window.innerWidth - 340)),
     y: Math.max(4, Math.min(anchor.bottom + 2, window.innerHeight - 200)),

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[]) => {
@@ -142,9 +144,13 @@ export function createGridController(tab: Tab, source: GridSource): GridControll
 
   const reloadRows = async () => {
     const result = await source.rows(state.query);
+    /* Index BEFORE the rows are published. The index is not reactive, and assigning `state.rows`
+       runs the effects that read it at once: a record's entry form (`content/record-entry.ts`)
+       resolves its row key from the new rows and reads that row's cells through the baseline,
+       which with the index still empty drew every field blank until something else re-ran it. */
+    indexRows(result.rows);
     state.rows = result.rows;
     state.total = result.total;
-    indexRows(result.rows);
   };
 
   /** Missing required cells block the save (marked as row/cell errors, like a failed commit). */
@@ -181,7 +187,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 +286,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 +302,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 +549,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,17 +19,13 @@ import {
   createPagesSource,
 } from "./sources/content-source";
 import { createConnectorSource } from "./sources/connector-source";
-import { makeGridTabId, parseGridTabId } from "./grid-source";
-import { libraryTabId } from "../browse/library-source";
+import { GRID_STUB_DOCUMENT, makeGridTabId, parseGridTabId } from "./grid-source";
 import { argsSchema, optionalStringArg, stringArg, stringProperty } from "../commands/command-args";
 import type { GridSource } from "./grid-source";
 import type { GridOpenSurfaceHandle, GridSourceGroup } from "../surfaces/grid-open";
 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.
  *
@@ -102,32 +98,6 @@ export function openCollectionGrid(typeName: string): Tab {
   return openVirtualGridTab(createCollectionSource(typeName));
 }
 
-/**
- * Open (or activate) the Library.
- *
- * A real tab, in the primary pane, with `manage` as its only mode — `commands/context.ts` maps that
- * to the `library` editor kind, so the status bar and the pane context bar can name what is on
- * screen. It is opened here rather than in `browse/` because this is the module that knows how a
- * virtual tab is made; the pane itself resolves its own source and its own view state.
- *
- * Idempotent by construction, which is what lets a shot say "the Library is open" without caring
- * whether an earlier step opened it.
- */
-export function openLibraryTab(): Tab {
-  const id = libraryTabId();
-  const existing = workspace.tabs.get(id);
-  if (existing) {
-    activateTab(id);
-    return existing;
-  }
-  return openTab({
-    capabilities: { modes: ["manage"] },
-    document: structuredClone(GRID_STUB_DOCUMENT),
-    documentPath: null,
-    id,
-  });
-}
-
 /** Open (or activate) the pages metadata grid. */
 export function openPagesGrid(): Tab {
   const id = makeGridTabId({ kind: "pages" });
@@ -187,14 +157,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}`,
     })),
   ];