@jxsuite/studio 6.1.0 → 6.1.2

package/src/surfaces/dialog.ts

@@ -25,27 +25,12 @@
 import { reactive } from "../reactivity";
 import { mountSurface, registerSurface } from "../ui/surface";
 import { overlayRegion, REGION_ATTR } from "../ui/regions";
-import { close as closeDialog, showModal } from "@jxsuite/ui/behaviors/dialog";
+import { close, showModal } from "@jxsuite/ui/behaviors/dialog";
 import { selectValue } from "@jxsuite/ui/behaviors/textfield";
 import dialogDoc from "./dialog.json";
-import type { SurfaceHandle } from "../ui/surface";
-import type { JxDocument } from "@jxsuite/schema/types";
+import type { SurfaceHandle, SurfaceOption } from "../ui/surface";
 
-registerSurface("dialog", dialogDoc as unknown as JxDocument);
-
-/**
- * One option of a prompt's choice.
- *
- * There is no `selected` here, and its absence is the contract rather than an omission: `jx-select`
- * is a native `<select>`, and the reader's first pick sets an option's dirtiness flag, after which
- * the `selected` content attribute stops moving selectedness (`ui.md` §5.1). A projection that
- * marked a row would be right until the first pick and wrong after it. The chosen row is named by
- * `chosen`, once, beside the list.
- */
-export interface DialogChoiceOption {
-  value: string;
-  label: string;
-}
+registerSurface("dialog", dialogDoc);
 
 /** What a flow hands the surface. Everything is a projection; the flow keeps the state machine. */
 export interface DialogSurfaceOptions {
@@ -61,8 +46,15 @@ export interface DialogSurfaceOptions {
   message?: string;
   /** Render a richer body into the document's island, once the element is ready. */
   island?: (host: HTMLElement) => void;
-  /** A `jx-select` above the field, and which of its rows is chosen. */
-  choice?: { label: string; options: DialogChoiceOption[]; chosen: string };
+  /**
+   * A `jx-select` above the field, and which of its rows is chosen. The rows carry no `selected`,
+   * and that absence is the contract rather than an omission: `jx-select` is a native `<select>`,
+   * and the reader's first pick sets an option's dirtiness flag, after which the `selected` content
+   * attribute stops moving selectedness (`ui.md` §5.1). A projection that marked a row would be
+   * right until the first pick and wrong after it. The chosen row is named by `chosen`, once,
+   * beside the list.
+   */
+  choice?: { label: string; options: SurfaceOption[]; chosen: string };
   /** The prompt's field. */
   field?: {
     value: string;
@@ -104,7 +96,7 @@ export interface DialogSurfacePatch {
   placeholder?: string;
   invalid?: boolean;
   error?: string;
-  options?: DialogChoiceOption[];
+  options?: SurfaceOption[];
   chosen?: string;
 }
 
@@ -118,7 +110,7 @@ export interface DialogSurfaceHandle {
   close: () => void;
 }
 
-interface DialogScope extends Record<string, unknown> {
+interface DialogScope {
   headline: string;
   confirmLabel: string;
   secondaryLabel: string;
@@ -129,7 +121,7 @@ interface DialogScope extends Record<string, unknown> {
   hasMessage: boolean;
   hasChoice: boolean;
   choiceLabel: string;
-  options: DialogChoiceOption[];
+  options: SurfaceOption[];
   hasField: boolean;
   multiline: boolean;
   rows: string;
@@ -195,7 +187,7 @@ export function openDialogSurface(options: DialogSurfaceOptions): DialogSurfaceH
   slot.setAttribute(REGION_ATTR, overlayRegion("dialog", options.region));
   options.layer.append(slot);
 
-  const scope = reactive<DialogScope>({
+  const scope: DialogScope = reactive<DialogScope>({
     cancel: () => {
       options.onCancel();
     },
@@ -236,10 +228,14 @@ export function openDialogSurface(options: DialogSurfaceOptions): DialogSurfaceH
     secondaryLabel: options.secondaryLabel ?? "",
     size: options.size ?? "sm",
     value: options.field?.value ?? "",
-  }) as DialogScope;
+  });
 
   let handle: SurfaceHandle | null = null;
   let closed = false;
+  /* Read through a call, not the bare binding: `close()` can run while the mount is awaiting the
+     element, and a direct `closed` test after that `await` would be narrowed to the value the test
+     before it saw. */
+  const isClosed = (): boolean => closed;
   /* Closing while the element is still rendering must not leave `ready` waiting on a `jx-ready`
      a disposed element will never send, so the wait races against the close. */
   let abort: () => void = () => {};
@@ -248,14 +244,16 @@ export function openDialogSurface(options: DialogSurfaceOptions): DialogSurfaceH
   });
   const mounted = mountSurface("dialog", scope, slot);
   const ready = mounted.then(async (surface) => {
+    /* SAFETY: `dialog.json`'s root definition is a `jx-dialog` element, so the runtime
+       mounts an HTMLElement; a `Text` root only comes from a document whose root is a bare string. */
     const element = surface.root as HTMLElement;
-    if (closed) {
+    if (isClosed()) {
       surface.dispose();
       return element;
     }
     handle = surface;
     await Promise.race([whenReady(element), aborted]);
-    if (closed) {
+    if (isClosed()) {
       return element;
     }
     options.island?.(element.querySelector<HTMLElement>('[part="island"]') ?? element);
@@ -284,7 +282,7 @@ export function openDialogSurface(options: DialogSurfaceOptions): DialogSurfaceH
       const element = handle?.root;
       if (element instanceof HTMLElement) {
         // The platform's close first, so focus goes back where it was; then the document goes.
-        closeDialog(element);
+        close(element);
       }
       // A mount that has not landed yet is disposed by `ready` when it does.
       handle?.dispose();

package/src/surfaces/diff-toolbar.ts

@@ -18,10 +18,9 @@
 import { reactive } from "../reactivity";
 import { mountSurface, registerSurface } from "../ui/surface";
 import diffToolbarDoc from "./diff-toolbar.json";
-import type { JxDocument } from "@jxsuite/schema/types";
 import type { SurfaceHandle } from "../ui/surface";
 
-registerSurface("diff-toolbar", diffToolbarDoc as unknown as JxDocument);
+registerSurface("diff-toolbar", diffToolbarDoc);
 
 /** Everything the bar draws, as one value. Every field is already a string or a boolean. */
 export interface DiffToolbarView {
@@ -66,7 +65,7 @@ export interface DiffToolbarSurfaceHandle {
 }
 
 /** The scope the document reads: {@link DiffToolbarView} plus the actions its controls call. */
-interface DiffToolbarScope extends Record<string, unknown>, DiffToolbarView, DiffToolbarActions {}
+interface DiffToolbarScope extends DiffToolbarView, DiffToolbarActions {}
 
 /** Write a projection into the scope. */
 function project(scope: DiffToolbarScope, view: DiffToolbarView): void {
@@ -98,7 +97,7 @@ export function mountDiffToolbarSurface(
   actions: DiffToolbarActions,
 ): DiffToolbarSurfaceHandle {
   host.replaceChildren();
-  const scope = reactive<DiffToolbarScope>({
+  const scope: DiffToolbarScope = reactive<DiffToolbarScope>({
     codeChecked: "false",
     countLabel: "",
     degraded: "hidden",
@@ -113,18 +112,21 @@ export function mountDiffToolbarSurface(
     stepper: "hidden",
     viewMode: "choice",
     visualChecked: "true",
-  }) as DiffToolbarScope;
+  });
   project(scope, view);
 
   let mounted: SurfaceHandle | null = null;
   let disposed = false;
   const ready = mountSurface("diff-toolbar", scope, host).then((surface) => {
+    /* SAFETY: `diff-toolbar.json`'s root definition is a `div` element, so the runtime mounts an
+       HTMLElement; a `Text` root only comes from a document whose root is a bare string. */
+    const root = surface.root as HTMLElement;
     if (disposed) {
       surface.dispose();
-      return surface.root as HTMLElement;
+      return root;
     }
     mounted = surface;
-    return surface.root as HTMLElement;
+    return root;
   });
 
   return {

package/src/surfaces/doc-header.ts

@@ -27,16 +27,9 @@
 import { reactive } from "../reactivity";
 import { mountSurface, registerSurface } from "../ui/surface";
 import docHeaderDoc from "./doc-header.json";
-import type { JxDocument } from "@jxsuite/schema/types";
-import type { SurfaceHandle } from "../ui/surface";
+import type { SurfaceHandle, SurfaceOption } from "../ui/surface";
 
-registerSurface("doc-header", docHeaderDoc as unknown as JxDocument);
-
-/** One choice in a row's picker. The shape `jx-select` reads. */
-export interface DocHeaderChoice {
-  value: string;
-  label: string;
-}
+registerSurface("doc-header", docHeaderDoc);
 
 /**
  * One row of the card, as the document reads it.
@@ -45,7 +38,7 @@ export interface DocHeaderChoice {
  * `$switch` chooses on one: a row that omitted `options` would leave the picker case reading an
  * absent path.
  */
-export interface DocHeaderRow extends Record<string, unknown> {
+export interface DocHeaderRow {
   /** The row's identity: the repeater's key, and the argument every action is given. */
   key: string;
   /** The name on `data-prop` — what a reader, a screenshot region and the inspector call it. */
@@ -68,7 +61,7 @@ export interface DocHeaderRow extends Record<string, unknown> {
   /** A text row's placeholder. Empty draws none. */
   placeholder: string;
   /** A picker's rows, in the order they are offered. Empty on every other kind. */
-  options: DocHeaderChoice[];
+  options: SurfaceOption[];
   /** A sentence under the control — an empty collection, or a listing that failed. */
   note: string;
   /** Whether {@link DocHeaderRow.note} has anything in it; `$switch` is the document's conditional. */
@@ -80,7 +73,7 @@ export interface DocHeaderRow extends Record<string, unknown> {
 }
 
 /** One `$head` entry the disclosure lists, read-only. */
-export interface DocHeaderRawEntry extends Record<string, unknown> {
+export interface DocHeaderRawEntry {
   /** Unique within one document — the repeater's key. */
   key: string;
   /** The entry as markup, e.g. `<meta name="author">`. */
@@ -134,7 +127,7 @@ export interface DocHeaderActions {
   /** Open the OS file picker for a media row and assign what comes back. */
   upload: (key: string) => void;
   /** Open the media browser under the button that was pressed. */
-  browse: (key: string, anchor: unknown) => void;
+  browse: (key: string, anchor: EventTarget | null) => void;
   /** Run the `document.openSeo` command — the door to Search appearance. */
   openSeo: () => void;
   /** Remember that the Raw head tags disclosure was opened or closed. */
@@ -153,7 +146,7 @@ export interface DocHeaderSurface {
 }
 
 /** The scope the document reads: the view plus the actions, flat. */
-interface DocHeaderScope extends Record<string, unknown>, DocHeaderView, DocHeaderActions {}
+interface DocHeaderScope extends DocHeaderView, DocHeaderActions {}
 
 /** Write a whole view into the scope. Assignment only — the mount is never rebuilt for a repaint. */
 function project(scope: DocHeaderScope, view: DocHeaderView): void {
@@ -184,7 +177,7 @@ export function mountDocHeaderSurface(
   view: DocHeaderView,
   actions: DocHeaderActions,
 ): DocHeaderSurface {
-  const scope = reactive<DocHeaderScope>({
+  const scope: DocHeaderScope = reactive<DocHeaderScope>({
     ...actions,
     collection: "Document",
     expanded: true,
@@ -195,7 +188,7 @@ export function mountDocHeaderSurface(
     region: "",
     route: "",
     rows: [],
-  }) as DocHeaderScope;
+  });
   project(scope, view);
 
   host.replaceChildren();
@@ -218,9 +211,7 @@ export function mountDocHeaderSurface(
        stage that redrew took the card's root away without telling anyone. */
     connected: () =>
       !disposed &&
-      (mounted === null
-        ? host.childNodes.length === 0
-        : (mounted.root as Node).parentNode === host),
+      (mounted === null ? host.childNodes.length === 0 : mounted.root.parentNode === host),
     dispose() {
       disposed = true;
       mounted?.dispose();

package/src/surfaces/empty-state.ts

@@ -28,13 +28,12 @@ import { reactive } from "../reactivity";
 import { mountSurface, registerSurface } from "../ui/surface";
 import emptyStateDoc from "./empty-state.json";
 import type { EmptyStateSpec } from "../panels/empty-state";
-import type { JxDocument } from "@jxsuite/schema/types";
 import type { SurfaceHandle } from "../ui/surface";
 
-registerSurface("empty-state", emptyStateDoc as unknown as JxDocument);
+registerSurface("empty-state", emptyStateDoc);
 
 /** One button, as the document draws it: a key, a word, and whether it can act. */
-interface EmptyStateActionRow extends Record<string, unknown> {
+interface EmptyStateActionRow {
   /** The repeater's key and what a press is addressed with — this action's slot in the list. */
   id: string;
   label: string;
@@ -44,10 +43,8 @@ interface EmptyStateActionRow extends Record<string, unknown> {
 /**
  * What the document draws, with every branch already decided.
  *
- * Named apart from the scope rather than derived from it with `Omit`: the scope carries the kit's
- * `Record<string, unknown>` index signature, and `Omit` over a type with one keeps the signature
- * and drops every named property — so the projection below would have type-checked against
- * anything.
+ * Named apart from the scope, which adds the one callback, so the projection below is checked
+ * against exactly the fields the document draws.
  */
 interface EmptyStateView {
   message: string;
@@ -59,7 +56,7 @@ interface EmptyStateView {
 }
 
 /** The scope `empty-state.json` reads. Every field is a value; the document asks no question. */
-interface EmptyStateScope extends Record<string, unknown>, EmptyStateView {
+interface EmptyStateScope extends EmptyStateView {
   runAction: (id: string) => void;
 }
 
@@ -89,12 +86,12 @@ export function createEmptyStateSurface(spec: EmptyStateSpec): EmptyStateSurface
 
   /** The handlers, held apart from the scope so `runAction` never has to be reassigned. */
   let handlers: (() => void)[] = [];
-  const scope = reactive<EmptyStateScope>({
+  const scope: EmptyStateScope = reactive<EmptyStateScope>({
     ...project(spec),
     runAction: (id: string) => {
       handlers[Number(id)]?.();
     },
-  }) as EmptyStateScope;
+  });
   handlers = handlersOf(spec);
 
   let mounted: SurfaceHandle | null = null;

package/src/surfaces/entry-editor.ts

@@ -27,13 +27,14 @@
  * @docs studio/projects/content-types
  */
 
+import { isString } from "@jxsuite/schema/guards";
 import { reactive } from "../reactivity";
 import { mountSurface, registerSurface } from "../ui/surface";
 import entryEditorDoc from "./entry-editor.json";
-import type { JxDocument } from "@jxsuite/schema/types";
+import type { JxElement } from "@jxsuite/schema/types";
 import type { SurfaceHandle } from "../ui/surface";
 
-registerSurface("entry-editor", entryEditorDoc as unknown as JxDocument);
+registerSurface("entry-editor", entryEditorDoc);
 
 /** Everything the document draws, as one value. */
 export interface EntryEditorView {
@@ -89,7 +90,7 @@ export interface EntryEditorSurfaceHandle {
 }
 
 /** The scope the document reads: the view plus the actions, flat. */
-interface EntryEditorScope extends Record<string, unknown>, EntryEditorView, EntryEditorActions {}
+interface EntryEditorScope extends EntryEditorView, EntryEditorActions {}
 
 /** Write a whole view into the scope. Assignment only — the mount is never rebuilt for a repaint. */
 function project(scope: EntryEditorScope, view: EntryEditorView): void {
@@ -107,10 +108,9 @@ function project(scope: EntryEditorScope, view: EntryEditorView): void {
 }
 
 /** The `part` a node was authored with, or `""` — the only thing this adapter asks about a node. */
-function partOf(def: unknown): string {
-  const attributes = (def as { attributes?: Record<string, unknown> } | null)?.attributes;
-  const part = attributes?.["part"];
-  return typeof part === "string" ? part : "";
+function partOf(def: JxElement | string): string {
+  const part = isString(def) ? undefined : def.attributes?.["part"];
+  return isString(part) ? part : "";
 }
 
 /**
@@ -133,7 +133,7 @@ export function mountEntryEditorSurface(
   islands: EntryEditorIslands,
 ): EntryEditorSurfaceHandle {
   host.replaceChildren();
-  const scope = reactive<EntryEditorScope>({
+  const scope: EntryEditorScope = reactive<EntryEditorScope>({
     collection: "",
     draft: false,
     draftAxis: "hidden",
@@ -147,7 +147,7 @@ export function mountEntryEditorSurface(
     region: "",
     setDraft: actions.setDraft,
     stage: "empty",
-  }) as EntryEditorScope;
+  });
   project(scope, view);
 
   let mounted: SurfaceHandle | null = null;
@@ -163,12 +163,15 @@ export function mountEntryEditorSurface(
       }
     },
   }).then((surface) => {
+    /* SAFETY: `entry-editor.json`'s root definition is a `div` element, so the runtime mounts an
+       HTMLElement; a `Text` root only comes from a document whose root is a bare string. */
+    const root = surface.root as HTMLElement;
     if (disposed) {
       surface.dispose();
-      return surface.root as HTMLElement;
+      return root;
     }
     mounted = surface;
-    return surface.root as HTMLElement;
+    return root;
   });
 
   return {

package/src/surfaces/expression-editor.ts

@@ -31,26 +31,12 @@
 import { reactive } from "../reactivity";
 import { mountSurface, registerSurface } from "../ui/surface";
 import expressionEditorDoc from "./expression-editor.json";
-import type { JxDocument } from "@jxsuite/schema/types";
-import type { SurfaceHandle } from "../ui/surface";
+import type { SurfaceHandle, SurfaceOption, SurfaceOptionGroup } from "../ui/surface";
 
-registerSurface("expression-editor", expressionEditorDoc as unknown as JxDocument);
-
-/** A closed list of choices, in the shape the kit's select reads. */
-export interface ExprOption {
-  value: string;
-  label: string;
-}
-
-/** A delimited run of choices — the kit's own `optgroup`, which draws both halves of the rule. */
-export interface ExprSelectGroup {
-  id: string;
-  label: string;
-  rows: ExprOption[];
-}
+registerSurface("expression-editor", expressionEditorDoc);
 
 /** One chip of the pipeline, as the document draws it. */
-export interface ExprChipView extends Record<string, unknown> {
+export interface ExprChipView {
   /** The joined node path: the repeater's key, and what a click reports back to the flow. */
   key: string;
   label: string;
@@ -83,7 +69,7 @@ export type ExprLead = "none" | "arg" | "case" | "default";
  * Every field is a string, a flag or a list: the document asks no question about an expression, and
  * there is no branch in it that the walk has not already taken.
  */
-export interface ExprRowView extends Record<string, unknown> {
+export interface ExprRowView {
   /**
    * Unique within one editor, and the repeater's key. It is the node's own path plus the slot it
    * fills, so a row that survives an edit keeps its node — which is what stops a keystroke in one
@@ -111,19 +97,19 @@ export interface ExprRowView extends Record<string, unknown> {
   /** The accessible name of the row's icon-only control. */
   title: string;
   /** An `operator` row's grouped operator list. */
-  groups: ExprSelectGroup[];
+  groups: SurfaceOptionGroup[];
   /** An `operator` row offers the catalog beside its picker; a nested one does not. */
   catalog: boolean;
   /** Which rung an `operand` row shows. */
   source: ExprSource;
   /** The rungs on offer. Empty means the slot admits one shape, so there is nothing to choose. */
-  sourceOptions: ExprOption[];
+  sourceOptions: SurfaceOption[];
   /** Whether the rung picker is drawn at all — `sourceOptions` non-empty, said as a flag. */
   chooser: boolean;
   /** `string`, `number`, `boolean` or `null` — what the literal type picker holds. */
   literalType: string;
   /** The literal types on offer. A separate list from {@link sourceOptions}: two questions. */
-  typeOptions: ExprOption[];
+  typeOptions: SurfaceOption[];
   /** Which literal control follows the type picker: `text`, `number`, `bool` or `null`. */
   literal: string;
   /** What a text literal, a number literal or a ref picker holds. */
@@ -131,9 +117,9 @@ export interface ExprRowView extends Record<string, unknown> {
   /** What a boolean literal holds. */
   checked: boolean;
   /** The signals this slot may bind to. */
-  refOptions: ExprOption[];
+  refOptions: SurfaceOption[];
   /** The event refs, as their own named run. Empty where the position admits none. */
-  refGroups: ExprSelectGroup[];
+  refGroups: SurfaceOptionGroup[];
   /** Which leading cell the row carries. */
   lead: ExprLead;
   /** An arg's positional name, or the `default` case's word. */
@@ -181,7 +167,7 @@ export interface ExpressionActions {
   pickChip: (key: string) => void;
 }
 
-interface ExpressionScope extends Record<string, unknown>, ExpressionActions {
+interface ExpressionScope extends ExpressionActions {
   rows: ExprRowView[];
 }
 
@@ -225,7 +211,7 @@ export function renderExpressionEditorSurface(
   }
   takeDown(host, existing);
   host.textContent = "";
-  const scope = reactive({ ...actions, rows }) as ExpressionScope;
+  const scope: ExpressionScope = reactive<ExpressionScope>({ ...actions, rows });
   const record: Mounted = { disposed: false, handle: null, scope };
   mounts.set(host, record);
   /* No race to arbitrate: a repaint arriving while this is in flight takes the branch above — a

package/src/surfaces/files-panel.ts

@@ -37,14 +37,15 @@
  * @docs studio/interface
  */
 
+import { isNonNullObject, isString } from "@jxsuite/schema/guards";
 import { reactive } from "../reactivity";
 import { mountSurface, registerSurface } from "../ui/surface";
 import filesPanelDoc from "./files-panel.json";
-import type { JxDocument, JxElement } from "@jxsuite/schema/types";
+import type { JxElement } from "@jxsuite/schema/types";
 import type { JxScope } from "@jxsuite/runtime/types";
 import type { SurfaceHandle } from "../ui/surface";
 
-registerSurface("files-panel", filesPanelDoc as unknown as JxDocument);
+registerSurface("files-panel", filesPanelDoc);
 
 /**
  * One row the tree draws, with every field already a string.
@@ -170,7 +171,7 @@ export interface FilesPanelSurfaceHandle {
 }
 
 /** The scope the document reads: the projection, plus everything a control can ask for. */
-interface FilesPanelScope extends Record<string, unknown>, FilesPanelValues, FilesPanelActions {}
+interface FilesPanelScope extends FilesPanelValues, FilesPanelActions {}
 
 /** Write a projection into the scope. Assignment by assignment, so an unchanged field is inert. */
 function project(scope: FilesPanelScope, values: FilesPanelValues): void {
@@ -214,15 +215,28 @@ export function emptyFilesPanelValues(): FilesPanelValues {
 
 /** The `part` a node's definition carries, or `""` for a text node or an unmarked element. */
 function partOf(def: JxElement | string): string {
-  const part = typeof def === "string" ? undefined : def.attributes?.["part"];
-  return typeof part === "string" ? part : "";
+  const part = isString(def) ? undefined : def.attributes?.["part"];
+  return isString(part) ? part : "";
 }
 
-/** The mapped row a node was rendered inside, or null when it was not in one. */
-function mappedRow(state: JxScope | undefined): FileRowView | null {
-  const map = state?.["$map"] as { item?: unknown } | undefined;
-  const item = map?.item as FileRowView | undefined;
-  return typeof item?.path === "string" ? item : null;
+/**
+ * The path and type of the mapped row a node was rendered inside, or null when it was not in one.
+ * The only mapped array in `files-panel.json` is `#/state/rows`, which `project()` fills from
+ * `FilesPanelValues.rows: FileRowView[]`, so a row's item carries both as strings.
+ */
+function mappedRow(state: JxScope | undefined): Pick<FileRowView, "path" | "type"> | null {
+  const map = state?.["$map"];
+  const item = isNonNullObject(map) && "item" in map ? map.item : undefined;
+  if (
+    !isNonNullObject(item) ||
+    !("path" in item) ||
+    !isString(item.path) ||
+    !("type" in item) ||
+    !isString(item.type)
+  ) {
+    return null;
+  }
+  return { path: item.path, type: item.type };
 }
 
 /**
@@ -237,10 +251,10 @@ export function mountFilesPanelSurface(
   values: FilesPanelValues,
   actions: FilesPanelActions,
 ): FilesPanelSurfaceHandle {
-  const scope = reactive<FilesPanelScope>({
+  const scope: FilesPanelScope = reactive<FilesPanelScope>({
     ...emptyFilesPanelValues(),
     ...actions,
-  }) as FilesPanelScope;
+  });
   project(scope, values);
 
   let mounted: SurfaceHandle | null = null;
@@ -286,8 +300,7 @@ export function mountFilesPanelSurface(
        answer is simply whether this handle is still wanted — answering no would start a second
        mount racing the first. Once mounted, the question is whether the root is still where it was
        put: a Navigator that painted another panel cleared this document out from under it. */
-    connected: () =>
-      !disposed && (mounted === null || (mounted.root as Node).parentNode === container),
+    connected: () => !disposed && (mounted === null || mounted.root.parentNode === container),
     dispose() {
       disposed = true;
       mounted?.dispose();

package/src/surfaces/formula-palette.ts

@@ -39,9 +39,8 @@ import formulaPaletteDoc from "./formula-palette.json";
 
 import type { FormulaCatalogEntry } from "../ui/formula-catalog";
 import type { SurfaceHandle } from "../ui/surface";
-import type { JxDocument } from "@jxsuite/schema/types";
 
-registerSurface("formula-palette", formulaPaletteDoc as unknown as JxDocument);
+registerSurface("formula-palette", formulaPaletteDoc);
 
 /** The popover slot id, and so the `overlay.popover:formula-palette` region the shots address. */
 const SLOT = "formula-palette";
@@ -81,7 +80,7 @@ interface GroupProjection {
 }
 
 /** The scope `formula-palette.json` reads, and the six things a gesture asks of this module. */
-interface FormulaPaletteScope extends Record<string, unknown> {
+interface FormulaPaletteScope {
   open: boolean;
   query: string;
   groups: GroupProjection[];
@@ -106,7 +105,7 @@ interface FormulaPaletteScope extends Record<string, unknown> {
   move: (delta: number) => void;
   activate: () => void;
   hover: (index: number) => void;
-  activateRow: (value: unknown) => void;
+  activateRow: (value: string) => void;
 }
 
 let _open = false;
@@ -228,7 +227,7 @@ function scope(): FormulaPaletteScope {
     },
     open: false,
     query: "",
-  }) as FormulaPaletteScope;
+  });
   return _scope;
 }