@jxsuite/studio 6.1.1 → 8.0.0

package/src/grid/sources/connector-source.ts

@@ -9,9 +9,17 @@
  * deletion. The server is authoritative — there are no file fingerprints; conflicts surface as
  * per-row API errors.
  */
+import { isJsonPrimitive, isNumber, isString } from "@jxsuite/schema/guards";
+import type { JsonObject, JsonValue } from "@jxsuite/schema/types";
 import { deleteRow, fetchRows, insertRow, updateRow } from "../../services/data-service";
 import { makeGridTabId } from "../grid-source";
-import type { DataColumnMeta, DataRowsQuery } from "../../types";
+import type {
+  DataColumnMeta,
+  DataRowDelete,
+  DataRowInsert,
+  DataRowUpdate,
+  DataRowsQuery,
+} from "../../types";
 import type {
   CommitResult,
   GridCellValue,
@@ -48,11 +56,11 @@ function editableColumn(column: DataColumnMeta): boolean {
 }
 
 /** DB value → grid cell value (JSON-ish values surface as text). */
-function toCellValue(value: unknown): GridCellValue {
-  if (value === null || value === undefined) {
+function toCellValue(value: JsonValue | undefined): GridCellValue {
+  if (value === undefined) {
     return null;
   }
-  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+  if (isJsonPrimitive(value)) {
     return value;
   }
   return JSON.stringify(value);
@@ -72,17 +80,23 @@ export function createConnectorSource(connection: string | undefined, table: str
     }
   };
 
-  const toQuery = (query?: GridQuery): DataRowsQuery => ({
-    table,
-    ...(connection ? { connection } : {}),
-    limit: query?.limit ?? DATA_PAGE_SIZE,
-    offset: query?.offset ?? 0,
-    ...(query?.orderBy ? { dir: query.dir ?? "asc", orderBy: query.orderBy } : {}),
-  });
+  const toQuery = (query?: GridQuery): DataRowsQuery => {
+    const rowsQuery: DataRowsQuery = { table };
+    if (connection) {
+      rowsQuery.connection = connection;
+    }
+    rowsQuery.limit = query?.limit ?? DATA_PAGE_SIZE;
+    rowsQuery.offset = query?.offset ?? 0;
+    if (query?.orderBy) {
+      rowsQuery.dir = query.dir ?? "asc";
+      rowsQuery.orderBy = query.orderBy;
+    }
+    return rowsQuery;
+  };
 
-  const rowKeyOf = (row: Record<string, unknown>, index: number): string => {
+  const rowKeyOf = (row: JsonObject, index: number): string => {
     const pk = row[pkName];
-    if (typeof pk === "string" || typeof pk === "number") {
+    if (isString(pk) || isNumber(pk)) {
       pkValues.set(String(pk), pk);
       return String(pk);
     }
@@ -132,11 +146,15 @@ export function createConnectorSource(connection: string | undefined, table: str
           continue;
         }
         try {
-          const set: Record<string, unknown> = {};
+          const set: JsonObject = {};
           for (const patch of patches) {
             set[patch.field] = patch.value;
           }
-          await updateRow({ pk, set, table, ...(connection ? { connection } : {}) });
+          const update: DataRowUpdate = { pk, set, table };
+          if (connection) {
+            update.connection = connection;
+          }
+          await updateRow(update);
           outcome(true);
         } catch (error) {
           outcome(false, error instanceof Error ? error.message : String(error));
@@ -145,16 +163,21 @@ export function createConnectorSource(connection: string | undefined, table: str
 
       for (const insert of batch.inserts) {
         try {
-          const values: Record<string, unknown> = {};
+          const values: JsonObject = {};
           for (const [field, value] of Object.entries(insert.cells)) {
             if (value !== null) {
               values[field] = value;
             }
           }
-          const { row } = await insertRow({ table, values, ...(connection ? { connection } : {}) });
+          const request: DataRowInsert = { table, values };
+          if (connection) {
+            request.connection = connection;
+          }
+          const { row } = await insertRow(request);
           const pk = row[pkName];
-          const newKey = typeof pk === "string" || typeof pk === "number" ? String(pk) : undefined;
-          if (newKey !== undefined && (typeof pk === "string" || typeof pk === "number")) {
+          let newKey: string | undefined;
+          if (isString(pk) || isNumber(pk)) {
+            newKey = String(pk);
             pkValues.set(newKey, pk);
           }
           result.inserts.push({ newKey, ok: true, tempKey: insert.tempKey });
@@ -178,7 +201,11 @@ export function createConnectorSource(connection: string | undefined, table: str
           continue;
         }
         try {
-          await deleteRow({ pk, table, ...(connection ? { connection } : {}) });
+          const request: DataRowDelete = { pk, table };
+          if (connection) {
+            request.connection = connection;
+          }
+          await deleteRow(request);
           result.deletes.push({ ok: true, rowKey: del.rowKey });
         } catch (error) {
           result.deletes.push({

package/src/grid/sources/content-source.ts

@@ -39,6 +39,10 @@ import {
   loadFormats,
 } from "../../format/format-host";
 import { parseSourceForPath } from "../../files/file-ops";
+import { collectionForDirectory } from "../../content/collection-match";
+import { collectionSourceFile } from "../../content/content-collections";
+import { fileRecordIds as recordIdsOf } from "../../content/file-record-ids";
+import { LOCALE_PLACEHOLDER } from "../../canvas/asset-resolve";
 import { columnsFromSchema, inferColumnsFromRows } from "../schema-columns";
 import { makeGridTabId } from "../grid-source";
 import type {
@@ -51,13 +55,16 @@ import type {
   GridSource,
 } from "../grid-source";
 import type { ContentSectionEntry } from "../../types";
+import type { EntryFields } from "../../content/entry-fields";
+import type { JxDocumentValue, JxMutableNode } from "@jxsuite/schema/types";
+import { isJsonPrimitive, isNonNullObject, isString } from "@jxsuite/schema/guards";
 
 /** The synthetic identity column: the entry's project path. Editable only on pending inserts. */
 export const PATH_FIELD = "__path";
 
 interface EntryRecord {
-  frontmatter: Record<string, unknown>;
-  document: Record<string, unknown>;
+  frontmatter: EntryFields;
+  document: JxMutableNode;
   rawText: string;
   formatName: string;
 }
@@ -69,13 +76,17 @@ interface CollectionInfo {
   ext: string;
 }
 
+/** The open project's `content` section (collection name → entry), or an empty one. */
+function contentSection(): Record<string, ContentSectionEntry> {
+  /* SAFETY: `content` is the parser extension's section — collection name → entry object, its
+     project fragment schema the source of truth. `ContentSectionEntry` names only the fields Studio
+     reads, every one optional, and both readers below test `source` before using it. */
+  return (projectState?.projectConfig?.content ?? {}) as Record<string, ContentSectionEntry>;
+}
+
 /** Resolve a content type's definition, source dir, and entry extension from project config. */
 export function collectionInfo(typeName: string): CollectionInfo | null {
-  const content = (projectState?.projectConfig?.content ?? {}) as Record<
-    string,
-    ContentSectionEntry
-  >;
-  const def = content[typeName];
+  const def = contentSection()[typeName];
   if (!def?.source) {
     return null;
   }
@@ -91,11 +102,7 @@ export function collectionInfo(typeName: string): CollectionInfo | null {
 
 /** Directory-backed collections in the project (for "Edit collection in Grid" affordances). */
 export function collectionDirs(): { name: string; dir: string }[] {
-  const content = (projectState?.projectConfig?.content ?? {}) as Record<
-    string,
-    ContentSectionEntry
-  >;
-  return Object.entries(content)
+  return Object.entries(contentSection())
     .filter(([, def]) => {
       const source = def.source?.replace(/^\.\//, "") ?? "";
       return source !== "" && !/\.[a-z0-9]+$/i.test(source);
@@ -126,14 +133,77 @@ async function listEntryFiles(dir: string, exts: string[]): Promise<string[]> {
   return results.toSorted();
 }
 
-/** Entry ids (file stems) of a collection — used by relationship cell editors. */
+/**
+ * The real directories a collection's entries live in.
+ *
+ * A plain source is its one directory. A localized source (`content/exhibitions/{locale}`) is one
+ * directory per language, and the literal path with the placeholder is a directory nobody has:
+ * listing it is a 500 from the dev server and an empty collection on screen. So the placeholder's
+ * parent is listed, and each subdirectory is kept when the one collection matcher
+ * (`content/collection-match.ts`) says that directory IS this collection's, which is what keeps an
+ * undeclared language or a co-located `images/` folder out.
+ */
+export async function collectionSourceDirs(info: { dir: string; name: string }): Promise<string[]> {
+  const cut = info.dir.indexOf(LOCALE_PLACEHOLDER);
+  if (cut === -1) {
+    return [info.dir];
+  }
+  const head = info.dir.slice(0, cut).replace(/\/$/, "");
+  const tail = info.dir.slice(cut + LOCALE_PLACEHOLDER.length);
+  let children;
+  try {
+    children = await getPlatform().listDirectory(head);
+  } catch {
+    return []; // No parent directory yet: a localized collection with no entries in any language.
+  }
+  return children
+    .filter((entry) => entry.type === "directory")
+    .map((entry) => `${entry.path}${tail}`.replace(/\/$/, ""))
+    .filter((dir) => collectionForDirectory(dir)?.name === info.name)
+    .toSorted();
+}
+
+/** Every entry file of a collection, across all of its directories. */
+async function listCollectionFiles(info: CollectionInfo): Promise<string[]> {
+  const dirs = await collectionSourceDirs(info);
+  const lists = await Promise.all(dirs.map((dir) => listEntryFiles(dir, [info.ext])));
+  return lists.flat().toSorted();
+}
+
+/**
+ * The ids of a file-backed collection's records (`content/file-records.ts`), or `null` when the
+ * source is a directory. A source that names a file is read, never listed: listing a CSV as a
+ * directory is a 500 from the dev server and a collection of no entries on screen.
+ */
+async function fileRecordIds(info: CollectionInfo): Promise<string[] | null> {
+  const file = collectionSourceFile(info.name);
+  if (file === null) {
+    return null;
+  }
+  let text: string;
+  try {
+    text = await getPlatform().readFile(file);
+  } catch {
+    return []; // A source file not written yet: an empty collection.
+  }
+  return recordIdsOf(file, text, info.def.idField);
+}
+
+/**
+ * Entry ids of a collection (file stems, or a file-backed collection's record ids), used by
+ * relationship cell editors and the Site panel's counts.
+ */
 export async function listCollectionEntryIds(typeName: string): Promise<string[]> {
   await loadFormats().catch(() => {}); // Extension resolution needs the format registry.
   const info = collectionInfo(typeName);
   if (!info) {
     return [];
   }
-  const files = await listEntryFiles(info.dir, [info.ext]);
+  const recordIds = await fileRecordIds(info);
+  if (recordIds !== null) {
+    return recordIds;
+  }
+  const files = await listCollectionFiles(info);
   return files.map((path) => {
     const base = path.split("/").pop() ?? path;
     return base.slice(0, base.length - info.ext.length);
@@ -160,14 +230,14 @@ async function mapLimit<T, R>(
 }
 
 /** Frontmatter value → grid cell value. Nested objects surface as read-only JSON text. */
-function toCellValue(value: unknown): GridCellValue {
-  if (value === null || value === undefined) {
+function toCellValue(value: JxDocumentValue | undefined): GridCellValue {
+  if (value === undefined) {
     return null;
   }
-  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+  if (isJsonPrimitive(value)) {
     return value;
   }
-  if (Array.isArray(value) && value.every((v) => typeof v !== "object" || v === null)) {
+  if (Array.isArray(value) && value.every((v) => !isNonNullObject(v))) {
     return value.map(String);
   }
   return JSON.stringify(value);
@@ -187,9 +257,7 @@ function openTabFor(path: string) {
 function extraRowsAreStrings(rows: Record<string, GridCellValue>[], field: string): boolean {
   return rows.every((row) => {
     const value = row[field];
-    return value === null || value === undefined || typeof value !== "string"
-      ? true
-      : !value.startsWith("{") && !value.startsWith("[");
+    return !isString(value) || (!value.startsWith("{") && !value.startsWith("["));
   });
 }
 
@@ -294,7 +362,7 @@ function buildEntryFileSource(opts: EntryFileSourceOptions): GridSource {
           return {
             document: parsed.document,
             formatName: parsed.format.name,
-            frontmatter: parsed.frontmatter ?? {},
+            frontmatter: parsed.frontmatter,
             rawText: text,
           };
         } catch {
@@ -393,7 +461,7 @@ function buildEntryFileSource(opts: EntryFileSourceOptions): GridSource {
   };
 
   const rowFor = (path: string, entry: EntryRecord): GridRow => {
-    const cells: Record<string, GridCellValue> = { [PATH_FIELD]: path };
+    const cells: GridRow["cells"] = { [PATH_FIELD]: path };
     for (const column of buildColumns()) {
       if (column.field === PATH_FIELD) {
         continue;
@@ -420,7 +488,11 @@ function buildEntryFileSource(opts: EntryFileSourceOptions): GridSource {
     }
     const doc = entry.document;
     const fullDoc = { ...frontmatter, ...doc, children: doc.children ?? [] };
-    const text = await formatSerialize(entry.formatName, fullDoc, { mode: "roundtrip" });
+    // The entry's own text, so only the patched keys are re-spelled.
+    const text = await formatSerialize(entry.formatName, fullDoc, {
+      mode: "roundtrip",
+      source: entry.rawText,
+    });
     markLocalMutation(path);
     await platform.writeFile(path, text);
     entries.set(path, { ...entry, frontmatter, rawText: text });
@@ -490,7 +562,7 @@ function buildEntryFileSource(opts: EntryFileSourceOptions): GridSource {
       // Inserts: new entry files from the Path cell.
       for (const insert of batch.inserts) {
         const rawPath = insert.cells[PATH_FIELD];
-        if (typeof rawPath !== "string" || rawPath.trim() === "") {
+        if (!isString(rawPath) || rawPath.trim() === "") {
           result.inserts.push({ error: "Path is required", ok: false, tempKey: insert.tempKey });
           continue;
         }
@@ -522,7 +594,7 @@ function buildEntryFileSource(opts: EntryFileSourceOptions): GridSource {
           continue;
         }
         try {
-          const frontmatter: Record<string, unknown> = {};
+          const frontmatter: Record<string, GridCellValue> = {};
           for (const [field, value] of Object.entries(insert.cells)) {
             if (field !== PATH_FIELD && value !== null) {
               frontmatter[field] = value;
@@ -539,7 +611,7 @@ function buildEntryFileSource(opts: EntryFileSourceOptions): GridSource {
           entries.set(path, {
             document: parsed.document,
             formatName: parsed.format.name,
-            frontmatter: parsed.frontmatter ?? {},
+            frontmatter: parsed.frontmatter,
             rawText: text,
           });
           result.inserts.push({ newKey: path, ok: true, tempKey: insert.tempKey });
@@ -627,10 +699,7 @@ export function createCollectionSource(typeName: string): GridSource {
       );
     },
     label: typeName,
-    list: () => {
-      const info = requireInfo();
-      return listEntryFiles(info.dir, [info.ext]);
-    },
+    list: () => listCollectionFiles(requireInfo()),
     resolveInsertPath: (raw) => {
       const info = requireInfo();
       let path = raw.trim().replace(/^\.\//, "").replace(/^\//, "");

package/src/grid/sources/csv-file-source.ts

@@ -84,7 +84,7 @@ function buildModel(text: string, path: string): CsvModel {
 
   // Typed columns when this CSV is a collection source; sniffed kinds otherwise.
   const contentType = findContentTypeSchema(path, projectState?.projectConfig);
-  const schemaProps = contentType?.schema?.properties ?? {};
+  const schemaProps = contentType?.schema.properties ?? {};
   const sampleRows = doc.rows.slice(0, 50).map((row) => {
     const cells: Record<string, GridCellValue> = {};
     for (const [i, field] of fields.entries()) {
@@ -116,7 +116,7 @@ function buildModel(text: string, path: string): CsvModel {
 }
 
 /** Typed cell values for one matrix row. */
-function rowCells(model: CsvModel, rowIndex: number): Record<string, GridCellValue> {
+function rowCells(model: CsvModel, rowIndex: number): GridRow["cells"] {
   const cells: Record<string, GridCellValue> = {};
   const row = model.doc.rows[rowIndex] ?? [];
   for (const [i, field] of model.fields.entries()) {

package/src/grid/tabulator-tables.d.ts

@@ -1,26 +1,35 @@
 /**
  * Minimal ambient types for tabulator-tables 6.x — the package ships no declarations. Only the
  * surface grid-view.ts touches is typed; extend here as usage grows.
+ *
+ * Every component is generic over `Value`, the type of one cell value. Tabulator stores the row
+ * objects it is handed (`data`, `replaceData`) and gives the same values back (`getValue`,
+ * `getData`, sorter and filter arguments), so the caller that builds the table names the value type
+ * once and reads it back from every component. Values written in (`setValue`, an editor's
+ * `success`, `selectableRangeClearCellsValue`) must be of that same type for the promise to hold.
  */
 declare module "tabulator-tables" {
-  export interface CellComponent {
-    getValue: () => unknown;
+  /** One row object as the table stores it: cell values keyed by field. */
+  export type RowData<Value> = Record<string, Value>;
+
+  export interface CellComponent<Value> {
+    getValue: () => Value;
     getField: () => string;
     getElement: () => HTMLElement;
-    getRow: () => RowComponent;
-    setValue: (value: unknown, mutate?: boolean) => void;
+    getRow: () => RowComponent<Value>;
+    setValue: (value: Value, mutate?: boolean) => void;
   }
 
-  export interface RowComponent {
-    getData: () => Record<string, unknown>;
+  export interface RowComponent<Value> {
+    getData: () => RowData<Value>;
     getElement: () => HTMLElement;
-    getCells: () => CellComponent[];
+    getCells: () => CellComponent<Value>[];
     reformat: () => void;
   }
 
-  export interface RangeComponent {
-    getRows: () => RowComponent[];
-    getCells: () => CellComponent[][];
+  export interface RangeComponent<Value> {
+    getRows: () => RowComponent<Value>[];
+    getCells: () => CellComponent<Value>[][];
   }
 
   export interface ColumnComponent {
@@ -28,28 +37,29 @@ declare module "tabulator-tables" {
     getWidth: () => number;
   }
 
-  export type CellEditor = (
-    cell: CellComponent,
+  export type CellEditor<Value> = (
+    cell: CellComponent<Value>,
     onRendered: (fn: () => void) => void,
-    success: (value: unknown) => void,
+    success: (value: Value) => void,
     cancel: () => void,
   ) => HTMLElement | false;
 
-  export type CellFormatter = (
-    cell: CellComponent,
-    formatterParams: Record<string, unknown>,
+  export type CellFormatter<Value> = (
+    cell: CellComponent<Value>,
+    /** Always `{}`: no column definition here declares `formatterParams`. */
+    formatterParams: Record<string, never>,
     onRendered: (fn: () => void) => void,
   ) => HTMLElement | string;
 
-  export interface ColumnDefinition {
+  export interface ColumnDefinition<Value> {
     title: string;
     field?: string | undefined;
     width?: number | undefined;
     frozen?: boolean | undefined;
-    editor?: CellEditor | undefined;
-    editable?: boolean | ((cell: CellComponent) => boolean) | undefined;
-    formatter?: CellFormatter | undefined;
-    sorter?: string | ((a: unknown, b: unknown) => number) | undefined;
+    editor?: CellEditor<Value> | undefined;
+    editable?: boolean | ((cell: CellComponent<Value>) => boolean) | undefined;
+    formatter?: CellFormatter<Value> | undefined;
+    sorter?: string | ((a: Value, b: Value) => number) | undefined;
     headerSort?: boolean | undefined;
     headerFilter?: string | undefined;
     cssClass?: string | undefined;
@@ -57,9 +67,20 @@ declare module "tabulator-tables" {
     headerSortTristate?: boolean | undefined;
   }
 
-  export interface Options {
-    data?: Record<string, unknown>[];
-    columns?: ColumnDefinition[];
+  /** Which table regions a clipboard copy includes. */
+  export interface ClipboardCopyConfig {
+    columnHeaders?: boolean;
+    columnGroups?: boolean;
+    rowHeaders?: boolean;
+    rowGroups?: boolean;
+    columnCalcs?: boolean;
+    dataTree?: boolean;
+    formatCells?: boolean;
+  }
+
+  export interface Options<Value> {
+    data?: RowData<Value>[];
+    columns?: ColumnDefinition<Value>[];
     index?: string;
     layout?: string;
     height?: string | number;
@@ -73,27 +94,33 @@ declare module "tabulator-tables" {
     selectableRangeColumns?: boolean;
     selectableRangeRows?: boolean;
     selectableRangeClearCells?: boolean;
-    selectableRangeClearCellsValue?: unknown;
+    selectableRangeClearCellsValue?: Value;
     clipboard?: boolean;
     clipboardCopyStyled?: boolean;
-    clipboardCopyConfig?: Record<string, unknown>;
+    clipboardCopyConfig?: ClipboardCopyConfig;
     clipboardCopyRowRange?: string;
     clipboardPasteParser?: string;
     clipboardPasteAction?: string;
     movableColumns?: boolean;
-    columnDefaults?: Partial<ColumnDefinition>;
-    rowFormatter?: (row: RowComponent) => void;
+    columnDefaults?: Partial<ColumnDefinition<Value>>;
+    rowFormatter?: (row: RowComponent<Value>) => void;
     placeholder?: string;
   }
 
-  export class Tabulator {
-    constructor(host: HTMLElement, options: Options);
+  export class Tabulator<Value> {
+    constructor(host: HTMLElement, options: Options<Value>);
     static registerModule(modules: unknown[]): void;
     on(event: string, callback: (...args: never[]) => void): void;
-    replaceData(data: Record<string, unknown>[]): Promise<void>;
-    getRows(activeOnly?: string): RowComponent[];
-    getRanges(): RangeComponent[];
-    setFilter(filter: (data: Record<string, unknown>) => boolean): void;
+    replaceData(data: RowData<Value>[]): Promise<void>;
+    getRows(activeOnly?: string): RowComponent<Value>[];
+    getRanges(): RangeComponent<Value>[];
+    /** The row whose `index` field holds `index`, or `false` for none. */
+    getRow(index: string): RowComponent<Value> | false;
+    /** Scroll a row into view; rejects when no row holds `index`. */
+    scrollToRow(index: string, position?: string, ifVisible?: boolean): Promise<void>;
+    /** Select the range between two cells, replacing the oldest range past `selectableRange`. */
+    addRange(start: CellComponent<Value>, end: CellComponent<Value>): RangeComponent<Value>;
+    setFilter(filter: (data: RowData<Value>) => boolean): void;
     clearFilter(includeHeaderFilters?: boolean): void;
     redraw(force?: boolean): void;
     destroy(): void;

package/src/hosting/document.ts

@@ -109,8 +109,8 @@ export function studioShellHtml(options: DocumentOptions = {}): string {
   const boot = (options.boot ?? []).map((mod) => `    ${scriptTag(mod)}`).join("\n");
   /* Only when there IS a boot module: `packages/studio/index.html` is generated with none and CI
      diffs it byte for byte, and the dev server it is served by is the one host that should fall
-     back. The `<head>` below stays a literal, attribute-free tag — Electrobun's macOS CEF path
-     injects its preload by splicing after that exact string. */
+     back. The `<head>` below stays a literal, attribute-free tag — a host that
+     injects a preload splices it in after that exact string. */
   const bootMeta = boot
     ? `    <meta name="${BOOT_META.name}" content="${BOOT_META.content}" />\n`
     : "";

package/src/hosting/stage.ts

@@ -15,6 +15,7 @@ import { cp, mkdir, readFile, rm, stat, writeFile } from "node:fs/promises";
 import { existsSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import { Glob } from "bun";
+import { isNonNullObject } from "@jxsuite/schema/guards";
 import { STUDIO_ASSETS, STUDIO_CANVAS, STUDIO_SHELL } from "./layout";
 import type { AssetBase, StudioAsset, StudioAssetKind, StudioLayoutMode } from "./layout";
 import { canvasShellHtml } from "./document";
@@ -193,11 +194,10 @@ export async function writeAssetManifest(
 ): Promise<void> {
   const out = manifestPath(root);
   await mkdir(dirname(out), { recursive: true });
-  const manifest = {
-    assets: STUDIO_ASSETS,
-    ...(extra.preload === undefined ? {} : { preload: extra.preload }),
-    shell: STUDIO_SHELL,
-  };
+  const manifest =
+    extra.preload === undefined
+      ? { assets: STUDIO_ASSETS, shell: STUDIO_SHELL }
+      : { assets: STUDIO_ASSETS, preload: extra.preload, shell: STUDIO_SHELL };
   await writeFile(out, `${JSON.stringify(manifest, null, 2)}\n`);
 }
 
@@ -231,8 +231,8 @@ export async function studioPreload(root: string = STUDIO_PACKAGE_DIR): Promise<
   if (!existsSync(path)) {
     return [];
   }
-  const manifest = JSON.parse(await readFile(path, "utf8")) as { preload?: unknown };
-  const { preload } = manifest;
+  const manifest: unknown = JSON.parse(await readFile(path, "utf8"));
+  const preload = isNonNullObject(manifest) && "preload" in manifest ? manifest.preload : undefined;
   if (!Array.isArray(preload)) {
     return [];
   }

package/src/i18n/i18n-commands.ts

@@ -47,7 +47,6 @@ import {
 } from "../commands/command-args";
 import type { CommandArgValues } from "../commands/command-args";
 import type { AnyCommand, CommandRegistry } from "../commands/registry";
-import type { Tab } from "../tabs/tab";
 
 /** The tags a translation verb may be asked for — the project's declared locales, read live. */
 function declaredLocales(): string[] {
@@ -98,7 +97,7 @@ function addressedDocument(commandId: string, args: CommandArgValues): string {
     }
     return path;
   }
-  const tab = paneId === undefined ? (activeTab.value as Tab | null) : tabOfPane(paneId);
+  const tab = paneId === undefined ? activeTab.value : tabOfPane(paneId);
   if (!tab) {
     throw new RangeError(
       paneId === undefined
@@ -128,6 +127,7 @@ function siblingPath(documentPath: string, locale: string): string | null {
   if (i18n === null || !i18n.locales.includes(locale)) {
     notify.error(`This project does not declare ${localeLabel(locale)}.`, {
       action: "settings.open",
+      actionArgs: { section: "locales" },
       detail: "Add it in Settings › Locales, or with the Add Language command.",
       source: "Languages",
     });
@@ -322,7 +322,7 @@ export function i18nCommands(): AnyCommand[] {
       when: (ctx) => ctx.project.isMultilingual,
       /* No `aiTool`, by studio-ui-guidelines.md §12.4's first deletion rule: the panel is a surface
          for a person. */
-      /* The panel is off the rail — it spends no rail slot and shifts no ⌘1-8 chord — so this
+      /* The panel is off the rail — it spends no rail slot — so this
          command and the generated `panel.focus.i18n` are its only two doors, and both open the
          same one. The TITLES must differ even though the behaviour does not: the palette is a flat
          searchable list where "View: Show Languages" twice is two rows a reader cannot choose