@jxsuite/studio 6.1.1 → 6.1.2

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;
 }
 

package/src/surfaces/git-panel.ts

@@ -26,10 +26,9 @@
 import { reactive } from "../reactivity";
 import { mountSurface, registerSurface } from "../ui/surface";
 import gitPanelDoc from "./git-panel.json";
-import type { JxDocument } from "@jxsuite/schema/types";
-import type { SurfaceHandle } from "../ui/surface";
+import type { SurfaceHandle, SurfaceOption } from "../ui/surface";
 
-registerSurface("git-panel", gitPanelDoc as unknown as JxDocument);
+registerSurface("git-panel", gitPanelDoc);
 
 /** One changed file, as the document draws it. Every field is a value: no records, no closures. */
 export interface GitFileRowView {
@@ -72,12 +71,6 @@ export interface GitCommitView {
   meta: string;
 }
 
-/** One row of the branch picker. `__new__` is a row like any other; the flow knows what it means. */
-export interface GitBranchOption {
-  value: string;
-  label: string;
-}
-
 /** What the panel says the surface should be showing right now. */
 export interface GitPanelValues {
   /**
@@ -104,7 +97,7 @@ export interface GitPanelValues {
   branchName: string;
   /** What the picker currently holds. Not always {@link branchName} — see the adapter's note. */
   branchValue: string;
-  branchOptions: GitBranchOption[];
+  branchOptions: SurfaceOption[];
   /** `changes` or `history` — `shell.git.subTab`, which names the `$switch` case. */
   subTab: string;
   /** "Local Changes (6)" — the count is part of the tab's label, not a badge of its own. */
@@ -159,7 +152,7 @@ export interface GitPanelSurfaceHandle {
 }
 
 /** The scope the document reads: the projection, plus everything a control can ask for. */
-interface GitPanelScope extends Record<string, unknown>, GitPanelValues, GitPanelActions {}
+interface GitPanelScope extends GitPanelValues, GitPanelActions {}
 
 /** Write a projection into the scope. Assignment by assignment, so an unchanged field is inert. */
 function project(scope: GitPanelScope, values: GitPanelValues): void {
@@ -237,10 +230,10 @@ export function mountGitPanelSurface(
   values: GitPanelValues,
   actions: GitPanelActions,
 ): GitPanelSurfaceHandle {
-  const scope = reactive<GitPanelScope>({
+  const scope: GitPanelScope = reactive<GitPanelScope>({
     ...emptyValues(),
     ...actions,
-  }) as GitPanelScope;
+  });
   project(scope, values);
 
   let mounted: SurfaceHandle | null = null;
@@ -258,8 +251,7 @@ export function mountGitPanelSurface(
        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/github-auth.ts

@@ -27,13 +27,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 { whenReady } from "./dialog";
 import githubAuthDoc from "./github-auth.json";
-import type { SurfaceHandle } from "../ui/surface";
-import type { JxDocument } from "@jxsuite/schema/types";
+import type { DialogLayerHandle, SurfaceHandle } from "../ui/surface";
 
-registerSurface("github-auth", githubAuthDoc as unknown as JxDocument);
+registerSurface("github-auth", githubAuthDoc);
 
 export interface GithubAuthSurfaceOptions {
   /** Where the dialog is mounted — the dialog layer, handed in so this never reaches back. */
@@ -48,16 +47,7 @@ export interface GithubAuthSurfaceOptions {
   onClosed: () => void;
 }
 
-export interface GithubAuthSurfaceHandle {
-  /** The slot in the dialog layer that carries the region. */
-  host: HTMLElement;
-  /** Resolves with the `jx-dialog` element once it has rendered and been opened. */
-  ready: Promise<HTMLElement>;
-  /** Close the dialog (the platform restores focus) and dispose the document. Idempotent. */
-  close: () => void;
-}
-
-interface GithubAuthScope extends Record<string, unknown> {
+interface GithubAuthScope {
   userCode: string;
   verificationUri: string;
   cancel: () => void;
@@ -65,7 +55,7 @@ interface GithubAuthScope extends Record<string, unknown> {
 }
 
 /** Put the code up. The handle's `ready` resolves once the dialog is showing. */
-export function openGithubAuthSurface(options: GithubAuthSurfaceOptions): GithubAuthSurfaceHandle {
+export function openGithubAuthSurface(options: GithubAuthSurfaceOptions): DialogLayerHandle {
   const slot = document.createElement("div");
   /* The layer is `pointer-events: none` so a click passes through it when nothing is up, and every
      slot in it turns them back on for its own content. `pointer-events` INHERITS, and the top layer
@@ -90,26 +80,32 @@ export function openGithubAuthSurface(options: GithubAuthSurfaceOptions): Github
     closed = true;
     options.onClosed();
   };
+  /* 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;
 
-  const scope = reactive<GithubAuthScope>({
+  const scope: GithubAuthScope = reactive<GithubAuthScope>({
     cancel: () => {
       options.onCancel();
     },
     closed: finish,
     userCode: options.userCode,
     verificationUri: options.verificationUri,
-  }) as GithubAuthScope;
+  });
 
   let mounted: SurfaceHandle | null = null;
   const ready = mountSurface("github-auth", scope, slot).then(async (surface) => {
     mounted = surface;
+    /* SAFETY: `github-auth.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;
     }
     await whenReady(element);
-    if (closed) {
+    if (isClosed()) {
       return element;
     }
     showModal(element);
@@ -125,7 +121,7 @@ export function openGithubAuthSurface(options: GithubAuthSurfaceOptions): Github
       const element = mounted?.root;
       if (element instanceof HTMLElement) {
         // The platform's close first, so focus goes back where it came from; then the document.
-        closeDialog(element);
+        close(element);
       }
       // A mount that has not landed yet is disposed by `ready` when it does — `finish` tells it so.
       mounted?.dispose();