@jxsuite/studio 10.4.0 → 10.6.0

package/src/services/jxn-language.ts

@@ -0,0 +1,110 @@
+/**
+ * Jx Notation in the Code view: a Monarch grammar, with TypeScript inside a multi-line raw string.
+ *
+ * Multi-line raw strings are where a `.jxn` file keeps code (`spec.md` §22.3), so highlighting one
+ * as TypeScript is the common case and not a guess about a particular file.
+ *
+ * @docs framework/concepts/jxn-files
+ */
+
+import type { languages } from "monaco-editor/editor";
+
+/** The language id, as `monacoLangForPath` answers it. */
+export const JXN_LANGUAGE_ID = "jxn";
+
+/** Comments and brackets, which is what typing and folding need to know. */
+export const JXN_LANGUAGE_CONFIGURATION: languages.LanguageConfiguration = {
+  autoClosingPairs: [
+    { close: "}", open: "{" },
+    { close: ")", open: "(" },
+    { close: '"', open: '"' },
+  ],
+  brackets: [
+    ["{", "}"],
+    ["(", ")"],
+  ],
+  comments: { blockComment: ["/*", "*/"], lineComment: "//" },
+};
+
+/** The tokenizer. */
+export const JXN_MONARCH: languages.IMonarchLanguage = {
+  defaultToken: "",
+  // Monarch otherwise starts in the first state listed, and these are sorted.
+  start: "root",
+  tokenizer: {
+    blockComment: [
+      [/[^/*]+/u, "comment"],
+      [/\/\*/u, "comment", "@push"],
+      [/\*\//u, "comment", "@pop"],
+      [/[/*]/u, "comment"],
+    ],
+    quoted: [
+      [/[^\\"]+/u, "string"],
+      [/\\./u, "string.escape"],
+      [/"/u, "string", "@pop"],
+    ],
+    quotedLines: [
+      [/"""/u, "string", "@pop"],
+      [/\\./u, "string.escape"],
+      [/./u, "string"],
+    ],
+    raw: [
+      [/"#+/u, { cases: { "$0==$S2": { next: "@pop", token: "string" }, "@default": "string" } }],
+      [/[^"]+/u, "string"],
+      [/"/u, "string"],
+    ],
+    rawLines: [
+      [
+        /"""#+/u,
+        {
+          cases: {
+            "$0==$S2": { next: "@pop", nextEmbedded: "@pop", token: "string.quote" },
+            "@default": "",
+          },
+        },
+      ],
+      [/[^"]+/u, ""],
+      [/"/u, ""],
+    ],
+    root: [
+      [/\/\/.*$/u, "comment"],
+      [/\/\*/u, "comment", "@blockComment"],
+      [/\/-/u, "comment"],
+      [/\((?:array|fn|object|on|ref)\)/u, "type"],
+      [/\([^)\s]*\)/u, "invalid"],
+      [/#"""/u, { next: '@rawLines."""#', nextEmbedded: "typescript", token: "string.quote" }],
+      [/##+"""/u, { next: '@rawLines."""$0', nextEmbedded: "typescript", token: "string.quote" }],
+      [/#+"/u, { next: '@raw."$0', token: "string" }],
+      [/"""/u, "string", "@quotedLines"],
+      [/"/u, "string", "@quoted"],
+      [/#(?:true|false|null|inf|-inf|nan)\b/u, "keyword"],
+      [/[-+]?\d[\d_]*(?:\.\d[\d_]*)?(?:[eE][-+]?\d+)?/u, "number"],
+      [/[{};]/u, "delimiter"],
+      [/\$[^\s=(){};"]*/u, "keyword"],
+      [/[^\s=(){};"#]+(?==)/u, "attribute.name"],
+      [/[^\s=(){};"#]+/u, "identifier"],
+      [/[=]/u, "delimiter"],
+    ],
+  },
+};
+
+/** The part of Monaco's API registering a language uses. */
+export type MonacoLanguages = Pick<
+  typeof languages,
+  "register" | "setLanguageConfiguration" | "setMonarchTokensProvider"
+>;
+
+/**
+ * Teach Monaco the language.
+ *
+ * @param languages `monaco.languages`. Absent under a double of Monaco that has no language API,
+ *   and there is nothing to teach then.
+ */
+export function registerJxnLanguage(languages?: MonacoLanguages): void {
+  if (!languages) {
+    return;
+  }
+  languages.register({ extensions: [".jxn"], id: JXN_LANGUAGE_ID });
+  languages.setLanguageConfiguration(JXN_LANGUAGE_ID, JXN_LANGUAGE_CONFIGURATION);
+  languages.setMonarchTokensProvider(JXN_LANGUAGE_ID, JXN_MONARCH);
+}

package/src/services/model-uri.ts

@@ -95,6 +95,9 @@ export function monacoLangForPath(path: string): string {
     case "json": {
       return "json";
     }
+    case "jxn": {
+      return "jxn";
+    }
     case "md": {
       return "markdown";
     }

package/src/services/monaco-setup.ts

@@ -35,7 +35,7 @@
  *   schema completion with it.
  */
 
-import "monaco-editor/editor";
+import * as monacoApi from "monaco-editor/editor";
 // Core widget, icons, tokenization.
 import "monaco-editor/features/codeEditor/register";
 import "monaco-editor/features/codicon/register";
@@ -83,6 +83,8 @@ import projectSchema from "@jxsuite/schema/project-schema.json";
 import type { JsonObject } from "@jxsuite/schema/types";
 import type { ProjectSchemasResponse } from "../types";
 import { bundleUrl } from "./bundle-base";
+import { PROJECT_FILE_NAME } from "@jxsuite/schema/project-file";
+import { registerJxnLanguage } from "./jxn-language";
 
 /* Re-exported for the modules that already imported it from here. New callers should reach for
    `./model-uri` directly — it is Monaco-free, and importing this module loads the editor. */
@@ -150,6 +152,8 @@ if (documentFonts?.ready) {
   });
 }
 
+registerJxnLanguage(monacoApi.languages);
+
 /** Folder globs whose JSON files validate against the (per-project or core) document schema. */
 const DOCUMENT_FILE_MATCH = [
   "pages/*.json",
@@ -205,7 +209,7 @@ function applyJsonSchemas(documentSchema: JsonObject, projectJsonSchema: JsonObj
         uri: "https://jxsuite.com/schema/v1",
       },
       {
-        fileMatch: ["project.json"],
+        fileMatch: [PROJECT_FILE_NAME],
         schema: projectJsonSchema,
         uri: "https://jxsuite.com/schema/project/v1",
       },

package/src/services/render-critic.ts

@@ -10,19 +10,41 @@
  * expressions). Does NOT detect empty/zero-node output or deep-render custom element internals
  * (connectedCallback doesn't fire on detached nodes).
  *
+ * A page is drawn as the build would draw it, so a page that builds is not refused for what only
+ * the build supplies: its data is awaited, a dynamic route is drawn with its first entry, and
+ * `$page`, `$site` and project state are injected. Live data is the exception. A `timing: "server"`
+ * function is never called here and a `Request` is never sent (specs/ai.md §3.1), so both read as
+ * placeholders.
+ *
  * @license MIT
+ * @docs studio/ai/document-assistant
  */
 
 import {
   buildScope,
+  lookupsSettled,
   renderNode,
   runScoped,
   setResolveToken,
   setSkipServerFunctions,
   setTemplateErrorHandler,
 } from "@jxsuite/runtime";
-import type { JxDocument } from "@jxsuite/schema/types";
-import { hostResolveToken } from "../canvas/canvas-origin";
+import { isJsonObject, isServerFnDef, isString } from "@jxsuite/schema/guards";
+import { injectContext } from "@jxsuite/site/context";
+import { documentUrlPattern } from "@jxsuite/site/routes";
+import type { JxScope } from "@jxsuite/runtime/types";
+import type { JxDocument, JxMutableNode, JxStateDefinition } from "@jxsuite/schema/types";
+import { documentBase, hostResolveToken } from "../canvas/canvas-origin";
+import { isPagePath, pageContextFor } from "../canvas/canvas-page-context";
+import {
+  dynamicRouteParams,
+  loadParamValues,
+  pagePathsDef,
+  paramBoundStateKeys,
+  substitutePreviewParams,
+} from "../page-params";
+import { projectState } from "../store";
+import type { RenderSource } from "./ai-write-report";
 
 /**
  * Translate a render-time error into an actionable message the model can fix.
@@ -49,39 +71,239 @@ function translateRenderError(cause: unknown): string {
   return `Render error: ${msg}\n  → Fix: The document is schema-valid but fails to render. Review the last change for typos in $ref paths, template expressions, or event handler definitions.`;
 }
 
+/** How long a check waits for a document's data before it stops judging its templates. */
+const LOOKUP_WAIT_MS = 5000;
+
+/**
+ * Wait for the lookups in flight, for at most `waitMs`.
+ *
+ * @param {number} waitMs
+ * @returns {Promise<boolean>} Whether they all settled in time
+ */
+async function lookupsAnswered(waitMs: number): Promise<boolean> {
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  const expired = new Promise<boolean>((answer) => {
+    timer = setTimeout(answer, waitMs, false);
+  });
+  const answered = await Promise.race([lookupsSettled().then(() => true), expired]);
+  clearTimeout(timer);
+  return answered;
+}
+
+/**
+ * What live data reads as during a check: anything may be read from it or called on it, and it
+ * prints as nothing, so a template over live data evaluates and every other template on the page is
+ * still judged.
+ *
+ * `then` and the reactivity library's `__v_` flags read as absent: a truthy `then` would make it a
+ * thenable that never settles, and a truthy `__v_raw` sends `toRaw` round in a circle.
+ *
+ * @returns {() => void}
+ */
+function liveDataPlaceholder(): () => void {
+  const placeholder: () => void = new Proxy(() => placeholder, {
+    get(_target, key) {
+      if (key === Symbol.toPrimitive) {
+        return () => "";
+      }
+      if (key === Symbol.iterator) {
+        return Array.prototype[Symbol.iterator].bind([]);
+      }
+      return isString(key) && key !== "then" && !key.startsWith("__v_") ? placeholder : undefined;
+    },
+  });
+  return placeholder;
+}
+
+/** Whether an entry's value is live data, which only a person's own action may fetch. */
+function isLiveData(entry: JxStateDefinition): boolean {
+  return (
+    isServerFnDef(entry) ||
+    (isJsonObject(entry) && entry.$prototype === "Request" && !isString(entry.$src))
+  );
+}
+
+/**
+ * The class entry a template reads that came back with no data, if it reads one. The template is
+ * what connects them: an unrelated broken template beside a failed lookup is still its own
+ * mistake.
+ *
+ * @param {JxDocument} built
+ * @param {JxScope} state
+ * @param {string} template
+ * @returns {{ key: string; from: string } | null}
+ */
+function emptyLookupRead(
+  built: JxDocument,
+  state: JxScope,
+  template: string,
+): { key: string; from: string } | null {
+  const reads = new Set(template.match(/state\.[\w$]+/g));
+  for (const [key, entry] of Object.entries(built.state ?? {})) {
+    if (
+      reads.has(`state.${key}`) &&
+      isJsonObject(entry) &&
+      isString(entry.$prototype) &&
+      entry.$prototype !== "Function" &&
+      (state[key] ?? null) === null
+    ) {
+      return { from: isString(entry.$src) ? entry.$src : entry.$prototype, key };
+    }
+  }
+  return null;
+}
+
+/**
+ * The first entry of each route parameter a document declares, as the preview picker opens with.
+ *
+ * @param {JxDocument} doc
+ * @param {RenderSource} source
+ * @returns {Promise<Record<string, string>>}
+ */
+async function sampleRouteParams(
+  doc: JxMutableNode,
+  { documentPath, frontmatter }: RenderSource,
+): Promise<Record<string, string>> {
+  const paths = pagePathsDef({ document: doc, frontmatter: frontmatter ?? null });
+  const params: Record<string, string> = {};
+  for (const [name, values] of Object.entries(await loadParamValues(documentPath, paths))) {
+    const [first] = values;
+    if (first !== undefined) {
+      params[name] = first;
+    }
+  }
+  return params;
+}
+
+/**
+ * A document as the build would hand it to the renderer. A rebuild: the document may be the live
+ * tree of an open tab, which must not gain keys it would then save.
+ *
+ * @param {JxDocument} doc
+ * @param {RenderSource} source
+ * @returns {Promise<{ built: JxDocument; sampled: boolean }>} `sampled` is false when a route
+ *   parameter has no entry to stand for it, so the data its templates read cannot be looked up
+ */
+async function asBuilt(
+  doc: JxDocument,
+  source: RenderSource,
+): Promise<{ built: JxDocument; sampled: boolean }> {
+  const { documentPath } = source;
+  /* SAFETY: a candidate is a JSON tree, and everything below rebuilds it rather than writing to it,
+     so the mutable type is only what these shared helpers are declared over. */
+  const candidate = doc as JxMutableNode;
+  const params = await sampleRouteParams(candidate, source);
+  let built = substitutePreviewParams(candidate, params, documentPath);
+
+  const projectConfig = projectState?.projectConfig;
+  const drawnAsPage =
+    documentPath && (isPagePath(documentPath) || documentPath.startsWith("layouts/"));
+  if (drawnAsPage && projectConfig && projectState?.isSiteProject) {
+    built = { ...built, state: { ...built.state } };
+    if (built.imports) {
+      built.imports = { ...built.imports };
+    }
+    /* SAFETY: as on the canvas: `injectContext` writes `state`, `$media` and `imports`, all of which
+       the copy above owns. */
+    injectContext(built as JxDocument, projectConfig, {
+      urlPattern: documentUrlPattern(documentPath),
+    });
+    const context = await pageContextFor(
+      { documentPath, isEntry: false, lang: doc.$lang, params, title: doc.title },
+      projectConfig,
+    );
+    if (context) {
+      built = { ...built, state: { ...built.state, ...context } };
+    }
+  }
+
+  const sampled =
+    dynamicRouteParams(documentPath).every((name) => name in params) &&
+    paramBoundStateKeys(built.state ?? null).length === 0;
+  /* SAFETY: the same document, rebuilt member for member; its schema has not changed. */
+  return { built: built as JxDocument, sampled };
+}
+
+/**
+ * The URL a document's relative references resolve from, when one can be formed. A check is not
+ * failed for lacking one: a document with no relative reference does not need it.
+ *
+ * @param {RenderSource} source
+ * @returns {string | undefined}
+ */
+function baseOf({ documentPath }: RenderSource): string | undefined {
+  const base = documentBase(projectState?.projectRoot);
+  return documentPath && URL.canParse(base) ? new URL(documentPath, base).href : undefined;
+}
+
 /**
  * Attempt a detached render of a Jx document. Returns { ok: true } on success or { ok: false,
  * error: string } with an actionable message on failure.
  *
  * @param {import("@jxsuite/schema/types").JxDocument} doc
+ * @param {RenderSource} [source] - Where the document lives, when it lives anywhere yet
+ * @param {number} [waitMs] - How long to wait for the document's data
  * @returns {Promise<{ ok: true } | { ok: false; error: string }>}
  */
 export async function renderCheck(
   doc: JxDocument,
+  source: RenderSource = {},
+  waitMs = LOOKUP_WAIT_MS,
 ): Promise<{ ok: true } | { ok: false; error: string }> {
   let stopRender: (() => void) | null = null;
-  /* A binding that throws no longer unwinds the render (spec.md §6.1) — it renders empty and waits
-     for its data — so the throw is collected here instead. The first one is the verdict: a page
-     whose template can never evaluate is exactly what this check exists to refuse. */
-  const bindingErrors: Error[] = [];
-  setTemplateErrorHandler((error) => {
-    bindingErrors.push(error);
-  });
   try {
     setSkipServerFunctions(true);
     // The desktop dev proxy refuses a class resolve without the token the canvas carries.
     setResolveToken(hostResolveToken());
 
-    const state = await buildScope(doc, {});
+    const { built, sampled } = await asBuilt(doc, source);
+    const base = baseOf(source) ?? location.href;
+    /* This call's own context rather than `setSkipAutoRequests`, which is realm-wide: a Library
+       preview draws in this same realm, and would silently stop fetching. */
+    const state = await buildScope(built, {}, base, {
+      base,
+      media: null,
+      root: null,
+      skipAutoRequests: true,
+    });
+    for (const [key, entry] of Object.entries(built.state ?? {})) {
+      if (isLiveData(entry)) {
+        state[key] = liveDataPlaceholder();
+      }
+    }
+
+    /* The build resolves a page's data before its templates run, and here the data is a lookup that
+       has only just started. Rendering now would read `null` and refuse a page that builds. */
+    const answered = await lookupsAnswered(waitMs);
+
+    /* A binding that throws no longer unwinds the render (spec.md §6.1) — it renders empty and
+       waits for its data — so the throw is collected here instead. The first one is the verdict: a
+       page whose template can never evaluate is exactly what this check exists to refuse. Only for
+       the synchronous render: anything else this realm draws during the wait is not this document. */
+    const bindingErrors: { error: Error; template: string }[] = [];
+    setTemplateErrorHandler((error, template) => {
+      bindingErrors.push({ error, template });
+    });
 
     const container = document.createElement("div");
     const { stop } = runScoped(() => {
-      container.append(renderNode(doc, state));
+      container.append(renderNode(built, state));
     });
     stopRender = stop;
 
+    /* With a lookup still out, or no entry to look up, a throw may be nothing but the data being
+       absent, and refusing would block a valid write. A live binding recovers if that is what it was. */
     const [first] = bindingErrors;
-    return first ? { ok: false, error: translateRenderError(first) } : { ok: true };
+    if (!first || !answered || !sampled) {
+      return { ok: true };
+    }
+    const empty = emptyLookupRead(built, state, first.template);
+    return {
+      error: empty
+        ? `Render error: ${first.error.message}\n  → Fix: state.${empty.key} has no data: its lookup through ${empty.from} failed or came back empty, so this template has nothing to read. Check that $src and the entry's config. If the data can legitimately be empty, guard the read, for example state.${empty.key}?.name.`
+        : translateRenderError(first.error),
+      ok: false,
+    };
   } catch (error) {
     return { ok: false, error: translateRenderError(error) };
   } finally {

package/src/services/tool-executor.ts

@@ -22,15 +22,15 @@
 import type { InteractionStore } from "./harness/interaction-store";
 import type { createChatState } from "@jxsuite/ai/chat-state";
 import { DEFAULT_TURN_POLICY, assistantActorId, runTurn } from "@jxsuite/ai/harness";
-import type { TurnInput, TurnRun } from "@jxsuite/ai/harness";
-import { toChatMessages, toOpenAITools } from "@jxsuite/ai/messages";
+import type { TurnInput, TurnPolicy, TurnRun } from "@jxsuite/ai/harness";
+import { toChatMessages, toOpenAIMessages, toOpenAITools } from "@jxsuite/ai/messages";
 import type { StreamingClient } from "@jxsuite/ai/streaming-client";
 import { createSessionFacts } from "@jxsuite/ai/tools";
 import type { SessionFacts, ToolRegistry } from "@jxsuite/ai/tools";
 
 import type { Tab } from "../tabs/tab";
 import { openBatchLane } from "../tabs/transact";
-import { estimatePromptTokens } from "./context-manager";
+import { estimatePromptTokens, shedToolResults } from "./context-manager";
 import { fileTurn, openTurnLedger, turnAnchor } from "./ai-writes";
 import { applyHarnessEvent } from "./harness/chat-reducer";
 import { studioTurnHooks } from "./harness/turn-hooks";
@@ -52,6 +52,8 @@ interface RunAgentLoopOptions {
   session?: SessionFacts;
   /** Where a call that needs the author waits on them. Without one, such a call is refused. */
   interactions?: InteractionStore;
+  /** Overrides on Studio's policy, for a run with bounds of its own. */
+  policy?: Partial<TurnPolicy>;
 }
 
 /**
@@ -67,6 +69,7 @@ export async function runAgentLoop({
   getTab,
   session = createSessionFacts(),
   interactions,
+  policy,
 }: RunAgentLoopOptions): Promise<void> {
   /* The ledger is filed under the turn's last DRAWN assistant message (see services/ai-writes), so
      the scan starts at the message this turn answers. */
@@ -103,9 +106,13 @@ export async function runAgentLoop({
       system: [{ text: systemPrompt }],
       /* Projected from the chat store, the transcript of record. The streaming client is read on
          every round, and the turn's own signal is the host's, so a request is the one it was. */
-      model: (request) =>
-        streamingClient.streamChat(
-          chatState.toMessagesArray(),
+      model: (request) => {
+        /* A long turn must not outgrow the window between two sends: the trim only runs at a send. */
+        shedToolResults(chatState, systemPrompt);
+        const messages = chatState.toMessagesArray();
+        return streamingClient.streamChat(
+          /* A closing round's note is on no transcript, so it joins here, for this request only. */
+          request.closing ? [...messages, ...toOpenAIMessages([request.closing])] : messages,
           toOpenAITools(request.tools),
           systemPrompt,
           /* SAFETY: the one production caller, `document-assistant.ts`, always passes its turn
@@ -113,11 +120,12 @@ export async function runAgentLoop({
              doubles record the absent signal rather than reading it — which the agent-trace
              goldens (`signal: "none"`) pin. */
           signal as AbortSignal,
-        ),
+        );
+      },
       modelInfo: { family: "openai-compat", model: chatState.model },
       tools: toolRegistry,
       turnId: ledger.turnId,
-      policy: { estimateTokens: estimatePromptTokens },
+      policy: { estimateTokens: estimatePromptTokens, parallelReadOnly: true, ...policy },
       hooks: studioTurnHooks({
         superseded: () =>
           turnUserId !== undefined && !chatState.messages.some((m) => m.id === turnUserId),

package/src/settings/contributed-section.ts

@@ -61,6 +61,7 @@ import type {
   ContributedSurfaceHandle,
   ContributedView,
 } from "../surfaces/settings-contributed";
+import { projectConfigPath } from "../tabs/tab";
 
 // ─── Contribution shape ───────────────────────────────────────────────────────
 
@@ -258,7 +259,7 @@ async function saveProjectConfig(base: string, rerender: () => void) {
        fault, so it is a problem of its own rather than an error parked on the user's field. */
     notify.warn(`Could not validate project.json — ${errorMessage(error)}`, {
       key: "settings:validator",
-      path: "project.json",
+      path: projectConfigPath(),
       source: "Settings",
       tier: "problem",
     });

package/src/settings/extension-commands.ts

@@ -43,6 +43,7 @@ import { notify } from "../services/notify";
 import { notifySettingsDocument } from "./section-registry";
 import { updateSiteConfig } from "../site-context";
 import type { AnyCommand, CommandRegistry } from "../commands/registry";
+import { projectConfigPath } from "../tabs/tab";
 
 /** The package an extension operation is running for, or null. */
 let _inFlight: string | null = null;
@@ -168,7 +169,7 @@ export async function enableExtension(specifier: string): Promise<void> {
     }
     await updateSiteConfig({ extensions: [...enabledSpecifiers(), row.specifier] });
     /* Set after the write resolved, so the latch never claims a file the write did not reach. */
-    _lastEnableWrote = installed ? ["project.json", "package.json"] : ["project.json"];
+    _lastEnableWrote = installed ? [projectConfigPath(), "package.json"] : [projectConfigPath()];
   } finally {
     _inFlight = null;
     notifySettingsDocument();

package/src/settings/general-settings.ts

@@ -25,7 +25,7 @@ import { runActiveReported } from "../commands/run-reported";
 import { getPlatform } from "../platform";
 import { mountOverviewSurface } from "../surfaces/settings-overview";
 import { previewAssetSrcFor } from "../canvas/asset-refs";
-import { PROJECT_CONFIG_PATH } from "../tabs/tab";
+import { projectConfigPath } from "../tabs/tab";
 
 import type {
   OverviewActions,
@@ -191,7 +191,7 @@ function values(container: HTMLElement): OverviewValues {
     error: errors.get(container) ?? null,
     favicon: readFavicon(cfg),
     // `project.json` authored it, whatever tab is in front: the section is project-level.
-    faviconSrc: previewAssetSrcFor(readFavicon(cfg), PROJECT_CONFIG_PATH),
+    faviconSrc: previewAssetSrcFor(readFavicon(cfg), projectConfigPath()),
     name: cfg.name ?? "",
     stylesDisabled: command === undefined,
     stylesTitle: command?.title ?? "",

package/src/settings/settings-document.ts

@@ -29,7 +29,7 @@ import {
 } from "../commands/command-args";
 import { notify } from "../services/notify";
 import { projectState } from "../state";
-import { PROJECT_CONFIG_PATH } from "../tabs/tab";
+import { projectConfigPath } from "../tabs/tab";
 import { lendProjectConfigLayout } from "../tabs/project-config";
 import { focusPane, openTab, paneOfTab, workspace } from "../workspace/workspace";
 import { workspaceHomeTabId } from "../workspace/workspace-ids";
@@ -211,7 +211,7 @@ export function showSettingsDocument(mode: string = shell.stylebook.view): Tab |
     return null;
   }
   rememberStylesView(mode);
-  const existing = workspace.tabs.get(PROJECT_CONFIG_PATH);
+  const existing = workspace.tabs.get(projectConfigPath());
   if (existing) {
     for (const candidate of PROJECT_TAB_MODES.toReversed()) {
       if (!existing.capabilities.modes.includes(candidate)) {
@@ -225,8 +225,8 @@ export function showSettingsDocument(mode: string = shell.stylebook.view): Tab |
   const tab = openTab({
     capabilities: { modes: [...PROJECT_TAB_MODES] },
     document: state.projectConfig ?? {},
-    documentPath: PROJECT_CONFIG_PATH,
-    id: PROJECT_CONFIG_PATH,
+    documentPath: projectConfigPath(),
+    id: projectConfigPath(),
   });
   /* The mode is written here rather than left to the capability list, because `createTab` seeds
      `session.ui.canvasMode` from the first non-preview mode, and a door over the same document has
@@ -303,7 +303,7 @@ export async function openProjectSettings(section?: string): Promise<void> {
        Problem rather than a toast that erases itself. */
     notify.warn(`Could not load extension settings sections — ${errorMessage(error)}`, {
       key: "settings:sections",
-      path: PROJECT_CONFIG_PATH,
+      path: projectConfigPath(),
       source: "Settings",
       tier: "problem",
     });

package/src/shell.ts

@@ -102,10 +102,10 @@ export const NAVIGATOR_PANEL_IDS = [
   "files",
   "search",
   "i18n",
+  "insert",
   "layers",
   "data",
   "packages",
-  "insert",
 ] as const;
 
 export type NavigatorPanelId = (typeof NAVIGATOR_PANEL_IDS)[number];