@jxsuite/studio 2.0.1 → 2.1.0

package/dist/chunks/studio-cjm7fdjf.js

@@ -0,0 +1,451 @@
+// ../schema/src/guards.ts
+function isJsonObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isRef(value) {
+  return isJsonObject(value) && typeof value.$ref === "string";
+}
+function isFunctionDef(value) {
+  return isJsonObject(value) && value.$prototype === "Function";
+}
+function isExpressionDef(value) {
+  return isJsonObject(value) && isJsonObject(value.$expression);
+}
+function isNamedFormulaDef(value) {
+  return isExpressionDef(value) && Array.isArray(value.parameters) && value.parameters.length > 0;
+}
+function hasStructuredBody(value) {
+  return isFunctionDef(value) && Array.isArray(value.body);
+}
+function isPrototypeDef(value) {
+  return isJsonObject(value) && typeof value.$prototype === "string" && value.$prototype !== "Function";
+}
+function isServerFnDef(value) {
+  return isJsonObject(value) && value.timing === "server" && typeof value.$src === "string" && typeof value.$export === "string" && !value.$prototype;
+}
+var SCHEMA_KEYWORDS = new Set([
+  "type",
+  "enum",
+  "minimum",
+  "maximum",
+  "minLength",
+  "maxLength",
+  "pattern",
+  "format",
+  "items",
+  "properties",
+  "required",
+  "description",
+  "title",
+  "$comment"
+]);
+function isMappedArray(value) {
+  return isJsonObject(value) && value.$prototype === "Array";
+}
+function isTemplateString(value) {
+  return typeof value === "string" && value.includes("${");
+}
+function bodyReturnsValue(body) {
+  return /\breturn\b[^\S\n]*(?![;}\s]|$)/.test(body);
+}
+function isNestedStyle(value) {
+  return typeof value === "object" && value !== null;
+}
+function getNestedStyle(style, key) {
+  const value = style?.[key];
+  return isNestedStyle(value) ? value : undefined;
+}
+function ensureNestedStyle(style, key) {
+  const existing = style[key];
+  if (isNestedStyle(existing)) {
+    return existing;
+  }
+  const created = {};
+  style[key] = created;
+  return created;
+}
+function isEventBinding(value) {
+  return isRef(value) || isFunctionDef(value) || isExpressionDef(value);
+}
+function getEventBinding(node, key) {
+  const value = node[key];
+  return isEventBinding(value) ? value : undefined;
+}
+function paramNames(parameters) {
+  if (!parameters) {
+    return [];
+  }
+  return parameters.map((p) => typeof p === "string" ? p : p.name);
+}
+function isTagExpression(tagName) {
+  return isJsonObject(tagName) && isJsonObject(tagName.$expression);
+}
+function tagNameCandidates(tagName) {
+  if (typeof tagName === "string") {
+    return [tagName];
+  }
+  if (!isTagExpression(tagName)) {
+    return [];
+  }
+  const expression = tagName.$expression;
+  if (expression.operator === "?:") {
+    return [...new Set([expression.value, expression.initial])];
+  }
+  return [...new Set([...Object.values(expression.cases), expression.default])];
+}
+function displayTagName(tagName) {
+  return typeof tagName === "string" ? tagName : tagNameCandidates(tagName).join("|");
+}
+function isPrivateStateKey(key) {
+  return key.startsWith("#");
+}
+
+// src/ui/timing.ts
+var INPUT_DEBOUNCE = 400;
+var LIVE_PREVIEW = 350;
+var POLL_GIT = 30000;
+
+// src/state.ts
+function getNodeAtPath(doc, path) {
+  let node = doc;
+  for (const key of path) {
+    if (node == null) {
+      return;
+    }
+    node = node[key];
+  }
+  return node;
+}
+function childList(node) {
+  return Array.isArray(node?.children) ? node.children : [];
+}
+function normalizeArrayChildren(node) {
+  if (!node || typeof node !== "object") {
+    return node;
+  }
+  if (Array.isArray(node)) {
+    for (const child of node) {
+      normalizeArrayChildren(child);
+    }
+    return node;
+  }
+  const n = node;
+  const { children } = n;
+  if (children && typeof children === "object" && !Array.isArray(children) && children.$prototype === "Array") {
+    n.children = [children];
+  }
+  if (Array.isArray(n.children)) {
+    for (const child of n.children) {
+      normalizeArrayChildren(child);
+    }
+  }
+  if (n.$prototype === "Array" && n.map && typeof n.map === "object") {
+    normalizeArrayChildren(n.map);
+  }
+  if (n.cases && typeof n.cases === "object") {
+    for (const caseDef of Object.values(n.cases)) {
+      normalizeArrayChildren(caseDef);
+    }
+  }
+  return node;
+}
+function parentElementPath(path) {
+  return path.length >= 2 ? path.slice(0, -2) : null;
+}
+function childIndex(path) {
+  return path.at(-1);
+}
+function pathKey(path) {
+  return path.join("/");
+}
+function pathsEqual(a, b) {
+  if (a === b) {
+    return true;
+  }
+  if (!a || !b || a.length !== b.length) {
+    return false;
+  }
+  return a.every((v, i) => v === b[i]);
+}
+function isAncestor(path, descendant) {
+  if (path.length > descendant.length) {
+    return false;
+  }
+  return path.every((v, i) => v === descendant[i]);
+}
+function flattenTree(doc, path = [], depth = 0) {
+  const rows = [];
+  collectRows(doc, path, depth, rows, false);
+  return rows;
+}
+function collectRows(doc, path, depth, out, skipSelf) {
+  if (typeof doc === "string" || typeof doc === "number" || typeof doc === "boolean") {
+    if (!skipSelf) {
+      out.push({ depth, node: doc, nodeType: "text", path });
+    }
+    return;
+  }
+  if (doc.$prototype === "Array") {
+    if (!skipSelf) {
+      out.push({ depth, node: doc, nodeType: "map", path });
+    }
+    const mapDef = doc.map;
+    if (mapDef && typeof mapDef === "object") {
+      collectRows(mapDef, [...path, "map"], depth + 1, out, false);
+    }
+    return;
+  }
+  if (!skipSelf) {
+    out.push({ depth, node: doc, nodeType: "element", path });
+  }
+  if (doc.$props && displayTagName(doc.tagName).includes("-") && !Array.isArray(doc.children)) {
+    return;
+  }
+  const { children } = doc;
+  if (Array.isArray(children)) {
+    for (let i = 0;i < children.length; i++) {
+      const childPath = [...path, "children", i];
+      collectRows(children[i], childPath, depth + 1, out, false);
+    }
+  } else if (children && typeof children === "object" && children.$prototype === "Array") {
+    collectRows(children, [...path, "children"], depth + 1, out, false);
+  }
+  if (doc.$switch && doc.cases && typeof doc.cases === "object") {
+    for (const [caseName, caseDef] of Object.entries(doc.cases)) {
+      const casePath = [...path, "cases", caseName];
+      if (caseDef && typeof caseDef === "object" && caseDef.$ref) {
+        out.push({
+          depth: depth + 1,
+          node: caseDef,
+          nodeType: "case-ref",
+          path: casePath
+        });
+      } else if (caseDef && typeof caseDef === "object") {
+        out.push({
+          depth: depth + 1,
+          node: caseDef,
+          nodeType: "case",
+          path: casePath
+        });
+        collectRows(caseDef, casePath, depth + 2, out, true);
+      }
+    }
+  }
+}
+function nodeLabel(node) {
+  if (!node) {
+    return "?";
+  }
+  if (node.$prototype === "Array") {
+    const { items } = node;
+    const ref = (isRef(items) ? items.$ref : undefined) || "items";
+    return `Repeater → ${ref}`;
+  }
+  if (node.$title) {
+    return node.$title;
+  }
+  if (node.$id) {
+    return node.$id;
+  }
+  if (node.tagName === "slot") {
+    const name = node.attributes?.name;
+    return typeof name === "string" && name.trim() ? `slot: ${name.trim()}` : "slot";
+  }
+  const tag = displayTagName(node.tagName) || "div";
+  const suffix = node.$switch ? " ⇆" : "";
+  if (typeof node.textContent === "string" && node.textContent.length > 0) {
+    return `${tag} — ${node.textContent.slice(0, 24)}${suffix}`;
+  }
+  return tag + suffix;
+}
+var projectState = null;
+function setProjectState(ps) {
+  projectState = ps;
+}
+function requireProjectState() {
+  return projectState;
+}
+// src/utils/strip-events.ts
+function stripEventHandlers(node) {
+  if (!node || typeof node !== "object") {
+    return node;
+  }
+  if (Array.isArray(node)) {
+    return node.map((n) => stripEventHandlers(n));
+  }
+  const out = {};
+  for (const [k, v] of Object.entries(node)) {
+    if (k.startsWith("on") && isEventBinding(v)) {
+      continue;
+    }
+    if (k === "children") {
+      out.children = Array.isArray(v) ? v.map((c) => stripEventHandlers(c)) : stripEventHandlers(v);
+    } else if (k === "cases" && typeof v === "object") {
+      const cases = {};
+      for (const [ck, cv] of Object.entries(v)) {
+        cases[ck] = stripEventHandlers(cv);
+      }
+      out.cases = cases;
+    } else if (k === "state" && typeof v === "object" && v !== null) {
+      const state = {};
+      for (const [sk, sv] of Object.entries(v)) {
+        if (sv && typeof sv === "object" && sv.timing === "server") {
+          continue;
+        }
+        state[sk] = sv;
+      }
+      out.state = state;
+    } else if (k === "style" || k === "attributes" || k === "$media") {
+      out[k] = v;
+    } else {
+      out[k] = v;
+    }
+  }
+  return out;
+}
+
+// src/store.ts
+var activityBar = null;
+var leftPanel = null;
+var rightPanel = null;
+var toolbarEl = null;
+var statusbarEl = null;
+function initShellRefs() {
+  activityBar = document.querySelector("#activity-bar");
+  leftPanel = document.querySelector("#left-panel");
+  rightPanel = document.querySelector("#right-panel");
+  toolbarEl = document.querySelector("#toolbar");
+  statusbarEl = document.querySelector("#statusbar");
+}
+var VOID_ELEMENTS = new Set([
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+]);
+var COMMON_SELECTORS = [
+  ":hover",
+  ":focus",
+  ":active",
+  ":focus-within",
+  ":focus-visible",
+  ":disabled",
+  ":first-child",
+  ":last-child",
+  "::before",
+  "::after",
+  "::placeholder"
+];
+function isNestedSelector(k) {
+  return k.startsWith(":") || k.startsWith(".") || k.startsWith("&") || k.startsWith("[");
+}
+var _styleDebounceTimers = new Map;
+function debouncedStyleCommit(prop, ms, fn) {
+  const delay = ms ?? INPUT_DEBOUNCE;
+  return (...args) => {
+    clearTimeout(_styleDebounceTimers.get(prop));
+    _styleDebounceTimers.set(prop, setTimeout(() => {
+      _styleDebounceTimers.delete(prop);
+      fn(...args);
+    }, delay));
+  };
+}
+function cancelStyleDebounce(prop) {
+  clearTimeout(_styleDebounceTimers.get(prop));
+  _styleDebounceTimers.delete(prop);
+}
+var _renderers = new Map;
+var _rendersInFlight = 0;
+function rendersInFlight() {
+  return _rendersInFlight;
+}
+function runRenderer(name, fn) {
+  _rendersInFlight += 1;
+  const done = () => {
+    _rendersInFlight -= 1;
+  };
+  let pending = null;
+  try {
+    const result = fn();
+    if (typeof result?.then === "function") {
+      pending = result;
+    }
+  } catch (error) {
+    console.error(`Renderer "${name}" failed:`, error);
+  }
+  if (!pending) {
+    done();
+    return;
+  }
+  pending.then(done, (error) => {
+    console.error(`Renderer "${name}" failed:`, error);
+    done();
+  });
+}
+function registerRenderer(name, fn) {
+  _renderers.set(name, fn);
+}
+function render() {
+  for (const [name, fn] of _renderers.entries()) {
+    runRenderer(name, fn);
+  }
+}
+function renderOnly(...names) {
+  for (const name of names) {
+    const fn = _renderers.get(name);
+    if (!fn) {
+      continue;
+    }
+    runRenderer(name, fn);
+  }
+}
+function updateSession(tab, patch) {
+  if (tab) {
+    if (patch.selection !== undefined) {
+      tab.session.selection = patch.selection;
+    }
+    if (patch.hover !== undefined) {
+      tab.session.hover = patch.hover;
+    }
+    if (patch.clipboard !== undefined) {
+      tab.session.clipboard = patch.clipboard;
+    }
+    if (patch.ui) {
+      for (const [k, v] of Object.entries(patch.ui)) {
+        tab.session.ui[k] = v;
+      }
+    }
+    if (patch.canvas) {
+      for (const [k, v] of Object.entries(patch.canvas)) {
+        tab.session.canvas[k] = v;
+      }
+    }
+  }
+}
+function updateUi(tab, field, value) {
+  if (tab) {
+    tab.session.ui[field] = value;
+  }
+}
+function updateCanvas(tab, patch) {
+  if (tab) {
+    for (const [k, v] of Object.entries(patch)) {
+      tab.session.canvas[k] = v;
+    }
+  }
+}
+
+export { isJsonObject, isRef, isFunctionDef, isExpressionDef, isNamedFormulaDef, hasStructuredBody, isPrototypeDef, isServerFnDef, isMappedArray, isTemplateString, bodyReturnsValue, getNestedStyle, ensureNestedStyle, isEventBinding, getEventBinding, paramNames, isTagExpression, tagNameCandidates, displayTagName, isPrivateStateKey, LIVE_PREVIEW, POLL_GIT, getNodeAtPath, childList, normalizeArrayChildren, parentElementPath, childIndex, pathKey, pathsEqual, isAncestor, flattenTree, nodeLabel, projectState, setProjectState, requireProjectState, stripEventHandlers, activityBar, leftPanel, rightPanel, toolbarEl, statusbarEl, initShellRefs, VOID_ELEMENTS, COMMON_SELECTORS, isNestedSelector, debouncedStyleCommit, cancelStyleDebounce, rendersInFlight, registerRenderer, render, renderOnly, updateSession, updateUi, updateCanvas };
+
+//# debugId=147E616828B71FA964756E2164756E21
+//# sourceMappingURL=studio-cjm7fdjf.js.map

package/dist/chunks/studio-cjm7fdjf.js.map

@@ -0,0 +1,14 @@
+{
+  "version": 3,
+  "sources": ["../../schema/src/guards.ts", "../src/ui/timing.ts", "../src/state.ts", "../src/utils/strip-events.ts", "../src/store.ts"],
+  "sourcesContent": [
+    "/**\n * Type predicate guards for the Jx document model.\n *\n * These narrow `unknown`/union-typed values to precise domain types so call sites get real property\n * checking instead of casts. Every guard mirrors the runtime's actual detection logic (see\n * buildScope's five-shape algorithm in the runtime).\n */\n\nimport type {\n  JsonObject,\n  JsonValue,\n  JxClassDef,\n  JxElement,\n  JxEventBinding,\n  JxExpressionDef,\n  JxFunctionDef,\n  JxMappedArray,\n  JxMutableNode,\n  JxPrototypeDef,\n  JxRef,\n  JxServerFnDef,\n  JxStateObject,\n  JxStatement,\n  JxStyle,\n  JxTagExpression,\n} from \"../types\";\n\n// ─── JSON shape guards ──────────────────────────────────────────────────────────\n\n/** A plain object: not null, not an array. The base check for all object-shaped defs. */\nexport function isJsonObject(value: unknown): value is JsonObject {\n  return typeof value === \"object\" && value !== null && !Array.isArray(value);\n}\n\n// ─── Binding guards ─────────────────────────────────────────────────────────────\n\n/** A `{ $ref: \"#/...\" }` JSON Pointer reference. */\nexport function isRef(value: unknown): value is JxRef {\n  return isJsonObject(value) && typeof value.$ref === \"string\";\n}\n\n// ─── State definition guards (the five-shape algorithm) ────────────────────────\n\n/** Shape 4: a function declaration — `{ $prototype: \"Function\", body | $src }`. */\nexport function isFunctionDef(value: unknown): value is JxFunctionDef {\n  return isJsonObject(value) && value.$prototype === \"Function\";\n}\n\n/** Shape 5: a declarative expression entry — `{ $expression: { operator, target } }`. */\nexport function isExpressionDef(value: unknown): value is JxExpressionDef {\n  return isJsonObject(value) && isJsonObject(value.$expression);\n}\n\n/**\n * Shape 5 with `parameters`: a named formula — a pure, reusable computation invoked via the `call`\n * operator rather than lowered to a computed value.\n */\nexport function isNamedFormulaDef(\n  value: unknown,\n): value is JxExpressionDef & { parameters: unknown[] } {\n  return isExpressionDef(value) && Array.isArray(value.parameters) && value.parameters.length > 0;\n}\n\n/**\n * Shape 4 with a structured body: a Function entry whose `body` is a statement array (spec §20)\n * rather than opaque JS source.\n */\nexport function hasStructuredBody(\n  value: unknown,\n): value is JxFunctionDef & { body: JxStatement[] } {\n  return isFunctionDef(value) && Array.isArray(value.body);\n}\n\n/** A non-Function `$prototype` instance (Request, Storage, ContentCollection, classes, …). */\nexport function isPrototypeDef(value: unknown): value is JxPrototypeDef {\n  return (\n    isJsonObject(value) && typeof value.$prototype === \"string\" && value.$prototype !== \"Function\"\n  );\n}\n\n/** A `timing: \"server\"` function proxy (no `$prototype`, external `$src`/`$export`). */\nexport function isServerFnDef(value: unknown): value is JxServerFnDef {\n  return (\n    isJsonObject(value) &&\n    value.timing === \"server\" &&\n    typeof value.$src === \"string\" &&\n    typeof value.$export === \"string\" &&\n    !value.$prototype\n  );\n}\n\n/** Shape 2: an expanded signal — an object carrying a `default` value. */\nexport function isExpandedSignal(value: unknown): value is JxStateObject & { default: JsonValue } {\n  return isJsonObject(value) && !value.$prototype && !value.$expression && \"default\" in value;\n}\n\n/**\n * Schema-only keywords used to detect pure type definitions (Shape 2b). An object with ONLY these\n * keys and no `default` is a type def, not a signal.\n */\nexport const SCHEMA_KEYWORDS: ReadonlySet<string> = new Set([\n  \"type\",\n  \"enum\",\n  \"minimum\",\n  \"maximum\",\n  \"minLength\",\n  \"maxLength\",\n  \"pattern\",\n  \"format\",\n  \"items\",\n  \"properties\",\n  \"required\",\n  \"description\",\n  \"title\",\n  \"$comment\",\n]);\n\n/** Shape 2b: a pure type definition — every key is a JSON Schema keyword. */\nexport function isSchemaOnlyDef(value: unknown): value is JxStateObject {\n  if (!isJsonObject(value)) {\n    return false;\n  }\n  for (const k of Object.keys(value)) {\n    if (!SCHEMA_KEYWORDS.has(k)) {\n      return false;\n    }\n  }\n  return true;\n}\n\n/** True when an object carries at least one JSON Schema keyword. */\nexport function hasSchemaKeywords(value: unknown): value is JxStateObject {\n  if (!isJsonObject(value)) {\n    return false;\n  }\n  for (const k of Object.keys(value)) {\n    if (SCHEMA_KEYWORDS.has(k)) {\n      return true;\n    }\n  }\n  return false;\n}\n\n// ─── Document structure guards ──────────────────────────────────────────────────\n\n/** A mapped (repeater) children object — `{ $prototype: \"Array\", items, map }`. */\nexport function isMappedArray(value: unknown): value is JxMappedArray {\n  return isJsonObject(value) && value.$prototype === \"Array\";\n}\n\n/**\n * Whether a node's `children` holds at least one mapped array — either as the bare whole-children\n * slot (legacy) or as a member of the children array. Used by renderers and the compiler to decide\n * if a children list needs inline repeater expansion.\n */\nexport function childrenContainArray(children?: unknown): boolean {\n  if (isMappedArray(children)) {\n    return true;\n  }\n  return Array.isArray(children) && children.some((c) => isMappedArray(c));\n}\n\n/** A .class.json schema-defined class document — `{ $prototype: \"Class\" }`. */\nexport function isClassDef(value: unknown): value is JxClassDef {\n  return isJsonObject(value) && value.$prototype === \"Class\";\n}\n\n/** An element-shaped node object (vs. a bare string/number child). */\nexport function isNodeObject(value: unknown): value is JxMutableNode & JxElement {\n  return isJsonObject(value);\n}\n\n/** A `${...}` template-expression string. */\nexport function isTemplateString(value?: unknown): value is string {\n  return typeof value === \"string\" && value.includes(\"${\");\n}\n\n/**\n * Whether a function `body` returns a value — the heuristic that classifies a `$prototype:\n * \"Function\"` as a computed value vs an event handler. Uses a word boundary so identifiers like\n * `returned` do not match. Shared by the runtime interpreter and the compiler so both agree on the\n * classification.\n *\n * A bare `return;` does not count. It is an early-exit guard, which is handler code — reading it as\n * a value return turned any handler with a guard clause into a `computed()`, so the binding that\n * invoked it found a value where it expected a function. The value has to follow on the same line,\n * because a newline after `return` is an ASI bare return.\n */\nexport function bodyReturnsValue(body: string): boolean {\n  return /\\breturn\\b[^\\S\\n]*(?![;}\\s]|$)/.test(body);\n}\n\n// ─── Style guards & accessors ───────────────────────────────────────────────────\n\n/** A nested style object (selector/media block), as opposed to a scalar CSS value. */\nexport function isNestedStyle(value: string | number | JxStyle | undefined): value is JxStyle {\n  return typeof value === \"object\" && value !== null;\n}\n\n/** Read a nested style block (`:hover`, `@--md`, `& > li`, …), if present. */\nexport function getNestedStyle(style: JxStyle | undefined, key: string): JxStyle | undefined {\n  const value = style?.[key];\n  return isNestedStyle(value) ? value : undefined;\n}\n\n/** Read a nested style block, creating an empty one in place when absent or scalar. */\nexport function ensureNestedStyle(style: JxStyle, key: string): JxStyle {\n  const existing = style[key];\n  if (isNestedStyle(existing)) {\n    return existing;\n  }\n  const created: JxStyle = {};\n  style[key] = created;\n  return created;\n}\n\n// ─── Event binding guards ───────────────────────────────────────────────────────\n\n/**\n * The value of an `on*` document key: a `$ref`, an inline function declaration, or a declarative\n * expression.\n */\nexport function isEventBinding(value: unknown): value is JxEventBinding {\n  return isRef(value) || isFunctionDef(value) || isExpressionDef(value);\n}\n\n/** Read the event binding stored under an `on*` key of a node, if there is one. */\nexport function getEventBinding(\n  node: JxMutableNode | JxElement,\n  key: string,\n): JxEventBinding | undefined {\n  const value = node[key];\n  return isEventBinding(value) ? value : undefined;\n}\n\n// ─── Parameter helpers ──────────────────────────────────────────────────────────\n\n/** Resolve `parameters` entries (bare strings or CEM objects) to their names. */\nexport function paramNames(parameters: JxFunctionDef[\"parameters\"]): string[] {\n  if (!parameters) {\n    return [];\n  }\n  return parameters.map((p) => (typeof p === \"string\" ? p : p.name));\n}\n\n/** Whether an element's `tagName` is a choice rather than a name. */\nexport function isTagExpression(tagName: unknown): tagName is { $expression: JxTagExpression } {\n  return isJsonObject(tagName) && isJsonObject(tagName.$expression);\n}\n\n/**\n * Every tag an element could be, without evaluating anything.\n *\n * ONE implementation, shared by the runtime, the three compiler targets and the studio, because\n * four surfaces each writing their own enumeration is four chances to disagree about what an\n * element can be — and disagreeing about that is how the `${…}` tagName shipped a page whose SSR\n * markup and client render used different elements.\n *\n * A plain name yields itself, so every caller can treat the two forms alike.\n */\nexport function tagNameCandidates(tagName: unknown): string[] {\n  if (typeof tagName === \"string\") {\n    return [tagName];\n  }\n  if (!isTagExpression(tagName)) {\n    return [];\n  }\n  const expression = tagName.$expression;\n  if (expression.operator === \"?:\") {\n    return [...new Set([expression.value, expression.initial])];\n  }\n  return [...new Set([...Object.values(expression.cases), expression.default])];\n}\n\n/**\n * The tag to show a human when the element could be several.\n *\n * The Outline draws one row per node and needs a label that is stable, short and honest: `a|div`\n * says \"this is one element whose tag is chosen\" without pretending to know which. Rendering the\n * first candidate would have been a quieter lie.\n */\nexport function displayTagName(tagName: unknown): string {\n  return typeof tagName === \"string\" ? tagName : tagNameCandidates(tagName).join(\"|\");\n}\n\n/**\n * Whether a `state` key is private (`spec.md` §5.6).\n *\n * A `#`-prefixed entry is ordinary state in every respect but one: it is not part of the\n * component's interface. It never reaches the studio property panel, never appears in an exported\n * CEM manifest, and is never settable through `$props` — which is the clause that needs a predicate\n * rather than a convention, because the props paths are spread across two tiers.\n *\n * The rule lived inline at three call sites before it lived here, spelled `key.startsWith(\"#\")`\n * each time. That is survivable for two and a drift risk at four, and the interesting direction of\n * drift is silent: a path that forgets the check does not fail, it just quietly makes a private\n * entry writable from outside.\n *\n * @param {string} key - A `state` key\n * @returns {boolean}\n */\nexport function isPrivateStateKey(key: string): boolean {\n  return key.startsWith(\"#\");\n}\n",
+    "/**\n * Timing.ts — Studio's latency vocabulary.\n *\n * Every user-visible delay in Studio expresses one of a small number of intents: \"wait until the\n * user stops typing\", \"hold a message on screen long enough to read\", \"check the repo again\". Each\n * call site used to pick its own number for its intent, so the same intent shipped as 350, 400 and\n * 600 ms in three different panels and a retune meant a grep. Name the intent once here, import the\n * name, and the retune is a single edit.\n *\n * All values are milliseconds. The two input debounces are contractual:\n * `specs/studio-ui-guidelines.md` §4.4 fixes 400 ms for text inputs and 500 ms for code/expression\n * textareas. Do not change either without releasing that spec section.\n */\n\n/**\n * Text/style input debounce — the §4.4 standard. Long enough that a normal typing cadence produces\n * one commit per pause rather than one per keystroke, short enough that the canvas still feels\n * live.\n */\nexport const INPUT_DEBOUNCE = 400;\n\n/**\n * Code and expression textareas — the §4.4 standard. Longer than {@link INPUT_DEBOUNCE} because\n * each commit re-parses source (or re-lints), and because half-typed code is usually invalid, so\n * committing eagerly just burns work on states the user is about to leave.\n */\nexport const CODE_DEBOUNCE = 500;\n\n/**\n * Draft-layer live preview (ui/field-input.ts) — how long after a keystroke the in-progress draft\n * is pushed to the document so the canvas updates while the field stays focused. Deliberately below\n * {@link INPUT_DEBOUNCE}: this commit is provisional (the draft survives it, and blur/Enter commits\n * again), so it can afford to fire sooner than a committing input.\n */\nexport const LIVE_PREVIEW = 350;\n\n/*\n * `STATUS_MESSAGE = 3000` used to live here: how long a transient message stayed in the status bar\n * before it erased itself. It had one reader, `statusMessage`, which is deleted — the bar carries\n * ambient state now and outcomes go to `services/notify.ts`, whose `TOAST_LIFETIME_MS` is per\n * SEVERITY (§7.1 caps the band at 4–8s) rather than one number for a failure and a save alike.\n */\n\n/**\n * Git status poll while the Git panel is open. Deliberately coarse: it exists to notice changes\n * made outside Studio, and each tick shells out to git, so a faster cadence buys little and costs\n * I/O.\n */\nexport const POLL_GIT = 30_000;\n",
+    "/**\n * Document paths, the tree walk over them, and the project record.\n *\n * A `JxPath` addresses one node from the document root: `[]` is the root itself, `[\"children\", 0]`\n * its first child, `[\"children\", 0, \"children\", 2]` that child's third. Every module that points at\n * a node — selection, hover, the layers tree, a patch — spells it this way, which is why the\n * comparison and ancestry predicates live here rather than beside any one of them.\n *\n * The editable document and its history belong to a TAB (`tabs/tab.ts`) and its session lives on\n * the workspace; nothing here holds mutable document state. The one exception is `projectState`,\n * which outlives every document because it describes the folder they all come from.\n */\n\nimport type { ProjectState } from \"./types\";\nimport { displayTagName, isRef } from \"@jxsuite/schema/guards\";\nimport type { JxMutableNode } from \"@jxsuite/schema/types\";\n\nexport type JxPath = (string | number)[];\n\n// ─── Path utilities ───────────────────────────────────────────────────────────\n\n/**\n * Walk the document tree and return the node at the given path.\n *\n * @param {JxMutableNode} doc\n * @param {JxPath} path\n * @returns {JxMutableNode}\n */\nexport function getNodeAtPath(doc: JxMutableNode, path: JxPath) {\n  let node = doc;\n  for (const key of path) {\n    if (node == null) {\n      return undefined as unknown as JxMutableNode;\n    }\n    // Paths address nodes by construction; non-node leaves surface as undefined above.\n    node = node[key] as JxMutableNode;\n  }\n  return node;\n}\n\n/**\n * The node's children when they are a static array (the edit-mode invariant); an empty array for\n * mapped-array or absent children.\n *\n * @param {JxMutableNode | null | undefined} node\n * @returns {(JxMutableNode | string)[]}\n */\nexport function childList(node: JxMutableNode | null | undefined): (JxMutableNode | string)[] {\n  return Array.isArray(node?.children) ? node.children : [];\n}\n\n/**\n * Normalize a document in place to the canonical array-member form: a legacy whole-children\n * repeater (`children: { $prototype: \"Array\", … }`) becomes a single member of a children array\n * (`children: [{ $prototype: \"Array\", … }]`). Recurses through children, repeater templates, and\n * `$switch` cases. Runs once when a document is loaded into a tab so every in-studio doc — and its\n * history checkpoints — uses the member form before any mutation.\n *\n * @param {unknown} node\n * @returns {unknown} The same node (mutated)\n */\nexport function normalizeArrayChildren(node: unknown): unknown {\n  if (!node || typeof node !== \"object\") {\n    return node;\n  }\n  if (Array.isArray(node)) {\n    for (const child of node) {\n      normalizeArrayChildren(child);\n    }\n    return node;\n  }\n  const n = node as JxMutableNode;\n  const { children } = n;\n  if (\n    children &&\n    typeof children === \"object\" &&\n    !Array.isArray(children) &&\n    (children as JxMutableNode).$prototype === \"Array\"\n  ) {\n    n.children = [children as JxMutableNode];\n  }\n  if (Array.isArray(n.children)) {\n    for (const child of n.children) {\n      normalizeArrayChildren(child);\n    }\n  }\n  if (n.$prototype === \"Array\" && n.map && typeof n.map === \"object\") {\n    normalizeArrayChildren(n.map);\n  }\n  if (n.cases && typeof n.cases === \"object\") {\n    for (const caseDef of Object.values(n.cases)) {\n      normalizeArrayChildren(caseDef);\n    }\n  }\n  return node;\n}\n\n/**\n * Return the path to the parent element (strips trailing 'children' + index).\n *\n * @param {JxPath} path\n * @returns {JxPath | null}\n */\nexport function parentElementPath(path: JxPath) {\n  return path.length >= 2 ? path.slice(0, -2) : null;\n}\n\n/**\n * Return the child index (last segment of the path).\n *\n * @param {JxPath} path\n * @returns {string | number}\n */\nexport function childIndex(path: JxPath) {\n  return path.at(-1);\n}\n\n/**\n * Serialize a path to a string key for Map lookups.\n *\n * @param {JxPath} path\n * @returns {string}\n */\nexport function pathKey(path: JxPath) {\n  return path.join(\"/\");\n}\n\n/**\n * Compare two paths for equality.\n *\n * @param {JxPath | null} a\n * @param {JxPath | null} b\n * @returns {boolean}\n */\nexport function pathsEqual(a: JxPath | null, b: JxPath | null) {\n  if (a === b) {\n    return true;\n  }\n  if (!a || !b || a.length !== b.length) {\n    return false;\n  }\n  return a.every((v, i) => v === b[i]);\n}\n\n/**\n * Returns true if `path` is an ancestor of (or equal to) `descendant`.\n *\n * @param {JxPath} path\n * @param {JxPath} descendant\n * @returns {boolean}\n */\nexport function isAncestor(path: JxPath, descendant: JxPath) {\n  if (path.length > descendant.length) {\n    return false;\n  }\n  return path.every((v, i) => v === descendant[i]);\n}\n\n// ─── Tree flattening (for layer panel) ────────────────────────────────────────\n\n/**\n * Flatten a Jx document into an array of { node, path, depth, nodeType } rows. Walks static\n * children arrays, $map templates, and $switch cases.\n *\n * NodeType: 'element' (default) | 'map' | 'case' | 'case-ref'\n *\n * @param {JxMutableNode | string | number | boolean} doc\n * @param {JxPath} [path]\n * @param {number} [depth]\n * @returns {{\n *   node: JxMutableNode | string | number | boolean;\n *   path: JxPath;\n *   depth: number;\n *   nodeType: string;\n * }[]}\n */\nexport interface FlatRow {\n  node: JxMutableNode | string | number | boolean;\n  path: JxPath;\n  depth: number;\n  nodeType: string;\n}\n\nexport function flattenTree(\n  doc: JxMutableNode | string | number | boolean,\n  path: JxPath = [],\n  depth = 0,\n): FlatRow[] {\n  const rows: FlatRow[] = [];\n  collectRows(doc, path, depth, rows, false);\n  return rows;\n}\n\n/**\n * Pre-order walk that appends into `out`.\n *\n * Appending beats returning-and-spreading: `rows.push(...flattenTree(child))` copied every\n * descendant row once per ancestor level (O(n·depth) copies) and passed the whole subtree as\n * argument list, which throws `RangeError: too many arguments` on a large enough tree.\n *\n * `skipSelf` omits the node's own row and emits only its descendants — the `$switch` case branch\n * needs that, having already emitted a `case` row with its own nodeType.\n */\nfunction collectRows(\n  doc: JxMutableNode | string | number | boolean,\n  path: JxPath,\n  depth: number,\n  out: FlatRow[],\n  skipSelf: boolean,\n): void {\n  // Text node children: bare primitives get a \"text\" row\n  if (typeof doc === \"string\" || typeof doc === \"number\" || typeof doc === \"boolean\") {\n    if (!skipSelf) {\n      out.push({ depth, node: doc, nodeType: \"text\", path });\n    }\n    return;\n  }\n\n  // Array pseudo-element (repeater): a first-class node at its own path. Emit the \"map\" row, then\n  // Recurse into its single template at `[...path, \"map\"]`. This is reached both when the array is\n  // A member of a children array (path `[…, \"children\", i]`) and the legacy whole-children form\n  // (path `[…, \"children\"]`).\n  if ((doc as JxMutableNode).$prototype === \"Array\") {\n    if (!skipSelf) {\n      out.push({ depth, node: doc, nodeType: \"map\", path });\n    }\n    const mapDef = (doc as JxMutableNode).map;\n    if (mapDef && typeof mapDef === \"object\") {\n      collectRows(mapDef as JxMutableNode, [...path, \"map\"], depth + 1, out, false);\n    }\n    return;\n  }\n\n  if (!skipSelf) {\n    out.push({ depth, node: doc, nodeType: \"element\", path });\n  }\n\n  // Custom component instances without user-authored children are atomic in the layer tree\n  if (doc.$props && displayTagName(doc.tagName).includes(\"-\") && !Array.isArray(doc.children)) {\n    return;\n  }\n\n  const { children } = doc;\n\n  if (Array.isArray(children)) {\n    for (let i = 0; i < children.length; i++) {\n      const childPath = [...path, \"children\", i];\n      collectRows(children[i]!, childPath, depth + 1, out, false);\n    }\n  } else if (\n    children &&\n    typeof children === \"object\" &&\n    (children as JxMutableNode).$prototype === \"Array\"\n  ) {\n    // Legacy whole-children repeater: the array occupies the children slot itself.\n    collectRows(children as JxMutableNode, [...path, \"children\"], depth + 1, out, false);\n  }\n\n  // $switch — emit each case as a virtual child\n  if (doc.$switch && doc.cases && typeof doc.cases === \"object\") {\n    for (const [caseName, caseDef] of Object.entries(doc.cases)) {\n      const casePath = [...path, \"cases\", caseName];\n      if (caseDef && typeof caseDef === \"object\" && (caseDef as JxMutableNode).$ref) {\n        out.push({\n          depth: depth + 1,\n          node: caseDef as JxMutableNode,\n          nodeType: \"case-ref\",\n          path: casePath,\n        });\n      } else if (caseDef && typeof caseDef === \"object\") {\n        out.push({\n          depth: depth + 1,\n          node: caseDef as JxMutableNode,\n          nodeType: \"case\",\n          path: casePath,\n        });\n        // Recurse into case children — skipSelf, because the \"case\" row above already stands in for\n        // The case node itself (with its own nodeType).\n        collectRows(caseDef as JxMutableNode, casePath, depth + 2, out, true);\n      }\n    }\n  }\n}\n\n/**\n * Get a display label for a node (for layers + overlays).\n *\n * @param {JxMutableNode | null} node\n * @returns {string}\n */\nexport function nodeLabel(node: JxMutableNode | null) {\n  if (!node) {\n    return \"?\";\n  }\n  // $map container (Repeater)\n  if (node.$prototype === \"Array\") {\n    const { items } = node;\n    const ref = (isRef(items) ? items.$ref : undefined) || \"items\";\n    return `Repeater → ${ref}`;\n  }\n  if (node.$title) {\n    return node.$title;\n  }\n  if (node.$id) {\n    return node.$id;\n  }\n  if (node.tagName === \"slot\") {\n    const name = node.attributes?.name;\n    return typeof name === \"string\" && name.trim() ? `slot: ${name.trim()}` : \"slot\";\n  }\n  /* `displayTagName`, because a tag may be CHOSEN rather than written: this label reached the\n     Outline row, the Inspector's header and the jump bar, and a raw read rendered `[object Object]`\n     in all three. `a|div` is the honest answer — one element, tag decided at creation. */\n  const tag = displayTagName(node.tagName) || \"div\";\n  const suffix = node.$switch ? \" ⇆\" : \"\";\n  if (typeof node.textContent === \"string\" && node.textContent.length > 0) {\n    return `${tag} — ${node.textContent.slice(0, 24)}${suffix}`;\n  }\n  return tag + suffix;\n}\n\n// ─── Project state (persists across document switches) ────────────────────────\n//\n// Shape: { root, name, projectRoot, isSiteProject, projectConfig,\n//          Dirs: Map<string, DirEntry[]>, expanded: Set<string>,\n//          SelectedPath: string|null, searchQuery: string }\n// DirEntry: { name, path, type: \"file\"|\"directory\", size, modified }\n\nexport let projectState: ProjectState | null = null;\n\n/** @param {ProjectState | null} ps */\nexport function setProjectState(ps: ProjectState | null) {\n  projectState = ps;\n}\n\n/**\n * Return the current project state, asserting it is non-null. Only call when a project is known to\n * be loaded.\n *\n * @returns {ProjectState}\n */\nexport function requireProjectState() {\n  return projectState as ProjectState;\n}\n",
+    "/**\n * Strip `on*` event-handler bindings from a Jx document tree (returns a shallow-rebuilt copy). Used\n * to neutralize handlers before edit/design rendering so the canvas never wires live behavior, and\n * to drop `timing: \"server\"` state entries the canvas can't run.\n *\n * Lives in its own dependency-light module (it pulls only the pure `@jxsuite/schema/guards`\n * predicate) so the slim canvas-iframe subtree renderer can import it without dragging in the\n * editor's reactive `store.ts`; `store.ts` re-exports it for the legacy in-realm patcher.\n */\n\nimport { isEventBinding } from \"@jxsuite/schema/guards\";\nimport type { JxMutableNode } from \"@jxsuite/schema/types\";\n\n/** Strip all `on*` event-handler properties (and server-timed state) from a document tree. */\nexport function stripEventHandlers(node: JxMutableNode): JxMutableNode {\n  if (!node || typeof node !== \"object\") {\n    return node;\n  }\n  if (Array.isArray(node)) {\n    // Arrays of nodes round-trip element-wise; the array itself is not a node.\n    return node.map((n: JxMutableNode) => stripEventHandlers(n)) as unknown as JxMutableNode;\n  }\n  const out: Record<string, unknown> = {};\n  for (const [k, v] of Object.entries(node)) {\n    if (k.startsWith(\"on\") && isEventBinding(v)) {\n      continue;\n    }\n    if (k === \"children\") {\n      out.children = Array.isArray(v)\n        ? v.map((c: JxMutableNode) => stripEventHandlers(c))\n        : stripEventHandlers(v as JxMutableNode);\n    } else if (k === \"cases\" && typeof v === \"object\") {\n      const cases: Record<string, unknown> = {};\n      for (const [ck, cv] of Object.entries(v as Record<string, unknown>)) {\n        cases[ck] = stripEventHandlers(cv as JxMutableNode);\n      }\n      out.cases = cases;\n    } else if (k === \"state\" && typeof v === \"object\" && v !== null) {\n      const state: Record<string, unknown> = {};\n      for (const [sk, sv] of Object.entries(v as Record<string, unknown>)) {\n        if (sv && typeof sv === \"object\" && (sv as Record<string, unknown>).timing === \"server\") {\n          continue;\n        }\n        state[sk] = sv;\n      }\n      out.state = state;\n    } else if (k === \"style\" || k === \"attributes\" || k === \"$media\") {\n      out[k] = v;\n    } else {\n      out[k] = v;\n    }\n  }\n  return out;\n}\n",
+    "/// <reference lib=\"dom\" />\n/**\n * Store.js — Shared state hub for Jx Studio\n *\n * Every other studio module imports from this file for shared state, DOM refs, render\n * orchestration, and state.js re-exports. This prevents circular dependencies by keeping store.js\n * free of domain-specific imports.\n */\n\n// ─── Re-exports from state.js ────────────────────────────────────────────────\n\nimport { INPUT_DEBOUNCE } from \"./ui/timing\";\nimport type { JxPath } from \"./state\";\nimport type { Tab } from \"./tabs/tab\";\nimport type { JxMutableNode } from \"@jxsuite/schema/types\";\n\nexport {\n  getNodeAtPath,\n  childList,\n  flattenTree,\n  nodeLabel,\n  pathKey,\n  pathsEqual,\n  parentElementPath,\n  childIndex,\n  isAncestor,\n  projectState,\n  setProjectState,\n  requireProjectState,\n} from \"./state\";\n\n// ─── Shell element refs (populated by initShellRefs) ─────────────────────────\n\n/* There is no `canvasWrap` here, and there cannot be one.\n   It was `#canvas-wrap`, the shell's single stage, imported by six modules and read at ~30 sites —\n   each of which meant \"the pane I am acting on\" and got \"the pane that happens to be focused\". A\n   stage belongs to a pane (`canvas/canvas-surface.ts`), a pane's cell is built by\n   `panels/pane-grid.ts`, and every one of those readers now takes its surface. */\nexport let activityBar = null as unknown as HTMLElement;\nexport let leftPanel = null as unknown as HTMLElement;\nexport let rightPanel = null as unknown as HTMLElement;\nexport let toolbarEl = null as unknown as HTMLElement;\nexport let statusbarEl = null as unknown as HTMLElement;\n\nexport function initShellRefs() {\n  activityBar = document.querySelector(\"#activity-bar\") as HTMLElement;\n  leftPanel = document.querySelector(\"#left-panel\") as HTMLElement;\n  rightPanel = document.querySelector(\"#right-panel\") as HTMLElement;\n  toolbarEl = document.querySelector(\"#toolbar\") as HTMLElement;\n  statusbarEl = document.querySelector(\"#statusbar\") as HTMLElement;\n}\n\n// ─── Shared constants ────────────────────────────────────────────────────────\n\n/** Void elements that cannot accept children */\nexport const VOID_ELEMENTS = new Set([\n  \"area\",\n  \"base\",\n  \"br\",\n  \"col\",\n  \"embed\",\n  \"hr\",\n  \"img\",\n  \"input\",\n  \"link\",\n  \"meta\",\n  \"param\",\n  \"source\",\n  \"track\",\n  \"wbr\",\n]);\n\nexport const COMMON_SELECTORS = [\n  \":hover\",\n  \":focus\",\n  \":active\",\n  \":focus-within\",\n  \":focus-visible\",\n  \":disabled\",\n  \":first-child\",\n  \":last-child\",\n  \"::before\",\n  \"::after\",\n  \"::placeholder\",\n];\n\n/** @param {string} k */\nexport function isNestedSelector(k: string) {\n  return k.startsWith(\":\") || k.startsWith(\".\") || k.startsWith(\"&\") || k.startsWith(\"[\");\n}\n\n// ─── Shared utilities ────────────────────────────────────────────────────────\n\nconst _styleDebounceTimers = new Map<string, ReturnType<typeof setTimeout>>();\n\n/**\n * @param {string} prop\n * @param {number | undefined} ms Debounce delay; `undefined` takes the standard input debounce.\n * @param {(...args: unknown[]) => void} fn\n */\nexport function debouncedStyleCommit<A extends unknown[]>(\n  prop: string,\n  ms: number | undefined,\n  fn: (...args: A) => void,\n) {\n  const delay = ms ?? INPUT_DEBOUNCE;\n  return (...args: A) => {\n    clearTimeout(_styleDebounceTimers.get(prop));\n    _styleDebounceTimers.set(\n      prop,\n      setTimeout(() => {\n        _styleDebounceTimers.delete(prop);\n        fn(...args);\n      }, delay),\n    );\n  };\n}\n\n/** Cancel a pending debounced commit for the given prop key. */\nexport function cancelStyleDebounce(prop: string) {\n  clearTimeout(_styleDebounceTimers.get(prop));\n  _styleDebounceTimers.delete(prop);\n}\n\n// `stripEventHandlers` moved to ./utils/strip-events (dependency-light, shared with the iframe\n// Subtree renderer); re-exported here so existing `from \"../store\"` imports keep working.\nexport { stripEventHandlers } from \"./utils/strip-events\";\n\n// ─── Render orchestration ────────────────────────────────────────────────────\n\nconst _renderers = new Map<string, () => void>();\n\n/**\n * How many registered renderers are mid-paint right now.\n *\n * Condition 1 of the `probe.idle()` predicate (`services/idle.ts`, spec §13.5). A renderer is\n * declared `() => void`, but TypeScript happily assigns an `async` function to that type, so a\n * renderer that awaits keeps repainting long after `render()` returned. Counting the returned\n * thenable is what makes \"no queued lit render\" an answerable question instead of an assumption —\n * the alternative is a sleep, and a sleep cannot name what it is waiting for.\n */\nlet _rendersInFlight = 0;\n\n/** Renderers currently mid-paint — zero when the shell's DOM has caught up with its state. */\nexport function rendersInFlight(): number {\n  return _rendersInFlight;\n}\n\n/** Run one renderer, counting it as in-flight until it returns (or its promise settles). */\nfunction runRenderer(name: string, fn: () => void) {\n  _rendersInFlight += 1;\n  const done = () => {\n    _rendersInFlight -= 1;\n  };\n  let pending: PromiseLike<unknown> | null = null;\n  try {\n    const result = fn() as unknown;\n    if (typeof (result as PromiseLike<unknown> | null)?.then === \"function\") {\n      pending = result as PromiseLike<unknown>;\n    }\n  } catch (error) {\n    console.error(`Renderer \"${name}\" failed:`, error);\n  }\n  if (!pending) {\n    done();\n    return;\n  }\n  pending.then(done, (error: unknown) => {\n    console.error(`Renderer \"${name}\" failed:`, error);\n    done();\n  });\n}\n\n/**\n * Register a named renderer. Called at module import time by each module.\n *\n * @param {string} name\n * @param {() => void} fn\n */\nexport function registerRenderer(name: string, fn: () => void) {\n  _renderers.set(name, fn);\n}\n\n/** Call all registered renderers (full repaint). */\nexport function render() {\n  for (const [name, fn] of _renderers.entries()) {\n    runRenderer(name, fn);\n  }\n}\n\n/**\n * Call specific renderers by name.\n *\n * @param {...string} names\n */\nexport function renderOnly(...names: string[]) {\n  for (const name of names) {\n    const fn = _renderers.get(name);\n    if (!fn) {\n      continue;\n    }\n    runRenderer(name, fn);\n  }\n}\n\n// ─── Session dispatch ──────────────────────────────────────────────────────\n\n/* **Every dispatcher below takes the tab it writes, and none of them can find one on its own.**\n   All three used to open with `const tab = activeTab.value`, which made \"the document this\n   control is about\" and \"the document the keyboard happens to be in\" the same expression — the\n   defect that produced the Document Header card writing through focus, the zoom axis writing\n   through focus, the debounced Monaco commit writing through focus, and the whole pane context\n   bar writing through focus. Four instances, four audits, no gate: while the shell had one stage\n   the two readings could not disagree, so nothing could observe the difference.\n\n   `store.ts` is where they could not disagree, so `store.ts` is where the shape is fixed. There is\n   no `activeTab` import in this file and no zero-argument variant of any of these: a caller that\n   means the focused pane spells `activeTab.value` at its own call site, where a reviewer and\n   `scripts/check-pane-singletons.ts` can both see it, and a caller drawn FOR a pane passes the tab\n   it was drawn for. */\n\n/**\n * Dispatch a session-only state update (selection, hover, ui) into `tab`.\n *\n * @param {Tab | null} tab — the tab this update is about. `null` is a no-op.\n * @param {object} patch — partial session object, e.g. { ui: { zoom: 2 } }\n */\nexport function updateSession(\n  tab: Tab | null,\n  patch: {\n    /** The whole selection SET — `[]` clears it. Widened with `session.selection` itself (§6.5). */\n    selection?: JxPath[];\n    hover?: JxPath | null;\n    clipboard?: JxMutableNode | null;\n    ui?: Record<string, unknown>;\n    canvas?: Record<string, unknown>;\n  },\n) {\n  if (tab) {\n    if (patch.selection !== undefined) {\n      tab.session.selection = patch.selection;\n    }\n    if (patch.hover !== undefined) {\n      tab.session.hover = patch.hover as JxPath | null;\n    }\n    if (patch.clipboard !== undefined) {\n      tab.session.clipboard = patch.clipboard!;\n    }\n    if (patch.ui) {\n      for (const [k, v] of Object.entries(patch.ui)) {\n        (tab.session.ui as unknown as Record<string, unknown>)[k] = v;\n      }\n    }\n    if (patch.canvas) {\n      for (const [k, v] of Object.entries(patch.canvas)) {\n        (tab.session.canvas as unknown as Record<string, unknown>)[k] = v;\n      }\n    }\n  }\n}\n\n/**\n * Update a single UI field on `tab`.\n *\n * @param {Tab | null} tab — the tab this field belongs to. `null` is a no-op.\n * @param {string} field\n * @param {unknown} value\n */\nexport function updateUi(tab: Tab | null, field: string, value: unknown) {\n  if (tab) {\n    (tab.session.ui as unknown as Record<string, unknown>)[field] = value;\n  }\n}\n\n/**\n * Update `tab`'s canvas async state (status, scope, error).\n *\n * @param {Tab | null} tab — the tab whose stage produced this state. `null` is a no-op.\n * @param {object} patch\n */\nexport function updateCanvas(tab: Tab | null, patch: Record<string, unknown>) {\n  if (tab) {\n    for (const [k, v] of Object.entries(patch)) {\n      (tab.session.canvas as Record<string, unknown>)[k] = v;\n    }\n  }\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "147E616828B71FA964756E2164756E21",
+  "names": []
+}