@jxsuite/studio 10.3.0 → 10.5.0

package/src/services/context-manager.ts

@@ -19,7 +19,8 @@ import {
   toChatMessages,
   toLiveMessages,
 } from "@jxsuite/ai/messages";
-import { isString } from "@jxsuite/schema/guards";
+import { isJsonObject, isString } from "@jxsuite/schema/guards";
+import type { JsonObject, JsonValue } from "@jxsuite/schema/types";
 import { modelContextWindow } from "./ai-models";
 
 /** How many tool messages {@link pruneOrphanToolMessages} dropped, moved and sealed. */
@@ -161,6 +162,17 @@ function contextTokens(
   chatState: ReturnType<typeof createChatState>,
   systemTokens: number,
 ): number {
+  return (
+    countedTokens(chatState, systemTokens) ??
+    systemTokens + estimateTokens(chatState.toMessagesArray())
+  );
+}
+
+/** The provider's count carried forward to this transcript, when there is one it still covers. */
+function countedTokens(
+  chatState: ReturnType<typeof createChatState>,
+  systemTokens: number,
+): number | null {
   const { usage, messages } = chatState;
   const boundary = usage ? messages[usage.messageCount - 1] : undefined;
   if (usage && boundary && boundary.id === usage.lastMessageId) {
@@ -180,7 +192,7 @@ function contextTokens(
       return reused;
     }
   }
-  return systemTokens + estimateTokens(chatState.toMessagesArray());
+  return null;
 }
 
 /**
@@ -282,6 +294,102 @@ export function trimContext(
   return { estimatedTokens: newTotal, droppedCount };
 }
 
+// ─── Shed ───────────────────────────────────────────────────────────────────
+
+/** What {@link shedToolResults} sheds down to, as a fraction of the window. */
+const SHED_TARGET_FRACTION = 0.6;
+
+/** A result smaller than this is mostly its stub already, and is often an answer worth keeping. */
+const SHED_MIN_CHARS = 1024;
+
+/** What a shed result tells the model. */
+const SHED_NOTE =
+  "This result was removed to save space. Call the tool again if you still need it.";
+
+/** A tool's reply as an object, or an empty one when it is not a result this module can read. */
+function parsedReply(content: string): JsonObject {
+  try {
+    /* SAFETY: JSON.parse without a reviver turns text into nothing but JSON values. */
+    const parsed = JSON.parse(content) as JsonValue;
+    return isJsonObject(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * What is left of a tool's reply once its output is shed: how it ended and what it said it did, so
+ * the model and a restored chip keep the outcome and lose only the bulk.
+ */
+function shedReply(content: string): string {
+  const { success = true, summary, error } = parsedReply(content);
+  return JSON.stringify({ success, summary, error, shed: SHED_NOTE });
+}
+
+/**
+ * Keep a turn inside the model's window between its rounds (specs/ai.md §3.8).
+ *
+ * {@link trimContext} runs when a message is sent, so nothing else bounds what one turn's own tool
+ * results add, and a turn with room to work could fill the window and have its request refused.
+ * Past the same budget the trim uses, this replaces the oldest large tool results with a stub until
+ * the context is back under {@link SHED_TARGET_FRACTION}. The results of the latest round are never
+ * touched, because the model has not read them yet, and the pairs are never broken, because only a
+ * reply's content changes.
+ *
+ * It changes the transcript rather than one request, so a shed result stays shed: the next send
+ * measures what it will really send, and the provider's prompt cache breaks once for a whole batch
+ * rather than on every round after the budget is reached.
+ *
+ * @param {ReturnType<typeof createChatState>} chatState
+ * @param {string} systemPrompt
+ * @returns {number} How many results it shed.
+ */
+export function shedToolResults(
+  chatState: ReturnType<typeof createChatState>,
+  systemPrompt: string,
+): number {
+  const window = contextWindowFor(chatState.model);
+  const systemTokens = estimateTokens(systemPrompt);
+  const { messages } = chatState;
+  let total =
+    countedTokens(chatState, systemTokens) ??
+    systemTokens + estimateTokens(messages.map((message) => wireEntry(message)));
+  if (total <= Math.floor(window * BUDGET_FRACTION)) {
+    return 0;
+  }
+  const target = Math.floor(window * SHED_TARGET_FRACTION);
+  /* The latest round is the trailing run of replies, with the placeholder of the round about to
+     stream after it when there is one. */
+  let latest = messages.length;
+  while (
+    latest > 0 &&
+    messages[latest - 1]!.role === "assistant" &&
+    !messages[latest - 1]!.toolCalls
+  ) {
+    latest -= 1;
+  }
+  while (latest > 0 && messages[latest - 1]!.role === "tool") {
+    latest -= 1;
+  }
+  let shed = 0;
+  for (let i = 0; i < latest && total > target; i++) {
+    const message = messages[i]!;
+    if (message.role === "tool" && message.content.length >= SHED_MIN_CHARS) {
+      const before = estimateTokens(message.content);
+      message.content = shedReply(message.content);
+      total -= before - estimateTokens(message.content);
+      shed += 1;
+    }
+  }
+  if (shed > 0) {
+    // The provider counted the longer transcript; the estimate is all there is until it next counts.
+    chatState.clearUsage();
+    chatState.setTokenCount(total);
+    chatState.setContextWarning(true);
+  }
+  return shed;
+}
+
 // ─── Orphaned tool calls ────────────────────────────────────────────────────
 
 /**

package/src/services/document-assistant.ts

@@ -38,7 +38,7 @@ import { getAiProvider, getBaseUrl, getOpenAiKey } from "./ai-settings";
 import { preferredModel } from "./ai-models";
 import { pruneOrphanToolMessages, trimContext } from "./context-manager";
 import { renderCheck } from "./render-critic";
-import type { CandidateDocument, RenderVerdict } from "./ai-write-report";
+import type { RenderProbe } from "./ai-write-report";
 import { validateDoc } from "./jx-validate";
 import { reloadFileInTab } from "../files/files";
 import { getExtensionCatalog, refreshExtensionUi } from "../format/format-host";
@@ -68,7 +68,7 @@ function projectConfig(): ProjectConfig | null {
 /* SAFETY: renderCheck runs the whole render inside a try and answers `{ ok: false, error }` for
    anything it cannot render, so JSON that is not (yet) a valid document is exactly what it is safe
    to hand; its JxDocument parameter names what renders, not what may be probed. */
-const probeRender = renderCheck as (doc: CandidateDocument) => Promise<RenderVerdict>;
+const probeRender = renderCheck as RenderProbe;
 
 /**
  * Create a document-assistant session bound to the currently active tab.

package/src/services/harness/chat-reducer.ts

@@ -39,10 +39,15 @@ export function isImportProgressEvent(value: unknown): value is ImportProgressEv
 function applyOutcome(chat: ChatStore, outcome: TurnOutcome): void {
   switch (outcome.kind) {
     case "cap_partial": {
-      // A partial success is said as the assistant, not as a failure (specs/ai.md §3.2).
-      chat.beginAssistantTurn();
-      chat.appendDelta(outcome.cap?.text ?? "");
-      chat.finishStream("length");
+      /* The model's closing reply has already been drawn, and there is nothing to add. Otherwise a
+         partial success is said as the assistant, not as a failure (specs/ai.md §3.2), after
+         removing whatever the closing round that gave no reply left behind. */
+      if (outcome.cap) {
+        chat.cancelStream();
+        chat.beginAssistantTurn();
+        chat.appendDelta(outcome.cap.text);
+        chat.finishStream("length");
+      }
       break;
     }
     case "cap_failed":

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/surfaces/collections-panel.json

@@ -130,7 +130,7 @@
     "& [part=\"entry-locale\"]:empty": {
       "display": "none"
     },
-    "& [part=\"entry-status\"][data-status=\"Draft\"]": {
+    "& [part=\"entry-status\"]:not([data-status=\"Published\"], [data-status=\"\"])": {
       "color": "var(--warning)"
     },
     "& [part=\"note\"], & [part=\"no-project\"]": {

package/src/surfaces/collections-panel.ts

@@ -42,7 +42,7 @@ export interface CollectionRow {
 export interface CollectionEntryRow {
   path: string;
   title: string;
-  /** "Draft", "Published", or "". */
+  /** A `hold` rule's label, "Published", or "". */
   status: string;
   /** Whether a thumbnail is drawn, or the document glyph. */
   art: "image" | "glyph";

package/src/surfaces/entry-editor.json

@@ -1,14 +1,14 @@
 {
   "$schema": "https://jxsuite.com/schema/v1",
   "$id": "StudioEntryEditor",
-  "$description": "The Entry editor (site-architecture.md §7.4) — one content entry's fields, in a pane, as a Jx document over the kit. The adapter (`surfaces/entry-editor.ts`) hands in a projection; `content/entry-editor.ts` decides everything in it — which collection the file belongs to, which record its fields live in, which required keys are absent and what a draft flag commits into. The FORM is an island: a schema is `ui/schema-form.ts`'s subject, so this document renders an empty `fields` node and the flow places the element that engine hands back (studio-ui-guidelines.md §9.3, §9.4). That is the whole of the difference between this and the card the lit version drew, and it is why the engine converting in batch 7 is what unblocked this one.",
+  "$description": "The Entry editor (site-architecture.md §7.4) — one content entry's fields, in a pane, as a Jx document over the kit. The adapter (`surfaces/entry-editor.ts`) hands in a projection; `content/entry-editor.ts` decides everything in it — which collection the file belongs to, which record its fields live in, which required keys are absent and what a hold switch commits into. The FORM is an island: a schema is `ui/schema-form.ts`'s subject, so this document renders an empty `fields` node and the flow places the element that engine hands back (studio-ui-guidelines.md §9.3, §9.4). That is the whole of the difference between this and the card the lit version drew, and it is why the engine converting in batch 7 is what unblocked this one.",
   "tagName": "div",
   "attributes": {
     "part": "entry",
     "data-jx-region": "${state.region}"
   },
   "style": {
-    "$description": "What `.entry-editor`, `.entry-editor-header`, `.entry-editor-collection`, `.entry-draft-switch`, `.entry-editor-fields`, `.entry-editor-note` and `.entry-editor-empty` said in `styles/overlays.css`, keyed on `part` and re-pointed at the studio token layer. This editor was the only emitter of all seven, so those rules are dead in the stylesheet from here; a central sweep removes them rather than this change, which owns no stylesheet. Every `--spectrum-font-size-*` reference is gone rather than renamed: those names resolve only inside `<sp-theme>`, and a pane editor is mounted outside it, so each would silently have taken its hard-coded fallback.",
+    "$description": "What `.entry-editor`, `.entry-editor-header`, `.entry-editor-collection`, `.entry-hold-switch`, `.entry-editor-fields`, `.entry-editor-note` and `.entry-editor-empty` said in `styles/overlays.css`, keyed on `part` and re-pointed at the studio token layer. This editor was the only emitter of all seven, so those rules are dead in the stylesheet from here; a central sweep removes them rather than this change, which owns no stylesheet. Every `--spectrum-font-size-*` reference is gone rather than renamed: those names resolve only inside `<sp-theme>`, and a pane editor is mounted outside it, so each would silently have taken its hard-coded fallback.",
     "height": "100%",
     "padding": "var(--jx-space-5)",
     "overflowY": "auto",
@@ -32,7 +32,7 @@
       "color": "var(--fg-dim)",
       "fontSize": "var(--jx-text-sm)"
     },
-    "& [part=\"draft\"]": {
+    "& [part=\"hold\"]": {
       "$description": "Pushed to the far end of the header rather than placed there: the heading and the collection chip are both content-width, so `margin-left: auto` is what keeps the switch on the right edge whatever the entry is called.",
       "marginLeft": "auto"
     },
@@ -241,27 +241,27 @@
                 {
                   "tagName": "div",
                   "attributes": {
-                    "part": "draft-slot",
+                    "part": "hold-slot",
                     "role": "none"
                   },
                   "style": {
                     "display": "contents"
                   },
                   "$switch": {
-                    "$ref": "#/state/draftAxis"
+                    "$ref": "#/state/holdSwitch"
                   },
                   "cases": {
                     "shown": {
                       "$description": "No `label`: the slotted word is on screen and carries the name, so an aria-label would be read twice. The tooltip is `hint`, which is what DRAFT_MEANING has always been.",
                       "tagName": "jx-switch",
                       "attributes": {
-                        "part": "draft"
+                        "part": "hold"
                       },
                       "$props": {
                         "checked": {
-                          "$ref": "#/state/draft"
+                          "$ref": "#/state/holdOn"
                         },
-                        "hint": "${state.draftHint}",
+                        "hint": "${state.holdHint}",
                         "size": "sm"
                       },
                       "onchange": {
@@ -270,7 +270,7 @@
                           {
                             "operator": "call",
                             "target": {
-                              "$ref": "#/state/setDraft"
+                              "$ref": "#/state/setHold"
                             },
                             "value": [
                               {
@@ -283,7 +283,7 @@
                       "children": [
                         {
                           "tagName": "span",
-                          "textContent": "Draft"
+                          "textContent": "${state.holdLabel}"
                         }
                       ]
                     }