@jxsuite/studio 10.5.0 → 10.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jxsuite/studio",
-  "version": "10.5.0",
+  "version": "10.6.0",
   "description": "Jx Studio — visual builder for Jx documents",
   "license": "MIT",
   "repository": {
@@ -47,7 +47,7 @@
   "scripts": {
     "build": "bun run scripts/build.ts",
     "build:metafile": "bun build ./src/studio.ts --outdir dist-metafile --target browser --sourcemap=linked --metafile=metafile.json",
-    "gen:webdata": "bun run scripts/gen-webdata.js",
+    "gen:webdata": "bun run scripts/gen-webdata.ts",
     "eval": "bun run evals/cli.ts",
     "eval:headless": "bun run tests/harness/run-eval.ts",
     "lint:styles": "bun run scripts/check-styles.ts",
@@ -60,16 +60,16 @@
   "dependencies": {
     "@atlaskit/pragmatic-drag-and-drop": "^4.0.0",
     "@atlaskit/pragmatic-drag-and-drop-hitbox": "^3.0.0",
-    "@jxsuite/ai": "^0.43.0",
-    "@jxsuite/collab": "^0.11.6",
-    "@jxsuite/create": "^1.5.4",
-    "@jxsuite/formulas": "^0.0.28",
-    "@jxsuite/markup": "^1.0.4",
-    "@jxsuite/protocol": "^6.2.2",
-    "@jxsuite/runtime": "^6.1.0",
-    "@jxsuite/schema": "^5.2.0",
-    "@jxsuite/site": "^2.3.1",
-    "@jxsuite/ui": "^0.10.1",
+    "@jxsuite/ai": "^0.43.1",
+    "@jxsuite/collab": "^0.11.7",
+    "@jxsuite/create": "^1.5.5",
+    "@jxsuite/formulas": "^0.0.29",
+    "@jxsuite/markup": "^1.0.5",
+    "@jxsuite/protocol": "^6.2.3",
+    "@jxsuite/runtime": "^6.2.0",
+    "@jxsuite/schema": "^5.3.0",
+    "@jxsuite/site": "^2.4.0",
+    "@jxsuite/ui": "^0.10.2",
     "@vue/reactivity": "3.5.44",
     "ajv": "^8.20.0",
     "ajv-formats": "^3.0.1",

package/src/browse/preview-style.ts

@@ -27,6 +27,7 @@ import { isFunction, isNonNullObject, isString } from "@jxsuite/schema/guards";
 import { previewAssetSrcFor } from "../canvas/asset-refs";
 import { projectState } from "../store";
 import type { JxHeadEntry, ProjectConfig } from "@jxsuite/schema/types";
+import { PROJECT_FILE_NAME } from "@jxsuite/schema/project-file";
 
 /** The preview box, as a project sheet names the page's root and body inside a shadow root. */
 const HOST_ROOTS = { body: ":host", root: ":host" };
@@ -93,7 +94,7 @@ export function headStylesheetHrefs(head: readonly JxHeadEntry[] | undefined): s
 
 /** One linked stylesheet as a preview sheet, or null when it cannot be read. */
 async function linkedSheet(href: string): Promise<CSSStyleSheet | null> {
-  const url = previewAssetSrcFor(href, "project.json");
+  const url = previewAssetSrcFor(href, PROJECT_FILE_NAME);
   try {
     const response = await fetch(url);
     if (!response.ok) {

package/src/canvas/canvas-render.ts

@@ -175,8 +175,13 @@ export function initCanvasRender(ctx: CanvasRenderCtx) {
  */
 function sourceLang(tab: Tab) {
   const format = formatByName(tab.doc.sourceFormat);
+  if (!format) {
+    return "json";
+  }
   // The essence: splitting the declared type would yield `markdown; variant=GFM` as a language id.
-  return format ? (mediaTypeEssence(format.mediaType)?.split("/").pop() ?? "plaintext") : "json";
+  const fromType = mediaTypeEssence(format.mediaType)?.split("/").pop();
+  // `.jxn` has no media type to read a language from, and its path says everything it needs to.
+  return fromType ?? monacoLangForPath(tab.documentPath ?? "");
 }
 
 /**

package/src/canvas/iframe-drop.ts

@@ -16,7 +16,7 @@
  * preview is display-only and never the source of truth (patch-mid-drag safety).
  */
 
-import { parseJxPath } from "./path-mapping";
+import { parseJxPath, serializeJxPath } from "./path-mapping";
 import { displayTagName, isNonNullObject } from "@jxsuite/schema/guards";
 import { rectOf, elementAtPoint } from "../utils/geometry";
 import { getNodeAtPath, isAncestor, pathsEqual } from "../state";
@@ -161,6 +161,89 @@ export function resolveDropTarget(x: number, y: number, doc: Document): HTMLElem
   return nearestPathEl(hit);
 }
 
+/**
+ * The drop for a cursor over blank canvas: a point under no addressable node and outside a layout's
+ * chrome.
+ *
+ * **The canvas around the content is part of the page** (§5.3). A short page fills the top of a
+ * frame whose remainder is the body, or the unstamped layout node its blocks are drawn into, and
+ * that blank space is exactly where an author drags a new block. The drop goes to the nearest edge
+ * of the page's own top-level blocks, so below the content it lands after the last one. Layout
+ * chrome (`data-jx-layout-region`, the site header and footer a page is drawn inside) is not the
+ * page, so a drop over it resolves to nothing, as a click there edits nothing.
+ *
+ * Two shapes reach here. Without a layout the root is an element (`data-jx-path="[]"`) and the root
+ * branch of {@link computeDropInstruction} already answers. Inside a layout the page root has no
+ * element of its own (its children are drawn into the layout's slot), so its blocks are found by
+ * their stamped paths, and each keeps its own path as the target, which a text child of the root
+ * would otherwise shift.
+ */
+export function resolveBlankCanvasDrop(
+  x: number,
+  y: number,
+  doc: Document,
+  shadowDoc: JxMutableNode,
+  src: DragSrcKind,
+): DropPreview | null {
+  const hit = elementAtPoint(x, y, doc);
+  if (!hit || nearestPathEl(hit) || hit.closest("[data-jx-layout-region]")) {
+    return null;
+  }
+  const root = doc.querySelector<HTMLElement>(`[data-jx-path="${serializeJxPath([])}"]`);
+  if (root) {
+    return computeDropInstruction(root, y, shadowDoc, src);
+  }
+  const blocks = [...doc.querySelectorAll<HTMLElement>("[data-jx-path]")].filter(
+    (el) => parseJxPath(el.dataset.jxPath ?? "").length === 2,
+  );
+  const [first, ...rest] = blocks;
+  if (!first) {
+    return canDrop(src, [])
+      ? { edge: "inside", instruction: "make-child", referenceRect: rectFor(hit), targetPath: [] }
+      : null;
+  }
+  return nearestBlockEdge(first, rest, y, src);
+}
+
+/** How far `cursorY` is from `block`, and whether its bottom edge is the nearer one. */
+function blockEdge(block: HTMLElement, cursorY: number) {
+  const rect = rectFor(block);
+  const above = Math.abs(cursorY - rect.y);
+  const below = Math.abs(cursorY - (rect.y + rect.height));
+  return { below: below <= above, block, distance: Math.min(above, below) };
+}
+
+/**
+ * {@link nearestChildEdge} over blocks that carry their own paths, for a root with no element. The
+ * first block is passed apart from the rest because an empty page is the caller's to answer.
+ */
+function nearestBlockEdge(
+  first: HTMLElement,
+  rest: readonly HTMLElement[],
+  cursorY: number,
+  src: DragSrcKind,
+): DropPreview | null {
+  let best = blockEdge(first, cursorY);
+  for (const block of rest) {
+    const edge = blockEdge(block, cursorY);
+    if (edge.distance < best.distance) {
+      best = edge;
+    }
+  }
+  const targetPath = parseJxPath(best.block.dataset.jxPath ?? "");
+  if (!canDrop(src, targetPath)) {
+    return null;
+  }
+  return best.below
+    ? {
+        edge: "bottom",
+        instruction: "reorder-below",
+        referenceRect: rectFor(best.block),
+        targetPath,
+      }
+    : { edge: "top", instruction: "reorder-above", referenceRect: rectFor(best.block), targetPath };
+}
+
 /**
  * Compute the structural drop placement for a cursor over `targetEl`, PURE against iframe-realm
  * rects.

package/src/canvas/iframe-entry.ts

@@ -24,6 +24,7 @@ import { parseJxPath, serializeJxPath } from "./path-mapping";
 import {
   AUTO_SCROLL_STEP,
   computeDropInstruction,
+  resolveBlankCanvasDrop,
   rectFor,
   resolveDropTarget,
   scrollDirection,
@@ -107,8 +108,9 @@ setNpmModuleResolver((specifier) => npmModuleUrl(specifier, location.href));
 
 /**
  * Resolve the drop placement for a forwarded cursor: point hit-test → nearest `[data-jx-path]` →
- * pure {@link computeDropInstruction}. Returns null when the cursor resolves to no droppable target.
- * Shared by the `dragMove` (display-only preview) and `drop` (fresh, authoritative) handlers.
+ * pure {@link computeDropInstruction}, or, over blank canvas, {@link resolveBlankCanvasDrop}. Returns
+ * null when the cursor resolves to no droppable target (a layout's chrome). Shared by the
+ * `dragMove` (display-only preview) and `drop` (fresh, authoritative) handlers.
  */
 function previewAt(
   cursor: { x: number; y: number },
@@ -118,7 +120,7 @@ function previewAt(
 ) {
   const targetEl = resolveDropTarget(cursor.x, cursor.y, doc);
   if (!targetEl) {
-    return null;
+    return resolveBlankCanvasDrop(cursor.x, cursor.y, doc, shadowDoc, src);
   }
   return computeDropInstruction(targetEl, cursor.y, shadowDoc, src);
 }
@@ -703,10 +705,11 @@ export function startCanvasIframe(opts: {
     const doc = container.ownerDocument;
     const targetEl = resolveDropTarget(cursor.x, cursor.y, doc);
     const hit = targetEl ? fileDropHitFor(targetEl, shadowDoc) : null;
-    const preview =
-      shadowDoc && targetEl
+    const preview = shadowDoc
+      ? targetEl
         ? computeDropInstruction(targetEl, cursor.y, shadowDoc, FILE_DRAG_SRC)
-        : null;
+        : resolveBlankCanvasDrop(cursor.x, cursor.y, doc, shadowDoc, FILE_DRAG_SRC)
+      : null;
     if (kind === "fileDragOver") {
       if (e.dataTransfer) {
         e.dataTransfer.dropEffect = "copy";

package/src/canvas/iframe-render.ts

@@ -24,6 +24,7 @@ import {
   setCanvasDelinkCommands,
   setCanvasDelinkPopovers,
   setCanvasViewportTranspose,
+  setDocumentParser,
   setRootMedia,
   setSkipAutoRequests,
   setSkipServerFunctions,
@@ -43,6 +44,17 @@ import { isNonNullObject, isString } from "@jxsuite/schema/guards";
 import type { JxDocument, JxElement, JxStyle } from "@jxsuite/schema/types";
 import type { PathMapCtx } from "./path-mapping";
 
+/**
+ * Read a `.jxn` `$ref`, which the editing server answers as its text.
+ *
+ * Loaded when one turns up, because the parser is a third of this entry's size budget and most
+ * canvases never see a `.jxn` reference.
+ */
+async function parseDocumentText(text: string, source: string): Promise<JxDocument> {
+  const { parseJxn } = await import("@jxsuite/schema/jxn");
+  return parseJxn(text, source);
+}
+
 /**
  * The retained render context a full render leaves behind so the surgical patcher can re-render an
  * individual subtree (insert/replace/attr edits) with the SAME scope, doc base, path mapping, and
@@ -1070,6 +1082,7 @@ export async function renderResolvedDocument(opts: {
   const assets = opts.assets ?? null;
   setCanvasAssetResolver(assets ? (value) => resolveAssetRef(value, assets) : null);
   setSkipServerFunctions(opts.mode !== "preview");
+  setDocumentParser(parseDocumentText);
   // Same gate for automatic `$prototype: "Request"` state entries. `buildScope` re-resolves every
   // State entry on each full render, so without this an escalating authoring action (a signals-panel
   // Edit, or Enter inside component-wrapped content) issued an HTTP request per render. Edit/design

package/src/collab/collab-session.ts

@@ -33,7 +33,7 @@ import {
   setTransactObserver,
   transactDoc,
 } from "../tabs/transact";
-import { PROJECT_CONFIG_PATH } from "../tabs/tab";
+import { isProjectConfigPath } from "../tabs/tab";
 import type { TransactOrigin } from "../tabs/transact";
 import type { TransactionRecord } from "../tabs/patch-ops";
 import type { Tab } from "../tabs/tab";
@@ -672,7 +672,7 @@ const liveTabs = new Set<Tab>();
  */
 export function ensureCollab(tab: Tab): void {
   const platform = maybePlatform();
-  if (!platform?.collab || !tab.documentPath || tab.documentPath === PROJECT_CONFIG_PATH) {
+  if (!platform?.collab || !tab.documentPath || isProjectConfigPath(tab.documentPath)) {
     return;
   }
   const runtime = runtimeFor(tab);

package/src/commands/levels.ts

@@ -180,7 +180,7 @@ export const PANEL_PLACEMENT_MATRIX: Readonly<Record<PanelPlacement, PlacementRu
   },
   "rail/document": {
     admits: ["document"],
-    note: "the rail's lower group — Outline, Data, and Packages with the developer panels on",
+    note: "the rail's lower group — Insert, Outline, Data, and Packages with the developer panels on",
   },
   navigator: {
     admits: ["project", "document"],

package/src/create/add-new-flow.ts

@@ -101,6 +101,7 @@ import type {
   AddNewView,
 } from "../surfaces/add-new";
 import type { JsonObject, JxMutableNode } from "@jxsuite/schema/types";
+import { projectConfigPath } from "../tabs/tab";
 
 /** The `source` every Problem this flow files carries. */
 const SOURCE = "Add new";
@@ -385,7 +386,7 @@ async function performCollection(creation: Creation): Promise<AddNewResult | nul
   if (!committed.ok) {
     return null;
   }
-  const wrote = ["project.json"];
+  const wrote = [projectConfigPath()];
   const missed: string[] = [];
   for (const write of [{ body: creation.content, path: creation.path }, ...creation.extraWrites]) {
     try {

package/src/editor/convert-targets.ts

@@ -1,32 +1,11 @@
 import elementsMeta from "../../data/elements-meta.json";
 
+import { elementName } from "../locale/element-names";
 import { ELEMENT_DEFS } from "./editable-tags";
 import type { SlashCommand } from "./inline-edit";
 
 export type { SlashCommand } from "./inline-edit";
 
-const TAG_LABELS = new Map<string, string>([
-  ["article", "Article"],
-  ["aside", "Aside"],
-  ["blockquote", "Blockquote"],
-  ["div", "Div"],
-  ["footer", "Footer"],
-  ["h1", "Heading 1"],
-  ["h2", "Heading 2"],
-  ["h3", "Heading 3"],
-  ["h4", "Heading 4"],
-  ["h5", "Heading 5"],
-  ["h6", "Heading 6"],
-  ["header", "Header"],
-  ["main", "Main"],
-  ["nav", "Nav"],
-  ["ol", "Numbered List"],
-  ["p", "Paragraph"],
-  ["search", "Search"],
-  ["section", "Section"],
-  ["ul", "Bulleted List"],
-]);
-
 const groups: Readonly<Record<string, string[]>> = elementsMeta.$convertGroups;
 
 /**
@@ -56,7 +35,7 @@ export function getConvertTargets(currentTag: string, isEmpty: boolean): SlashCo
 
   return [...tags].map((tag) => ({
     description: "",
-    label: TAG_LABELS.get(tag) || tag.charAt(0).toUpperCase() + tag.slice(1),
+    label: elementName(tag),
     tag,
   }));
 }

package/src/editor/slash-menu.ts

@@ -28,6 +28,7 @@
 
 import { openSlashMenuSurface } from "../surfaces/slash-menu";
 import { componentSlashCommands } from "./insert-component";
+import { elementName } from "../locale/element-names";
 import { rectOf } from "../utils/geometry";
 import type {
   SlashMenuGroup,
@@ -39,24 +40,41 @@ import type { SlashCommand } from "./inline-edit";
 
 // ─── Commands ─────────────────────────────────────────────────────────────────
 
-const SLASH_COMMANDS = [
-  { description: "Large heading", label: "Heading 1", tag: "h1" },
-  { description: "Medium heading", label: "Heading 2", tag: "h2" },
-  { description: "Small heading", label: "Heading 3", tag: "h3" },
-  { description: "Plain text", label: "Paragraph", tag: "p" },
-  { description: "Unordered list", label: "Bulleted List", tag: "ul" },
-  { description: "Numbered list", label: "Numbered List", tag: "ol" },
-  { description: "Quote block", label: "Blockquote", tag: "blockquote" },
-  { description: "Insert image", label: "Image", tag: "img" },
-  { description: "Divider line", label: "Horizontal Rule", tag: "hr" },
-  { description: "Button element", label: "Button", tag: "button" },
-  { description: "Anchor link", label: "Link", tag: "a" },
-  { description: "Preformatted code", label: "Code Block", tag: "pre" },
-  { description: "Insert table", label: "Table", tag: "table" },
-  { description: "Container", label: "Div", tag: "div" },
-  { description: "Section container", label: "Section", tag: "section" },
+/**
+ * The HTML elements the slash menu offers, in this order. Each row's label is the element's name in
+ * the locale catalog (`locale/element-names.ts`), so the menu, the Insert palette and the convert
+ * menu call an element the same thing in every language. A row carries no description: the
+ * catalog's are sentences, written for the palette's tooltips, and a menu row draws its description
+ * on the label's own line and cuts it off there, while a name like "Bulleted list" already says
+ * what the row inserts.
+ */
+const SLASH_TAGS = [
+  "h1",
+  "h2",
+  "h3",
+  "p",
+  "ul",
+  "ol",
+  "blockquote",
+  "img",
+  "hr",
+  "button",
+  "a",
+  "pre",
+  "table",
+  "div",
+  "section",
 ];
 
+/** The element rows, named in the reader's language at the moment the menu opens. */
+function elementCommands(): SlashCommand[] {
+  return SLASH_TAGS.map((tag) => ({
+    description: "",
+    label: elementName(tag),
+    tag,
+  }));
+}
+
 // ─── State ────────────────────────────────────────────────────────────────────
 
 /** Callbacks a caller passes to {@link showSlashMenu}/{@link showSlashMenuAtRect}. */
@@ -127,7 +145,7 @@ export function showSlashMenuAtRect(
  * on offer.
  */
 function standardCommands(): SlashCommand[] {
-  return [...SLASH_COMMANDS, ...componentSlashCommands()];
+  return [...elementCommands(), ...componentSlashCommands()];
 }
 
 /** Everything on offer right now: what the caller named, or the standard set. */

package/src/files/files.ts

@@ -286,6 +286,24 @@ export async function loadProject() {
   }
 }
 
+/**
+ * Show the documents the operating system asks of this window, now and from here on.
+ *
+ * Called once the window has finished loading whatever it holds, so a document opens on top of the
+ * restored session rather than being replaced by it. Called whether or not there is a project yet,
+ * because a welcome window can be given one later and then be asked for a document in it.
+ */
+export function followOpenDocuments(): void {
+  getPlatform().subscribeOpenDocument?.((path) => {
+    // A window whose project did not load has been told why, and has nowhere to put a tab.
+    if (!projectState) {
+      return;
+    }
+    // It reports its own failure ("Could not open …"), as it does for every other caller.
+    void openFileInTab(path);
+  });
+}
+
 // ─── Open Project (PAL-based) ─────────────────────────────────────────────
 
 /**

package/src/format/format-choices.ts

@@ -69,11 +69,11 @@ function declaresDocumentKind(kinds: readonly string[]): boolean {
 /**
  * Whether this path is (or is used as) a layout.
  *
- * Layouts are JSON at BOTH readers — `packages/compiler/src/site/layout-resolver.ts` `JSON.parse`s
- * and throws, `packages/studio/src/site-context.ts` `JSON.parse`s and silently returns null — and
- * there is no `"layout"` document kind for a format to declare, so this clause is hand-written and
- * cannot be derived. `layouts/` is excluded by {@link DOCUMENT_ROOTS} already; what remains is a
- * project whose `layout` points somewhere inside a document root.
+ * A layout is native at both readers — `packages/compiler/src/site/layout-resolver.ts` reads
+ * `.json` and `.jxn` and throws, `packages/studio/src/site-context.ts` `JSON.parse`s and silently
+ * returns null — and there is no `"layout"` document kind for a format to declare, so this clause
+ * is hand-written and cannot be derived. `layouts/` is excluded by {@link DOCUMENT_ROOTS} already;
+ * what remains is a project whose `layout` points somewhere inside a document root.
  */
 function isLayoutPath(path: string): boolean {
   const declared = projectState?.projectConfig?.layout;

package/src/format/format-host.ts

@@ -4,7 +4,9 @@
  * Format classes are auto-discovered server-side from the project imports map
  * (specs/extensions.md); the studio introspects them via the PAL (`listFormats`) and invokes
  * parse/serialize capabilities via `formatAction` (POST /__studio/format in the dev server, RPC on
- * desktop). The studio itself holds zero format knowledge — `.json` is the single native built-in.
+ * desktop). The studio holds no other format knowledge: `.json` is native, and `.jxn` is read and
+ * written here in the same process with the same code as everywhere else (`spec.md` §22), so a host
+ * with no extension runtime has it too.
  */
 
 import { setProjectSchemasForMonaco } from "../services/monaco-lazy";
@@ -17,7 +19,8 @@ import type {
   StudioPlatform,
 } from "../types";
 import { isString } from "@jxsuite/schema/guards";
-import type { JxDocumentValue, JxMutableNode } from "@jxsuite/schema/types";
+import { parseJxn, serializeJxn } from "@jxsuite/schema/jxn";
+import type { JxDocument, JxDocumentValue, JxMutableNode } from "@jxsuite/schema/types";
 
 export interface StudioFormatHints {
   icon?: string;
@@ -59,6 +62,24 @@ export interface StudioFormat {
   capabilities: Record<string, { identifier: string; timing: string[] }>;
 }
 
+/**
+ * What opening a `.jxn` file is told about its format. It is not in {@link getFormats}, which is
+ * what a project chose and what a picker offers: a new document is still `.json`.
+ */
+const JXN_FORMAT: StudioFormat = {
+  capabilities: {
+    parse: { identifier: "parse", timing: ["compiler", "server"] },
+    serialize: { identifier: "serialize", timing: ["compiler", "server"] },
+  },
+  documentKinds: ["page", "component"],
+  exportTarget: false,
+  extensions: [".jxn"],
+  mediaType: null,
+  name: "jxn",
+  remote: false,
+  studio: { documentMode: { default: "component" } },
+};
+
 let _formats: StudioFormat[] = [];
 let _loaded: Promise<StudioFormat[]> | null = null;
 
@@ -235,6 +256,9 @@ export function getFormats(): StudioFormat[] {
 /** Look up the format claiming a file extension (".md" or "md"), optionally by capability. */
 export function formatByExtension(ext: string, capability?: string): StudioFormat | undefined {
   const norm = ext.startsWith(".") ? ext.toLowerCase() : `.${ext.toLowerCase()}`;
+  if (norm === ".jxn") {
+    return JXN_FORMAT;
+  }
   return _formats.find(
     (f) => f.extensions.includes(norm) && (!capability || f.capabilities[capability]),
   );
@@ -245,7 +269,7 @@ export function formatByName(name: string | null | undefined): StudioFormat | un
   if (!name) {
     return undefined;
   }
-  return _formats.find((f) => f.name === name);
+  return name === JXN_FORMAT.name ? JXN_FORMAT : _formats.find((f) => f.name === name);
 }
 
 /** Error for opening a non-JSON file when no imported format class claims its extension. */
@@ -330,6 +354,9 @@ export async function formatParse(
   source: string,
   options?: FormatActionOptions,
 ): Promise<JxMutableNode> {
+  if (name === JXN_FORMAT.name) {
+    return parseJxn(source);
+  }
   /* SAFETY: a format class's `parse` capability returns the Jx document it built from the source —
      The contract every format class implements (specs/extensions.md) — and nothing here inspects
      It before `splitFormatDocument` reads its keys. */
@@ -352,6 +379,11 @@ export async function formatSerialize(
   doc: JxMutableNode,
   options?: FormatActionOptions,
 ): Promise<string> {
+  if (name === JXN_FORMAT.name) {
+    // `source` is what keeps the comments: everything that did not change keeps its exact text.
+    // SAFETY: a document in its editing form, and every member of a JxDocument is optional.
+    return serializeJxn(doc as JxDocument, options?.source);
+  }
   /* SAFETY: a format class's `serialize` capability returns the source text it wrote — the contract
      Every format class implements (specs/extensions.md) — so the answer is a string. */
   return (await formatAction({

package/src/grid/redirects-grid.ts

@@ -29,7 +29,7 @@ import { projectState } from "../store";
 import { clearProblems, notify, problemFindings } from "../services/notify";
 import { showPromptDialog } from "../ui/layers";
 import { activateTab, openTab, workspace } from "../workspace/workspace";
-import { PROJECT_CONFIG_PATH, commitProjectConfig } from "../tabs/project-config";
+import { projectConfigPath, commitProjectConfig } from "../tabs/project-config";
 import { pageRoute } from "../panels/tab-strip";
 import { createGridController, getGridController } from "./grid-controller";
 import {
@@ -230,7 +230,7 @@ export function reportRedirectProblems(
       action: "redirects.open",
       detail: problem.detail,
       key: `redirects.${problem.rule}:${problem.source}`,
-      path: PROJECT_CONFIG_PATH,
+      path: projectConfigPath(),
       source: REDIRECTS_PROBLEM_SOURCE,
       tier: "problem",
     });
@@ -263,7 +263,7 @@ export function createRedirectsSource(): GridSource {
   const load = () => rulesFromConfig(currentConfig());
 
   return {
-    backingPaths: () => new Map([[PROJECT_CONFIG_PATH, "*"]]),
+    backingPaths: () => new Map([[projectConfigPath(), "*"]]),
     capabilities: { delete: true, insert: true, remotePaging: false, remoteSort: false },
     columns: () => Promise.resolve(redirectColumns()),
 
@@ -476,7 +476,7 @@ export function stageRedirectImport(
         action: "redirects.import",
         detail: notes.join("\n"),
         key: "redirects.import",
-        path: PROJECT_CONFIG_PATH,
+        path: projectConfigPath(),
         source: REDIRECTS_PROBLEM_SOURCE,
         tier: "problem",
       },