@jxsuite/studio 2.4.3 → 4.0.0

package/dist/chunks/studio-2zkz8evn.js

@@ -0,0 +1,3163 @@
+import {
+  commitTabBuffers
+} from "./studio-wcy8trfx.js";
+import {
+  computed,
+  effect,
+  effectScope,
+  notify,
+  onScopeDispose,
+  reactive,
+  toRaw
+} from "./studio-xrapxwwc.js";
+import {
+  applyDocOpToDoc,
+  childArray,
+  cloneValue
+} from "./studio-5ehhackm.js";
+import {
+  childIndex,
+  getNodeAtPath,
+  isAncestor,
+  normalizeArrayChildren,
+  parentElementPath,
+  pathsEqual,
+  projectState
+} from "./studio-p4ngc046.js";
+import {
+  ensureNestedStyle,
+  getNestedStyle,
+  isEventBinding
+} from "./studio-q7v10cg2.js";
+import {
+  defaultContentFormat,
+  formatByName,
+  formatForPath
+} from "./studio-eenfkt4e.js";
+import {
+  getPlatform
+} from "./studio-9ab8gqsm.js";
+import {
+  __require
+} from "./studio-a0tswy0w.js";
+
+// ../schema/src/locale.ts
+var RTL_SCRIPTS = new Set([
+  "Adlm",
+  "Arab",
+  "Aran",
+  "Armi",
+  "Avst",
+  "Cprt",
+  "Egyd",
+  "Egyh",
+  "Elym",
+  "Gara",
+  "Hatr",
+  "Hebr",
+  "Hluw",
+  "Hung",
+  "Khar",
+  "Lydi",
+  "Mand",
+  "Mani",
+  "Mend",
+  "Merc",
+  "Mero",
+  "Narb",
+  "Nbat",
+  "Nkoo",
+  "Orkh",
+  "Palm",
+  "Phli",
+  "Phlp",
+  "Phnx",
+  "Prti",
+  "Rohg",
+  "Samr",
+  "Sarb",
+  "Sogd",
+  "Sogo",
+  "Syrc",
+  "Thaa",
+  "Todr",
+  "Yezi"
+]);
+var LANGUAGE_TAG_PATTERN = "^[A-Za-z]{2,8}(-[A-Za-z0-9]{1,8})*$";
+function canonicalizeLocale(tag) {
+  if (typeof tag !== "string" || tag.trim() === "") {
+    return null;
+  }
+  try {
+    return new Intl.Locale(tag.trim()).toString();
+  } catch {
+    return null;
+  }
+}
+function isWellFormedLocale(tag) {
+  return canonicalizeLocale(tag) !== null;
+}
+function localeDirection(tag) {
+  const canonical = canonicalizeLocale(tag);
+  if (canonical === null) {
+    return "ltr";
+  }
+  const locale = new Intl.Locale(canonical);
+  const script = locale.script ?? locale.maximize().script;
+  return script !== undefined && RTL_SCRIPTS.has(script) ? "rtl" : "ltr";
+}
+function localeLabel(tag) {
+  const canonical = canonicalizeLocale(tag);
+  if (canonical === null) {
+    return typeof tag === "string" ? tag : "";
+  }
+  return new Intl.DisplayNames([canonical], { type: "language" }).of(canonical) ?? canonical;
+}
+var DEFAULT_ROUTING = "prefix-except-default";
+function resolveI18n(projectConfig) {
+  const raw = projectConfig.i18n;
+  const errors = [];
+  if (!raw || typeof raw !== "object") {
+    return { errors, i18n: null };
+  }
+  const declared = Array.isArray(raw.locales) ? raw.locales : [];
+  const locales = [];
+  for (const tag of declared) {
+    const canonical = canonicalizeLocale(tag);
+    if (canonical === null) {
+      errors.push(`i18n.locales: "${String(tag)}" is not a well-formed BCP 47 language tag.`);
+      continue;
+    }
+    if (!locales.includes(canonical)) {
+      locales.push(canonical);
+    }
+  }
+  const defaultLocale = canonicalizeLocale(raw.defaultLocale) ?? locales[0] ?? null;
+  if (raw.defaultLocale !== undefined && canonicalizeLocale(raw.defaultLocale) === null) {
+    errors.push(`i18n.defaultLocale: "${String(raw.defaultLocale)}" is not a well-formed BCP 47 language tag.`);
+  }
+  if (defaultLocale === null) {
+    errors.push("i18n is declared with no usable locale — set `defaultLocale` or `locales`.");
+    return { errors, i18n: null };
+  }
+  if (!locales.includes(defaultLocale)) {
+    locales.unshift(defaultLocale);
+  }
+  const routing = raw.routing === "prefix-always" || raw.routing === "prefix-except-default" ? raw.routing : DEFAULT_ROUTING;
+  return { errors, i18n: { defaultLocale, locales, routing } };
+}
+function localeOfPath(path, i18n) {
+  const index = localeSegment(pathSegments(path), i18n);
+  if (index === -1 || i18n === null) {
+    return null;
+  }
+  return canonicalizeLocale(pathSegments(path)[index]);
+}
+function servedLocaleOfPath(path, i18n) {
+  const own = localeOfPath(path, i18n);
+  if (own !== null || i18n === null || i18n.routing !== "prefix-except-default") {
+    return own;
+  }
+  return pathSegments(path)[0] === "pages" ? i18n.defaultLocale : null;
+}
+function translationKeyOfPath(path, i18n) {
+  const segments = pathSegments(path);
+  const index = localeSegment(segments, i18n);
+  return index === -1 ? segments.join("/") : segments.filter((_, i) => i !== index).join("/");
+}
+function translationPathFor(path, locale, i18n) {
+  if (i18n === null) {
+    return null;
+  }
+  const canonical = canonicalizeLocale(locale);
+  if (canonical === null || !i18n.locales.includes(canonical)) {
+    return null;
+  }
+  const segments = pathSegments(path);
+  const existing = localeSegment(segments, i18n);
+  const slot = existing === -1 ? localeSlot(segments) : existing;
+  if (slot === -1) {
+    return null;
+  }
+  const bare = existing === -1 ? segments : segments.filter((_, i) => i !== existing);
+  if (canonical === i18n.defaultLocale && i18n.routing === "prefix-except-default") {
+    return bare.join("/");
+  }
+  return bare.toSpliced(slot, 0, canonical.toLowerCase()).join("/");
+}
+function pathSegments(path) {
+  return path.replace(/^\.\//, "").split("/").filter(Boolean);
+}
+function localeSegment(segments, i18n) {
+  if (i18n === null) {
+    return -1;
+  }
+  return segments.findIndex((segment) => {
+    const canonical = canonicalizeLocale(segment);
+    return canonical !== null && i18n.locales.includes(canonical);
+  });
+}
+function localeSlot(segments) {
+  if (segments[0] === "pages" && segments.length > 1) {
+    return 1;
+  }
+  if (segments[0] === "content" && segments.length > 2) {
+    return 2;
+  }
+  return -1;
+}
+
+// src/content/collection-match.ts
+var LOCALE_PLACEHOLDER = "{locale}";
+function escapeLiteral(part) {
+  return part.replaceAll(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`);
+}
+function normalize(path) {
+  return path.replaceAll("\\", "/").replace(/^\.\//, "").replace(/\/+$/, "");
+}
+function configOf(config) {
+  return config ?? projectState?.projectConfig ?? null;
+}
+function contentSection(config) {
+  return config?.content ?? {};
+}
+function declaredLocales(config) {
+  const locales = resolveI18n(config ?? {}).i18n?.locales ?? [];
+  return locales.length > 0 ? [...locales] : null;
+}
+function isFileBacked(source) {
+  if (source.endsWith("/")) {
+    return false;
+  }
+  const base = source.slice(source.lastIndexOf("/") + 1);
+  return /\.[a-z\d]+$/i.test(base);
+}
+function resolveExt(def) {
+  if (def.format === "json") {
+    return { ext: ".json", unresolvedFormat: null };
+  }
+  if (def.format === undefined || def.format === "") {
+    return { ext: defaultContentFormat()?.extensions[0] ?? ".json", unresolvedFormat: null };
+  }
+  const format = formatByName(def.format);
+  return format?.extensions[0] === undefined ? { ext: null, unresolvedFormat: def.format } : { ext: format.extensions[0], unresolvedFormat: null };
+}
+function sourcePattern(source, locales) {
+  const segment = locales === null ? "[^/]+" : `(?:${locales.map((locale) => escapeLiteral(locale)).join("|")})`;
+  const body = normalize(source).split(LOCALE_PLACEHOLDER).map((part) => escapeLiteral(part)).join(segment);
+  return new RegExp(`^${body}(?:/|$)`, "i");
+}
+function matchedRoot(source, target, locales) {
+  const hit = sourcePattern(source, locales).exec(target);
+  if (!hit) {
+    return null;
+  }
+  return hit[0].replace(/\/$/, "");
+}
+function sourceWeight(source) {
+  return normalize(source).replaceAll(LOCALE_PLACEHOLDER, "").length;
+}
+function collectionForDirectory(dir, config) {
+  if (dir === null || dir === undefined || dir === "") {
+    return null;
+  }
+  const resolved = configOf(config);
+  const locales = declaredLocales(resolved);
+  const target = normalize(dir);
+  let best = null;
+  let bestWeight = -1;
+  for (const [name, def] of Object.entries(contentSection(resolved))) {
+    const { source } = def;
+    if (source === undefined || source === "" || isFileBacked(source)) {
+      continue;
+    }
+    const weight = sourceWeight(source);
+    if (weight <= bestWeight) {
+      continue;
+    }
+    const root = matchedRoot(source, target, locales);
+    if (root === null) {
+      continue;
+    }
+    best = {
+      def,
+      dir: target,
+      fileBacked: false,
+      isSourceRoot: target.length === root.length,
+      name,
+      ...resolveExt(def)
+    };
+    bestWeight = weight;
+  }
+  return best;
+}
+function collectionForFile(path, config) {
+  if (path === null || path === undefined || path === "") {
+    return null;
+  }
+  const resolved = configOf(config);
+  const target = normalize(path);
+  const lower = target.toLowerCase();
+  for (const [name, def] of Object.entries(contentSection(resolved))) {
+    const { source } = def;
+    if (source === undefined || source === "" || !isFileBacked(source)) {
+      continue;
+    }
+    const src = normalize(source).toLowerCase();
+    if (lower === src || lower.endsWith(`/${src}`)) {
+      return {
+        def,
+        dir: target.includes("/") ? target.slice(0, target.lastIndexOf("/")) : ".",
+        fileBacked: true,
+        isSourceRoot: false,
+        name,
+        ...resolveExt(def)
+      };
+    }
+  }
+  return collectionForDirectory(target.includes("/") ? target.slice(0, target.lastIndexOf("/")) : ".", resolved);
+}
+
+// src/utils/studio-utils.ts
+function camelToKebab(str) {
+  return str.replaceAll(/[A-Z]/g, (c) => `-${c.toLowerCase()}`);
+}
+function camelToLabel(prop) {
+  return prop.replaceAll(/([A-Z])/g, " $1").replace(/^./, (c) => c.toUpperCase());
+}
+function toCamelCase(str) {
+  return str.replaceAll(/[^a-zA-Z0-9]+(.)?/g, (_, c) => c ? c.toUpperCase() : "").replace(/^[A-Z]/, (c) => c.toLowerCase());
+}
+function kebabToLabel(val) {
+  return val.replaceAll(/(^|-)(\w)/g, (_, sep, c) => (sep ? " " : "") + c.toUpperCase());
+}
+function propLabel(entry, prop) {
+  return entry?.$label || camelToLabel(prop);
+}
+function attrLabel(entry, attr) {
+  if (entry?.$label) {
+    return entry.$label;
+  }
+  if (attr.includes("-")) {
+    return attr.replaceAll(/(^|-)(\w)/g, (_, sep, c) => (sep ? " " : "") + c.toUpperCase());
+  }
+  return camelToLabel(attr);
+}
+function abbreviateValue(val) {
+  const map = {
+    baseline: "base",
+    column: "col",
+    "column-reverse": "col-r",
+    contents: "cnt",
+    "flex-end": "end",
+    "flex-start": "start",
+    "flow-root": "flow",
+    inline: "inl",
+    "inline-block": "i-blk",
+    "inline-flex": "i-flx",
+    "inline-grid": "i-grd",
+    normal: "norm",
+    nowrap: "no-wr",
+    "row-reverse": "row-r",
+    "space-around": "arnd",
+    "space-between": "betw",
+    "space-evenly": "even",
+    stretch: "str",
+    "wrap-reverse": "wr-rev"
+  };
+  return map[val] || val;
+}
+function isMediaFormat(format) {
+  return format === "image" || format === "uri-reference";
+}
+function inferInputType(entry) {
+  if (entry.$shorthand === true) {
+    return "shorthand";
+  }
+  if (entry.$input === "button-group") {
+    return "button-group";
+  }
+  if (entry.$input === "media") {
+    return "media";
+  }
+  if (entry.format === "color") {
+    return "color";
+  }
+  if (isMediaFormat(entry.format)) {
+    return "media";
+  }
+  if (entry.$units !== undefined) {
+    return "number-unit";
+  }
+  if (entry.type === "number") {
+    return "number";
+  }
+  if (Array.isArray(entry.enum)) {
+    return "select";
+  }
+  if (Array.isArray(entry.examples) || Array.isArray(entry.presets)) {
+    return "combobox";
+  }
+  return "text";
+}
+function findContentTypeSchema(documentPath, projectConfig) {
+  if (!documentPath || !projectConfig?.content) {
+    return null;
+  }
+  const match = collectionForFile(documentPath, projectConfig);
+  if (!match || !match.def.schema) {
+    return null;
+  }
+  if (!match.fileBacked) {
+    const ext = match.ext ?? defaultContentFormat()?.extensions[0] ?? ".json";
+    if (!documentPath.toLowerCase().endsWith(ext.toLowerCase())) {
+      return null;
+    }
+  }
+  return { name: match.name, schema: match.def.schema };
+}
+function friendlyNameToVar(name, prefix) {
+  const slug = name.trim().toLowerCase().replaceAll(/[^a-z0-9\s-]/g, "").replaceAll(/\s+/g, "-").replaceAll(/-+/g, "-").replaceAll(/^-|-$/g, "");
+  if (!slug) {
+    return "";
+  }
+  return `${prefix}${slug}`;
+}
+function varDisplayName(varName, prefix) {
+  return varName.replace(new RegExp(`^${prefix.replaceAll(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`)}`), "").replace(/^--/, "").replaceAll("-", " ").replaceAll(/\b\w/g, (c) => c.toUpperCase()) || varName;
+}
+function parseCemType(typeText) {
+  if (!typeText) {
+    return { kind: "text" };
+  }
+  const t = typeText.trim().replaceAll(/\s*\|\s*undefined\b/g, "").trim();
+  if (t === "boolean") {
+    return { kind: "boolean" };
+  }
+  if (t === "number") {
+    return { kind: "number" };
+  }
+  const enumMatch = t.match(/^'[^']*'(\s*\|\s*'[^']*')+$/);
+  if (enumMatch) {
+    const options = [...t.matchAll(/'([^']*)'/g)].map((m) => m[1]);
+    return { kind: "combobox", options };
+  }
+  return { kind: "text" };
+}
+function jsonClone(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+
+// src/tabs/selection.ts
+function primarySelection(selection) {
+  return selection && selection.length > 0 ? selection.at(-1) : null;
+}
+function selectionAnchor(selection) {
+  return selection && selection.length > 0 ? selection[0] : null;
+}
+function isSelected(selection, path) {
+  if (!path || !selection) {
+    return false;
+  }
+  return selection.some((p) => pathsEqual(p, path));
+}
+function cloneSelection(paths) {
+  return clonePaths(paths);
+}
+function clonePaths(paths) {
+  const out = [];
+  for (const path of paths) {
+    out.push([...path]);
+  }
+  return out;
+}
+function toggleSelected(selection, path) {
+  if (isSelected(selection, path)) {
+    return clonePaths(selection.filter((p) => !pathsEqual(p, path)));
+  }
+  return [...clonePaths(selection), [...path]];
+}
+function rangeSelection(rows, anchor, target) {
+  const to = rows.findIndex((p) => pathsEqual(p, target));
+  const from = anchor ? rows.findIndex((p) => pathsEqual(p, anchor)) : -1;
+  if (to === -1 || from === -1) {
+    return [[...target]];
+  }
+  const slice = from <= to ? rows.slice(from, to + 1) : rows.slice(to, from + 1).toReversed();
+  return clonePaths(slice);
+}
+function pruneSelection(selection, removed) {
+  return clonePaths(selection.filter((p) => !isAncestor(removed, p)));
+}
+function comparePaths(a, b) {
+  const len = Math.min(a.length, b.length);
+  for (let i = 0;i < len; i++) {
+    const x = a[i];
+    const y = b[i];
+    if (x === y) {
+      continue;
+    }
+    if (typeof x === "number" && typeof y === "number") {
+      return x - y;
+    }
+    return String(x) < String(y) ? -1 : 1;
+  }
+  return a.length - b.length;
+}
+function topLevelSelection(selection) {
+  return clonePaths(selection.filter((p) => !selection.some((q) => !pathsEqual(q, p) && isAncestor(q, p))));
+}
+function isSpliceablePath(path) {
+  return path.at(-2) === "children" && typeof path.at(-1) === "number";
+}
+function structuralBatch(selection) {
+  return topLevelSelection(selection).filter((path) => isSpliceablePath(path)).toSorted((a, b) => comparePaths(b, a));
+}
+function uniquePaths(paths) {
+  const out = [];
+  for (const path of paths) {
+    if (!out.some((p) => pathsEqual(p, path))) {
+      out.push([...path]);
+    }
+  }
+  return out;
+}
+function unifyValues(values) {
+  if (values.length === 0) {
+    return { mixed: false, value: undefined };
+  }
+  const first = values[0];
+  const key = JSON.stringify(first ?? null);
+  for (let i = 1;i < values.length; i++) {
+    if (JSON.stringify(values[i] ?? null) !== key) {
+      return { mixed: true, value: undefined };
+    }
+  }
+  return { mixed: false, value: first };
+}
+// src/tabs/patch-ops.ts
+var _consumer = null;
+function setPatchConsumer(consumer) {
+  _consumer = consumer;
+}
+function getPatchConsumer() {
+  return _consumer;
+}
+var _recording = null;
+var _docOps = null;
+var _fmOps = null;
+var _invertible = true;
+function beginRecording() {
+  _recording = [];
+  _docOps = [];
+  _fmOps = [];
+  _invertible = true;
+}
+function recordPatch(op) {
+  if (_recording) {
+    _recording.push(op);
+  }
+}
+function recordDocOp(pair) {
+  if (_docOps) {
+    _docOps.push(pair);
+  }
+}
+function recordFmOp(op) {
+  if (_fmOps) {
+    _fmOps.push(op);
+  }
+}
+function endRecording() {
+  const record = {
+    docOps: _docOps ?? [],
+    fmOps: _fmOps ?? [],
+    invertible: _invertible,
+    ops: _recording ?? []
+  };
+  _recording = null;
+  _docOps = null;
+  _fmOps = null;
+  _invertible = true;
+  return record;
+}
+
+// src/tabs/transact.ts
+var HISTORY_LIMIT = 100;
+var CHECKPOINT_INTERVAL = 20;
+function patchHistoryEnabled() {
+  try {
+    return typeof localStorage === "undefined" || !localStorage.getItem("jx-legacy-history");
+  } catch {
+    return true;
+  }
+}
+function setKeyPair(path, key, before, after) {
+  return {
+    forward: { key, op: "set-key", path, value: after },
+    inverse: { key, op: "set-key", path, value: before }
+  };
+}
+function shiftPrefixedIndex(parentPath, path, spliceIndex, delta, inclusive) {
+  const d = parentPath.length;
+  const isProperPrefix = d < path.length && parentPath.every((seg, i) => seg === path[i]);
+  if (!isProperPrefix || path[d] !== "children" || typeof path[d + 1] !== "number") {
+    return path;
+  }
+  const idx = path[d + 1];
+  if (inclusive ? idx < spliceIndex : idx <= spliceIndex) {
+    return path;
+  }
+  const shifted = [...path];
+  shifted[d + 1] = idx + delta;
+  return shifted;
+}
+var _transactObserver = null;
+function setTransactObserver(fn) {
+  _transactObserver = fn;
+}
+var _transactGate = null;
+function setTransactGate(fn) {
+  _transactGate = fn;
+}
+function rollbackFailedTransaction(tab, record, selectionBefore, dirtyBefore) {
+  for (let i = record.docOps.length - 1;i >= 0; i--) {
+    applyDocOpToDoc(tab.doc.document, toRaw(record.docOps[i].inverse));
+  }
+  for (let i = record.fmOps.length - 1;i >= 0; i--) {
+    const op = record.fmOps[i];
+    applyFmState(tab, op.field, op.before);
+  }
+  tab.doc.document = { ...toRaw(tab.doc.document) };
+  tab.session.selection = selectionBefore;
+  tab.doc.dirty = dirtyBefore;
+}
+function transactDoc(tab, mutationFn, {
+  skipHistory = false,
+  origin = "user",
+  coalesceKey = null
+} = {}) {
+  if (!tab) {
+    return false;
+  }
+  if (origin !== "remote" && _transactGate?.(tab, origin)) {
+    return false;
+  }
+  const selectionBefore = cloneSelection(tab.session.selection);
+  const dirtyBefore = tab.doc.dirty;
+  beginRecording();
+  let record;
+  let failure = null;
+  try {
+    mutationFn(tab);
+  } catch (error) {
+    failure = { error };
+  } finally {
+    record = endRecording();
+  }
+  if (failure) {
+    rollbackFailedTransaction(tab, record, selectionBefore, dirtyBefore);
+    throw failure.error;
+  }
+  const raw = toRaw(tab.doc.document);
+  const newRef = { ...raw };
+  const consumer = getPatchConsumer();
+  const verdict = consumer === null ? { patchable: false, reason: "no-patch-consumer" } : record.ops.length === 0 ? { patchable: false, reason: "unrecorded-mutation" } : consumer.classify(tab, record.ops);
+  if (verdict.patchable) {
+    consumer.markConsumed(newRef, tab);
+  }
+  tab.doc.document = newRef;
+  if (verdict.patchable) {
+    try {
+      consumer.apply(tab, record.ops, record);
+    } catch (error) {
+      consumer.escalate(`patch-apply-failed: ${error instanceof Error ? error.message : String(error)}`, tab);
+    }
+  }
+  if (!skipHistory && !_batchTab) {
+    pushHistoryEntry(tab, raw, record, selectionBefore, coalesceKey);
+  }
+  tab.doc.dirty = true;
+  _transactObserver?.(tab, record, origin);
+  return true;
+}
+function pushHistoryEntry(tab, raw, record, selectionBefore, coalesceKey = null) {
+  const truncated = tab.history.snapshots.slice(0, tab.history.index + 1);
+  const useOps = patchHistoryEnabled() && record.invertible && (record.docOps.length > 0 || record.fmOps.length > 0);
+  const prev = truncated.at(-1);
+  if (coalesceKey && useOps && prev && prev.coalesceKey === coalesceKey && prev.inverseOps) {
+    prev.forwardOps = [...prev.forwardOps ?? [], ...record.docOps.map((pair) => pair.forward)];
+    prev.inverseOps = [...prev.inverseOps, ...record.docOps.map((pair) => pair.inverse)];
+    prev.selection = cloneSelection(tab.session.selection);
+    if (prev.document) {
+      prev.document = jsonClone(raw);
+    }
+    tab.history.snapshots = truncated;
+    tab.history.index = truncated.length - 1;
+    return;
+  }
+  const needCheckpoint = !useOps || truncated.length % CHECKPOINT_INTERVAL === 0;
+  truncated.push({
+    document: needCheckpoint ? jsonClone(raw) : null,
+    fmOps: useOps && record.fmOps.length > 0 ? record.fmOps : null,
+    forwardOps: useOps ? record.docOps.map((p) => p.forward) : null,
+    inverseOps: useOps ? record.docOps.map((p) => p.inverse) : null,
+    coalesceKey,
+    selection: cloneSelection(tab.session.selection),
+    selectionBefore
+  });
+  if (truncated.length > HISTORY_LIMIT) {
+    if (!truncated[1].document) {
+      truncated[1].document = materializeState(truncated, 1);
+    }
+    truncated.shift();
+  }
+  tab.history.snapshots = truncated;
+  tab.history.index = truncated.length - 1;
+}
+function materializeState(snapshots, target) {
+  let base = target;
+  while (base >= 0 && !snapshots[base].document) {
+    base -= 1;
+  }
+  if (base < 0) {
+    throw new Error("history-missing-checkpoint");
+  }
+  const doc = jsonClone(snapshots[base].document);
+  for (let i = base + 1;i <= target; i++) {
+    for (const op of snapshots[i].forwardOps ?? []) {
+      applyDocOpToDoc(doc, op);
+    }
+  }
+  return doc;
+}
+function transact(tab, fn, opts) {
+  return transactDoc(tab, (t) => fn(t.doc.document), opts);
+}
+function applyExternalDocOps(tab, ops) {
+  transactDoc(tab, (t) => {
+    for (const op of ops) {
+      applyDocOp(t, op);
+    }
+  }, { origin: "remote", skipHistory: true });
+}
+var DOC_META_KEYS = new Set(["state", "$media", "$head", "$elements", "imports", "$layout"]);
+function applyDocOp(tab, op) {
+  const prev = op.op === "set-key" ? getNodeAtPath(tab.doc.document, op.path)?.[op.key] : null;
+  applyDocOpToDoc(tab.doc.document, op);
+  recordDocOp({ forward: op, inverse: op });
+  switch (op.op) {
+    case "set-key": {
+      if (DOC_META_KEYS.has(op.key)) {
+        recordPatch({ key: op.key, op: "doc-meta" });
+      } else if (op.key === "style") {
+        recordPatch({ op: "set-style", path: op.path });
+      } else if (op.key === "textContent") {
+        recordPatch({ op: "set-text", path: op.path });
+      } else if (op.key === "attributes" || op.key === "cases" || op.key === "$props") {
+        recordPatch({ op: "replace", path: op.path });
+      } else {
+        const isEvent = op.key.startsWith("on") && (isEventBinding(op.value) || isEventBinding(prev));
+        recordPatch({ isEvent, key: op.key, op: "set-prop", path: op.path });
+      }
+      return;
+    }
+    case "insert-child": {
+      recordPatch({ index: op.index, op: "insert", parentPath: op.parentPath });
+      return;
+    }
+    case "remove-child": {
+      recordPatch({ op: "remove", path: [...op.parentPath, "children", op.index] });
+      return;
+    }
+    case "set-child": {
+      recordPatch({ op: "replace", path: [...op.parentPath, "children", op.index] });
+      return;
+    }
+    case "move-child": {
+      recordPatch({
+        fromPath: [...op.fromParentPath, "children", op.fromIndex],
+        op: "move",
+        toIndex: op.toIndex,
+        toParentPath: op.toParentPath
+      });
+      break;
+    }
+    default: {
+      break;
+    }
+  }
+}
+var _batchTab = null;
+var _batchEndNotifier = null;
+function setBatchEndNotifier(fn) {
+  _batchEndNotifier = fn;
+}
+function beginBatch(tab) {
+  _batchTab = tab;
+}
+function endBatch() {
+  const tab = _batchTab;
+  if (tab && !_historyDelegates.has(tab)) {
+    const raw = toRaw(tab.doc.document);
+    const snapshot = {
+      document: jsonClone(raw),
+      selection: cloneSelection(tab.session.selection)
+    };
+    const truncated = tab.history.snapshots.slice(0, tab.history.index + 1);
+    truncated.push(snapshot);
+    if (truncated.length > HISTORY_LIMIT) {
+      truncated.shift();
+    }
+    tab.history.snapshots = truncated;
+    tab.history.index = truncated.length - 1;
+  }
+  _batchTab = null;
+  if (tab) {
+    _batchEndNotifier?.(tab);
+  }
+}
+function isBatching() {
+  return _batchTab !== null;
+}
+function batchTab() {
+  return _batchTab;
+}
+var _historyDelegates = new WeakMap;
+function setHistoryDelegate(tab, delegate) {
+  if (delegate) {
+    _historyDelegates.set(tab, delegate);
+  } else {
+    _historyDelegates.delete(tab);
+  }
+}
+function canUndo(tab) {
+  const delegate = _historyDelegates.get(tab);
+  return delegate ? delegate.canUndo(tab) : tab.history.index > 0;
+}
+function canRedo(tab) {
+  const delegate = _historyDelegates.get(tab);
+  return delegate ? delegate.canRedo(tab) : tab.history.index < tab.history.snapshots.length - 1;
+}
+function restoreState(tab, index) {
+  const { snapshots } = tab.history;
+  tab.doc.document = materializeState(snapshots, index);
+  const snap = snapshots[index];
+  tab.session.selection = cloneSelection(toRaw(snap.selection));
+}
+function assertHistoryConsistency(tab, index) {
+  try {
+    if (typeof localStorage === "undefined" || !localStorage.getItem("jx-canvas-debug")) {
+      return;
+    }
+  } catch {
+    return;
+  }
+  const expected = JSON.stringify(materializeState(tab.history.snapshots, index));
+  const actual = JSON.stringify(jsonClone(toRaw(tab.doc.document)));
+  if (expected !== actual) {
+    console.error("jx history: ops-based undo/redo diverged from checkpoint replay", {
+      index
+    });
+  }
+}
+function undo(tab) {
+  const delegate = _historyDelegates.get(tab);
+  if (delegate) {
+    delegate.undo(tab);
+    return;
+  }
+  if (tab.history.index <= 0) {
+    return;
+  }
+  const entry = tab.history.snapshots[tab.history.index];
+  const inverseOps = patchHistoryEnabled() ? entry.inverseOps : null;
+  const fmOps = patchHistoryEnabled() ? entry.fmOps : null;
+  if (inverseOps && inverseOps.length > 0 || fmOps && fmOps.length > 0) {
+    const applied = transactDoc(tab, (t) => {
+      if (inverseOps) {
+        for (let i = inverseOps.length - 1;i >= 0; i--) {
+          applyDocOp(t, toRaw(inverseOps[i]));
+        }
+      }
+      if (fmOps) {
+        for (let i = fmOps.length - 1;i >= 0; i--) {
+          const op = toRaw(fmOps[i]);
+          applyFmState(t, op.field, op.before);
+        }
+      }
+    }, { origin: "history", skipHistory: true });
+    if (!applied) {
+      return;
+    }
+    tab.session.selection = cloneSelection(toRaw(entry.selectionBefore ?? []));
+    tab.history.index -= 1;
+    assertHistoryConsistency(tab, tab.history.index);
+  } else {
+    tab.history.index -= 1;
+    restoreState(tab, tab.history.index);
+  }
+  tab.doc.dirty = true;
+}
+function redo(tab) {
+  const delegate = _historyDelegates.get(tab);
+  if (delegate) {
+    delegate.redo(tab);
+    return;
+  }
+  if (tab.history.index >= tab.history.snapshots.length - 1) {
+    return;
+  }
+  const entry = tab.history.snapshots[tab.history.index + 1];
+  const forwardOps = patchHistoryEnabled() ? entry.forwardOps : null;
+  const fmOps = patchHistoryEnabled() ? entry.fmOps : null;
+  if (forwardOps && forwardOps.length > 0 || fmOps && fmOps.length > 0) {
+    const applied = transactDoc(tab, (t) => {
+      if (forwardOps) {
+        for (const op of forwardOps) {
+          applyDocOp(t, toRaw(op));
+        }
+      }
+      if (fmOps) {
+        for (const op of fmOps) {
+          const raw = toRaw(op);
+          applyFmState(t, raw.field, raw.after);
+        }
+      }
+    }, { origin: "history", skipHistory: true });
+    if (!applied) {
+      return;
+    }
+    tab.session.selection = cloneSelection(toRaw(entry.selection));
+    tab.history.index += 1;
+    assertHistoryConsistency(tab, tab.history.index);
+  } else {
+    tab.history.index += 1;
+    restoreState(tab, tab.history.index);
+  }
+  tab.doc.dirty = true;
+}
+function mutateInsertNode(tab, parentPath, index, nodeDef) {
+  const parent = getNodeAtPath(tab.doc.document, parentPath);
+  if (!parent) {
+    return;
+  }
+  childArray(parent).splice(index, 0, structuredClone(nodeDef));
+  recordPatch({ index, op: "insert", parentPath });
+  recordDocOp({
+    forward: { index, node: cloneValue(nodeDef), op: "insert-child", parentPath },
+    inverse: { index, op: "remove-child", parentPath }
+  });
+}
+function mutateRemoveNode(tab, path) {
+  if (!path || !isSpliceablePath(path)) {
+    return;
+  }
+  const elemPath = parentElementPath(path);
+  const idx = childIndex(path);
+  const [removed] = getNodeAtPath(tab.doc.document, elemPath).children.splice(idx, 1);
+  recordPatch({ op: "remove", path });
+  recordDocOp({
+    forward: { index: idx, op: "remove-child", parentPath: elemPath },
+    inverse: { index: idx, node: cloneValue(removed), op: "insert-child", parentPath: elemPath }
+  });
+  tab.session.selection = pruneSelection(tab.session.selection, path);
+}
+function mutateDuplicateNode(tab, path) {
+  if (!path || !isSpliceablePath(path)) {
+    return;
+  }
+  const node = getNodeAtPath(tab.doc.document, path);
+  if (!node) {
+    return;
+  }
+  const elemPath = parentElementPath(path);
+  const idx = childIndex(path);
+  const clone = structuredClone(toRaw(node));
+  getNodeAtPath(tab.doc.document, elemPath).children.splice(idx + 1, 0, clone);
+  recordPatch({ index: idx + 1, op: "insert", parentPath: elemPath });
+  recordDocOp({
+    forward: { index: idx + 1, node: cloneValue(clone), op: "insert-child", parentPath: elemPath },
+    inverse: { index: idx + 1, op: "remove-child", parentPath: elemPath }
+  });
+  tab.session.selection = [[...elemPath, "children", idx + 1]];
+}
+function mutateRemoveNodes(tab, paths) {
+  for (const path of structuralBatch(paths)) {
+    mutateRemoveNode(tab, path);
+  }
+}
+function mutateDuplicateNodes(tab, paths) {
+  let clones = [];
+  for (const path of structuralBatch(paths)) {
+    const before = tab.session.selection;
+    mutateDuplicateNode(tab, path);
+    const made = primarySelection(tab.session.selection);
+    if (!made || tab.session.selection === before) {
+      continue;
+    }
+    const parentPath = parentElementPath(made);
+    const spliceIndex = childIndex(made);
+    clones = clones.map((clone) => shiftPrefixedIndex(parentPath, clone, spliceIndex, 1, true));
+    clones.unshift(made);
+  }
+  if (clones.length > 0) {
+    tab.session.selection = clones;
+  }
+}
+function mutateWrapNode(tab, path, wrapperTag = "div") {
+  if (!path || !isSpliceablePath(path)) {
+    return;
+  }
+  const node = getNodeAtPath(tab.doc.document, path);
+  if (!node) {
+    return;
+  }
+  const elemPath = parentElementPath(path);
+  const idx = childIndex(path);
+  const wrapper = {
+    children: [structuredClone(toRaw(node))],
+    tagName: wrapperTag
+  };
+  const original = cloneValue(node);
+  getNodeAtPath(tab.doc.document, elemPath).children.splice(idx, 1, wrapper);
+  recordPatch({ op: "replace", path });
+  recordDocOp({
+    forward: { index: idx, node: cloneValue(wrapper), op: "set-child", parentPath: elemPath },
+    inverse: { index: idx, node: original, op: "set-child", parentPath: elemPath }
+  });
+  tab.session.selection = [[...elemPath, "children", idx]];
+}
+function mutateMoveNode(tab, fromPath, toParentPath, toIndex) {
+  const doc = tab.doc.document;
+  const fromParentPath = parentElementPath(fromPath);
+  const fromIdx = childIndex(fromPath);
+  if (!fromParentPath || typeof fromIdx !== "number") {
+    return;
+  }
+  const fromParent = getNodeAtPath(doc, fromParentPath);
+  const toParent = getNodeAtPath(doc, toParentPath);
+  if (!fromParent || !Array.isArray(fromParent.children) || !toParent) {
+    return;
+  }
+  const [node] = fromParent.children.splice(fromIdx, 1);
+  if (node === undefined) {
+    return;
+  }
+  let adjustedIndex = toIndex;
+  if (fromParent === toParent && fromIdx < toIndex) {
+    adjustedIndex -= 1;
+  }
+  childArray(toParent).splice(adjustedIndex, 0, node);
+  recordPatch({ fromPath, op: "move", toIndex: adjustedIndex, toParentPath });
+  recordDocOp({
+    forward: {
+      fromIndex: fromIdx,
+      fromParentPath,
+      op: "move-child",
+      toIndex: adjustedIndex,
+      toParentPath
+    },
+    inverse: {
+      fromIndex: adjustedIndex,
+      fromParentPath: shiftPrefixedIndex(fromParentPath, toParentPath, fromIdx, -1, false),
+      op: "move-child",
+      toIndex: fromIdx,
+      toParentPath: shiftPrefixedIndex(toParentPath, fromParentPath, adjustedIndex, 1, true)
+    }
+  });
+  if (pathsEqual(primarySelection(tab.session.selection), fromPath)) {
+    let idx = toIndex;
+    if (fromParentPath.length === toParentPath.length && fromParentPath.every((v, i) => v === toParentPath[i]) && fromIdx < toIndex) {
+      idx = toIndex - 1;
+    }
+    tab.session.selection = [[...toParentPath, "children", idx]];
+  }
+}
+function mutateUpdateProperty(tab, path, key, value) {
+  const node = getNodeAtPath(tab.doc.document, path);
+  if (!node) {
+    return;
+  }
+  const prev = node[key];
+  const before = cloneValue(prev);
+  if (value === undefined || value === null || value === "") {
+    delete node[key];
+  } else {
+    node[key] = value;
+  }
+  recordDocOp(setKeyPair(path, key, before, cloneValue(node[key])));
+  if (key === "textContent") {
+    recordPatch({ op: "set-text", path });
+  } else if (key === "style") {
+    recordPatch({ op: "set-style", path });
+  } else {
+    const bindingValue = value === undefined || value === null || value === "" ? prev : value;
+    const isEvent = key.startsWith("on") && isEventBinding(bindingValue);
+    recordPatch({ isEvent, key, op: "set-prop", path });
+  }
+}
+function mutateUpdateStyle(tab, path, prop, value) {
+  const node = getNodeAtPath(tab.doc.document, path);
+  const styleBefore = cloneValue(node.style);
+  if (!node.style) {
+    node.style = {};
+  }
+  if (value === undefined || value === "") {
+    delete node.style[prop];
+  } else {
+    node.style[prop] = value;
+  }
+  if (Object.keys(node.style).length === 0) {
+    delete node.style;
+  }
+  recordDocOp(setKeyPair(path, "style", styleBefore, cloneValue(node.style)));
+  recordPatch({ op: "set-style", path });
+}
+function mutateUpdateAttribute(tab, path, attr, value) {
+  const node = getNodeAtPath(tab.doc.document, path);
+  const attrsBefore = cloneValue(node.attributes);
+  if (!node.attributes) {
+    node.attributes = {};
+  }
+  if (value === undefined || value === "") {
+    delete node.attributes[attr];
+  } else {
+    node.attributes[attr] = value;
+  }
+  if (Object.keys(node.attributes).length === 0) {
+    delete node.attributes;
+  }
+  recordDocOp(setKeyPair(path, "attributes", attrsBefore, cloneValue(node.attributes)));
+  recordPatch({ attr, op: "set-attr", path });
+}
+function mutateUpdateMediaStyle(tab, path, mediaName, prop, value) {
+  if (!mediaName) {
+    return mutateUpdateStyle(tab, path, prop, value);
+  }
+  const node = getNodeAtPath(tab.doc.document, path);
+  const styleBefore = cloneValue(node.style);
+  if (!node.style) {
+    node.style = {};
+  }
+  const key = `@${mediaName}`;
+  const media = ensureNestedStyle(node.style, key);
+  if (value === undefined || value === "") {
+    delete media[prop];
+    if (Object.keys(media).length === 0) {
+      delete node.style[key];
+    }
+  } else {
+    media[prop] = value;
+  }
+  if (Object.keys(node.style).length === 0) {
+    delete node.style;
+  }
+  recordDocOp(setKeyPair(path, "style", styleBefore, cloneValue(node.style)));
+  recordPatch({ op: "set-style", path });
+}
+function mutateUpdateNestedStyle(tab, path, selector, prop, value) {
+  const node = getNodeAtPath(tab.doc.document, path);
+  const styleBefore = cloneValue(node.style);
+  if (!node.style) {
+    node.style = {};
+  }
+  const block = ensureNestedStyle(node.style, selector);
+  if (value === undefined || value === "") {
+    delete block[prop];
+    if (Object.keys(block).length === 0) {
+      delete node.style[selector];
+    }
+  } else {
+    block[prop] = value;
+  }
+  if (Object.keys(node.style).length === 0) {
+    delete node.style;
+  }
+  recordDocOp(setKeyPair(path, "style", styleBefore, cloneValue(node.style)));
+  recordPatch({ op: "set-style", path });
+}
+function mutateUpdateMediaNestedStyle(tab, path, mediaName, selector, prop, value) {
+  const node = getNodeAtPath(tab.doc.document, path);
+  const styleBefore = cloneValue(node.style);
+  if (!node.style) {
+    node.style = {};
+  }
+  const key = `@${mediaName}`;
+  const media = ensureNestedStyle(node.style, key);
+  const block = ensureNestedStyle(media, selector);
+  if (value === undefined || value === "") {
+    delete block[prop];
+    if (Object.keys(block).length === 0) {
+      delete media[selector];
+    }
+    if (Object.keys(media).length === 0) {
+      delete node.style[key];
+    }
+  } else {
+    block[prop] = value;
+  }
+  if (Object.keys(node.style).length === 0) {
+    delete node.style;
+  }
+  recordDocOp(setKeyPair(path, "style", styleBefore, cloneValue(node.style)));
+  recordPatch({ op: "set-style", path });
+}
+function pruneEmptyStylePath(root, stylePath) {
+  const owners = [root];
+  for (const seg of stylePath) {
+    const next = getNestedStyle(owners.at(-1), seg);
+    if (!next) {
+      break;
+    }
+    owners.push(next);
+  }
+  for (let i = owners.length - 2;i >= 0; i--) {
+    const owner = owners[i];
+    const seg = stylePath[i];
+    const block = getNestedStyle(owner, seg);
+    if (block && Object.keys(block).length === 0) {
+      delete owner[seg];
+    }
+  }
+}
+function mutateUpdateNestedStylePath(tab, path, stylePath, prop, value) {
+  const node = getNodeAtPath(tab.doc.document, path);
+  const styleBefore = cloneValue(node.style);
+  if (!node.style) {
+    node.style = {};
+  }
+  let obj = node.style;
+  for (const seg of stylePath) {
+    obj = ensureNestedStyle(obj, seg);
+  }
+  if (value === undefined || value === "") {
+    delete obj[prop];
+    pruneEmptyStylePath(node.style, stylePath);
+  } else {
+    obj[prop] = value;
+  }
+  if (Object.keys(node.style).length === 0) {
+    delete node.style;
+  }
+  recordDocOp(setKeyPair(path, "style", styleBefore, cloneValue(node.style)));
+  recordPatch({ op: "set-style", path });
+}
+function mutateUpdateMediaNestedStylePath(tab, path, mediaName, stylePath, prop, value) {
+  const node = getNodeAtPath(tab.doc.document, path);
+  const styleBefore = cloneValue(node.style);
+  if (!node.style) {
+    node.style = {};
+  }
+  const key = `@${mediaName}`;
+  const media = ensureNestedStyle(node.style, key);
+  let obj = media;
+  for (const seg of stylePath) {
+    obj = ensureNestedStyle(obj, seg);
+  }
+  if (value === undefined || value === "") {
+    delete obj[prop];
+    pruneEmptyStylePath(media, stylePath);
+    if (Object.keys(media).length === 0) {
+      delete node.style[key];
+    }
+  } else {
+    obj[prop] = value;
+  }
+  if (Object.keys(node.style).length === 0) {
+    delete node.style;
+  }
+  recordDocOp(setKeyPair(path, "style", styleBefore, cloneValue(node.style)));
+  recordPatch({ op: "set-style", path });
+}
+function mutateReplaceStyle(tab, path, style) {
+  const node = getNodeAtPath(tab.doc.document, path);
+  const styleBefore = cloneValue(node.style);
+  if (style && Object.keys(style).length > 0) {
+    node.style = style;
+  } else {
+    delete node.style;
+  }
+  recordDocOp(setKeyPair(path, "style", styleBefore, cloneValue(node.style)));
+  recordPatch({ op: "set-style", path });
+}
+function mutateAddDef(tab, name, def) {
+  const doc = tab.doc.document;
+  const before = cloneValue(doc.state);
+  if (!doc.state) {
+    doc.state = {};
+  }
+  doc.state[name] = def;
+  recordDocOp(setKeyPair([], "state", before, cloneValue(doc.state)));
+  recordPatch({ key: "state", op: "doc-meta" });
+}
+function mutateRemoveDef(tab, name) {
+  const doc = tab.doc.document;
+  if (doc.state) {
+    const before = cloneValue(doc.state);
+    delete doc.state[name];
+    if (Object.keys(doc.state).length === 0) {
+      delete doc.state;
+    }
+    recordDocOp(setKeyPair([], "state", before, cloneValue(doc.state)));
+    recordPatch({ key: "state", op: "doc-meta" });
+  }
+}
+function mutateUpdateDef(tab, name, updates) {
+  const doc = tab.doc.document;
+  const stateBefore = cloneValue(doc.state);
+  if (!doc.state) {
+    doc.state = {};
+  }
+  const existing = doc.state[name];
+  const entry = existing == null ? {} : typeof existing !== "object" || Array.isArray(existing) ? { default: existing } : existing;
+  doc.state[name] = entry;
+  Object.assign(entry, updates);
+  for (const k of Object.keys(entry)) {
+    if (entry[k] === undefined || entry[k] === null) {
+      delete entry[k];
+    }
+  }
+  recordDocOp(setKeyPair([], "state", stateBefore, cloneValue(doc.state)));
+  recordPatch({ key: "state", op: "doc-meta" });
+}
+function mutateRenameDef(tab, oldName, newName) {
+  const doc = tab.doc.document;
+  if (!doc.state || !doc.state[oldName]) {
+    return;
+  }
+  const before = cloneValue(doc.state);
+  doc.state[newName] = doc.state[oldName];
+  delete doc.state[oldName];
+  recordDocOp(setKeyPair([], "state", before, cloneValue(doc.state)));
+  recordPatch({ key: "state", op: "doc-meta" });
+}
+function mutateUpdateProp(tab, path, propName, value) {
+  const node = getNodeAtPath(tab.doc.document, path);
+  const propsBefore = cloneValue(node.$props);
+  if (!node.$props) {
+    node.$props = {};
+  }
+  if (value === undefined || value === null || value === "") {
+    delete node.$props[propName];
+  } else {
+    node.$props[propName] = value;
+  }
+  if (Object.keys(node.$props).length === 0) {
+    delete node.$props;
+  }
+  recordDocOp(setKeyPair(path, "$props", propsBefore, cloneValue(node.$props)));
+  recordPatch({ op: "replace", path });
+}
+function mutateAddSwitchCase(tab, path, caseName, caseDef) {
+  const node = getNodeAtPath(tab.doc.document, path);
+  const before = cloneValue(node.cases);
+  if (!node.cases) {
+    node.cases = {};
+  }
+  node.cases[caseName] = caseDef || { tagName: "div", textContent: caseName };
+  recordDocOp(setKeyPair(path, "cases", before, cloneValue(node.cases)));
+  recordPatch({ op: "replace", path });
+}
+function mutateRemoveSwitchCase(tab, path, caseName) {
+  const node = getNodeAtPath(tab.doc.document, path);
+  if (node.cases) {
+    const before = cloneValue(node.cases);
+    delete node.cases[caseName];
+    recordDocOp(setKeyPair(path, "cases", before, cloneValue(node.cases)));
+    recordPatch({ op: "replace", path });
+  }
+}
+function mutateRenameSwitchCase(tab, path, oldName, newName) {
+  const node = getNodeAtPath(tab.doc.document, path);
+  if (!node.cases || !node.cases[oldName]) {
+    return;
+  }
+  const before = cloneValue(node.cases);
+  node.cases[newName] = node.cases[oldName];
+  delete node.cases[oldName];
+  recordDocOp(setKeyPair(path, "cases", before, cloneValue(node.cases)));
+  recordPatch({ op: "replace", path });
+}
+function mutateUpdateFrontmatter(tab, field, value) {
+  const fm = tab.doc.content.frontmatter;
+  const before = Object.hasOwn(fm, field) ? cloneValue(fm[field]) : undefined;
+  const deletes = value === undefined || value === null || value === "";
+  if (deletes) {
+    delete fm[field];
+  } else {
+    fm[field] = value;
+  }
+  const after = deletes ? undefined : cloneValue(value);
+  recordFmOp({ after, before, field });
+  tab.doc.dirty = true;
+}
+function applyFmState(tab, field, value) {
+  if (value === undefined) {
+    delete tab.doc.content.frontmatter[field];
+  } else {
+    tab.doc.content.frontmatter[field] = value;
+  }
+}
+
+// src/commands/context.ts
+var EDITOR_KIND_BY_MODE = {
+  design: "canvas",
+  edit: "canvas",
+  entry: "entry",
+  "git-diff": "diff",
+  grid: "grid",
+  manage: "library",
+  media: "media",
+  preview: "canvas",
+  settings: "config",
+  source: "code",
+  stylebook: "config"
+};
+var EDITOR_KIND_LABELS = {
+  canvas: "Canvas",
+  code: "Code",
+  config: "Project Styles",
+  diff: "Diff",
+  entry: "Entry",
+  grid: "Grid",
+  media: "Media",
+  library: "Library",
+  none: "None"
+};
+function editorKindForMode(mode) {
+  return EDITOR_KIND_BY_MODE[mode] ?? "canvas";
+}
+var CANVAS_VIEW_BY_MODE = {
+  design: "design",
+  edit: "edit",
+  preview: "preview"
+};
+function canvasViewForMode(mode) {
+  return CANVAS_VIEW_BY_MODE[mode] ?? "design";
+}
+var inCanvas = (ctx) => ctx.editor.kind === "canvas";
+var hasSelection = (ctx) => inCanvas(ctx) && ctx.selection.count > 0;
+var hasElementSelection = (ctx) => hasSelection(ctx) && !ctx.selection.isRoot;
+function emptyContext() {
+  return {
+    project: { open: false, isSite: false, isRepo: false, isMultilingual: false },
+    git: { ahead: 0, behind: 0, dirtyCount: 0 },
+    document: { open: false, dirty: false, mode: "", canUndo: false, canRedo: false },
+    editor: { kind: "none" },
+    canvas: { view: "design" },
+    pane: { count: 1, derived: false },
+    selection: {
+      count: 0,
+      paths: [],
+      kind: "",
+      isRoot: false,
+      isComponentInstance: false,
+      isLayoutNode: false,
+      isRepeater: false
+    },
+    caret: { active: false, inCanvas: false },
+    focus: { region: "pane" },
+    modal: { open: false },
+    collab: { attached: false, readOnly: false, sourceCanonical: false },
+    ai: { configured: false, streaming: false, waiting: false },
+    capability: {
+      gitClone: false,
+      importSite: false,
+      openProjectInNewWindow: false,
+      dataRows: false,
+      windowControls: false,
+      findReferences: false
+    }
+  };
+}
+function makeContext(patch = {}) {
+  const base = emptyContext();
+  for (const key of Object.keys(patch)) {
+    const group = patch[key];
+    if (group) {
+      Object.assign(base[key], group);
+    }
+  }
+  return base;
+}
+var MODAL_STACK = ["palette"];
+var CARET_STACK = ["caret", "global"];
+var DOCK_STACK = ["dock", "global"];
+var CANVAS_STACK = ["canvas", "global"];
+var GRID_STACK = ["grid", "global"];
+var CODE_STACK = ["code", "global"];
+var GLOBAL_STACK = ["global"];
+function keyScopeStack(ctx) {
+  if (ctx.modal.open) {
+    return MODAL_STACK;
+  }
+  if (ctx.caret.active) {
+    return CARET_STACK;
+  }
+  if (ctx.focus.region !== "pane") {
+    return DOCK_STACK;
+  }
+  switch (ctx.editor.kind) {
+    case "grid": {
+      return GRID_STACK;
+    }
+    case "code": {
+      return CODE_STACK;
+    }
+    case "canvas": {
+      return ctx.canvas.view === "preview" ? GLOBAL_STACK : CANVAS_STACK;
+    }
+    default: {
+      return GLOBAL_STACK;
+    }
+  }
+}
+
+// src/tabs/tab.ts
+var PROJECT_CONFIG_PATH = "project.json";
+function createDefaultUi(canvasMode, preview = false) {
+  return {
+    activeMedia: null,
+    activeSelector: null,
+    canvasMode,
+    editZoom: 1,
+    editingFormula: null,
+    editingFunction: null,
+    featureToggles: {},
+    inspectorSections: {},
+    pendingInlineEdit: null,
+    preview,
+    previewColorScheme: "auto",
+    previewLocale: null,
+    previewParams: {},
+    previewProps: null,
+    rightTab: "properties",
+    showLayout: true,
+    styleFilter: "",
+    styleSections: {},
+    dataRows: {},
+    dataLimits: {},
+    styleShorthands: {},
+    zoom: 1
+  };
+}
+var ALL_MODES = ["edit", "design", "preview", "source", "stylebook"];
+function createTab({
+  id,
+  documentPath = null,
+  fileHandle = null,
+  document,
+  frontmatter,
+  sourceFormat = null,
+  capabilities,
+  openedFrom = null,
+  preview: previewTab = false
+}) {
+  const scope = effectScope();
+  normalizeArrayChildren(document);
+  const resolvedModes = capabilities?.modes ?? inferModes(documentPath, sourceFormat);
+  const initialCanvasMode = resolvedModes.find((m) => m !== "preview") ?? "edit";
+  const initialPreview = resolvedModes[0] === "preview";
+  const tab = scope.run(() => ({
+    capabilities: { modes: resolvedModes },
+    doc: reactive({
+      content: { frontmatter: frontmatter || {} },
+      dirty: false,
+      document,
+      handlersSource: null,
+      mode: inferDocumentMode(documentPath, sourceFormat),
+      sourceFormat
+    }),
+    documentPath,
+    fileHandle,
+    history: reactive({
+      index: 0,
+      snapshots: [{ document: structuredClone(document), selection: [] }]
+    }),
+    id,
+    pinned: false,
+    preview: previewTab,
+    scope,
+    session: reactive({
+      canvas: {
+        refreshing: false,
+        error: null,
+        livePreviews: null,
+        pendingInlineEdit: null,
+        scope: null,
+        status: "idle"
+      },
+      clipboard: null,
+      hover: null,
+      openedFrom,
+      selection: [],
+      ui: createDefaultUi(initialCanvasMode, initialPreview)
+    })
+  }));
+  return tab;
+}
+function inferModes(documentPath, sourceFormat) {
+  if (documentPath === PROJECT_CONFIG_PATH) {
+    return ["stylebook", "source"];
+  }
+  const format = formatByName(sourceFormat) ?? formatForPath(documentPath);
+  if (format) {
+    return format.studio?.modes ?? ["edit", "design", "preview", "source"];
+  }
+  return ALL_MODES;
+}
+function inferDocumentMode(documentPath, sourceFormat) {
+  const format = formatByName(sourceFormat) ?? formatForPath(documentPath);
+  if (format) {
+    return format.studio?.documentMode?.default ?? "content";
+  }
+  return "component";
+}
+function editorKindOf(tab) {
+  return editorKindForMode(tab.session.ui.canvasMode);
+}
+function editorKindsOf(tab) {
+  const kinds = [];
+  for (const mode of tab.capabilities.modes) {
+    if (mode === "preview") {
+      continue;
+    }
+    const kind = editorKindForMode(mode);
+    if (!kinds.includes(kind)) {
+      kinds.push(kind);
+    }
+  }
+  return kinds;
+}
+function modeForEditorKind(tab, kind) {
+  return tab.capabilities.modes.find((mode) => mode !== "preview" && editorKindForMode(mode) === kind);
+}
+function disposeTab(tab) {
+  tab.scope.stop();
+}
+
+// src/collab/collab-state.ts
+var states = new WeakMap;
+var attachedPaths = new Map;
+function collabState(tab) {
+  const key = toRaw(tab);
+  let state = states.get(key);
+  if (!state) {
+    state = reactive({
+      active: false,
+      attachError: "",
+      peers: [],
+      readOnly: false,
+      sourceCanonical: false,
+      status: "unavailable"
+    });
+    states.set(key, state);
+  }
+  return state;
+}
+function registerCollabPath(path) {
+  attachedPaths.set(path, (attachedPaths.get(path) ?? 0) + 1);
+}
+function unregisterCollabPath(path) {
+  const count = attachedPaths.get(path) ?? 0;
+  if (count <= 1) {
+    attachedPaths.delete(path);
+  } else {
+    attachedPaths.set(path, count - 1);
+  }
+}
+function isCollabPath(path) {
+  return attachedPaths.has(path.replaceAll("\\", "/"));
+}
+
+// src/collab/collab-session.ts
+var SYNC_TIMEOUT_MS = 8000;
+var MIRROR_DEBOUNCE_MS = 800;
+var MIRROR_MAX_LAG_MS = 2500;
+var collabModulePromise = null;
+function loadCollab() {
+  collabModulePromise ??= import("./index-zqxmqxmh.js");
+  return collabModulePromise;
+}
+function maybePlatform() {
+  try {
+    return getPlatform();
+  } catch {
+    return null;
+  }
+}
+var _serialize = null;
+function configureCollabSerializer(fn) {
+  _serialize = fn;
+}
+var _parse = null;
+function configureCollabParser(fn) {
+  _parse = fn;
+}
+var _notify = () => {};
+function configureCollabNotifier(fn) {
+  _notify = fn ?? (() => {});
+}
+var runtimes = new WeakMap;
+function rawTab(tab) {
+  return toRaw(tab);
+}
+function runtimeOf(tab) {
+  return runtimes.get(rawTab(tab));
+}
+function runtimeFor(tab) {
+  const key = rawTab(tab);
+  let runtime = runtimes.get(key);
+  if (!runtime) {
+    runtime = {
+      attaching: null,
+      generation: 0,
+      optedOut: reactive({ value: false }),
+      session: null,
+      watcherInstalled: false
+    };
+    runtimes.set(key, runtime);
+  }
+  return runtime;
+}
+var hooksInstalled = false;
+function installGlobalHooks() {
+  if (hooksInstalled) {
+    return;
+  }
+  hooksInstalled = true;
+  setTransactObserver(onTransact);
+  setBatchEndNotifier(onBatchEnd);
+  setTransactGate((tab) => {
+    const session = runtimeOf(tab)?.session;
+    if (session?.synced && collabState(tab).sourceCanonical) {
+      _notify("Source editing in progress — structural edits are paused");
+      return "source-canonical";
+    }
+    return null;
+  });
+}
+function onTransact(tab, record, origin) {
+  const session = runtimeOf(tab)?.session;
+  if (!session || !session.synced) {
+    return;
+  }
+  session.lastSeenRef = toRaw(tab.doc.document);
+  if (origin === "remote") {
+    scheduleMirror(session);
+    return;
+  }
+  if (session.canWrite) {
+    publishRecord(session, record);
+    scheduleMirror(session);
+  }
+}
+function onBatchEnd(tab) {
+  const session = runtimeOf(tab)?.session;
+  if (!session?.synced || session.batchOps === null) {
+    return;
+  }
+  const ops = session.batchOps;
+  const needsDiff = session.batchNeedsDiff;
+  session.batchOps = null;
+  session.batchNeedsDiff = false;
+  if (!session.canWrite) {
+    return;
+  }
+  session.undoManager?.stopCapturing();
+  if (needsDiff) {
+    publishDiff(session);
+  } else if (ops.length > 0) {
+    try {
+      session.collab.applyDocOpsToY(session.handle.doc, ops, session.collab.LOCAL_ORIGIN);
+    } catch {
+      publishDiff(session);
+    }
+  }
+  session.undoManager?.stopCapturing();
+}
+function publishRecord(session, record) {
+  const forward = record.docOps.map((pair) => pair.forward);
+  if (isBatching()) {
+    session.batchOps ??= [];
+    if (forward.length === 0) {
+      session.batchNeedsDiff = true;
+    } else {
+      session.batchOps.push(...forward);
+    }
+    return;
+  }
+  if (forward.length === 0) {
+    publishDiff(session);
+    return;
+  }
+  try {
+    session.collab.applyDocOpsToY(session.handle.doc, forward, session.collab.LOCAL_ORIGIN);
+  } catch {
+    publishDiff(session);
+  }
+}
+function publishDiff(session) {
+  const { collab, handle, tab } = session;
+  const before = collab.yDocToJson(handle.doc);
+  const after = jsonClone(toRaw(tab.doc.document));
+  const ops = collab.diffDocs(before, after);
+  if (ops === null) {
+    collab.replaceYStructure(handle.doc, after, collab.LOCAL_ORIGIN);
+  } else if (ops.length > 0) {
+    try {
+      collab.applyDocOpsToY(handle.doc, ops, collab.LOCAL_ORIGIN);
+    } catch {
+      collab.replaceYStructure(handle.doc, after, collab.LOCAL_ORIGIN);
+    }
+  }
+}
+function reconcileTabFromY(session) {
+  const next = session.collab.yDocToJson(session.handle.doc);
+  transactDoc(session.tab, (t) => {
+    const target = t.doc.document;
+    for (const key of Object.keys(target)) {
+      if (!(key in next)) {
+        delete target[key];
+      }
+    }
+    Object.assign(target, next);
+  }, { origin: "remote", skipHistory: true });
+}
+function isReconciler(session) {
+  if (!session.canWrite) {
+    return false;
+  }
+  const { awareness } = session.handle;
+  let lowest = awareness.clientID;
+  for (const [clientId, state] of awareness.getStates()) {
+    if (state.canWrite !== false && clientId < lowest) {
+      lowest = clientId;
+    }
+  }
+  return lowest === session.handle.awareness.clientID;
+}
+function scheduleMirror(session) {
+  if (!_serialize || !isReconciler(session)) {
+    return;
+  }
+  if (session.collab.canonicalOf(session.handle.doc) === "source") {
+    return;
+  }
+  const now = Date.now();
+  session.lastMirrorAt ??= now;
+  if (now - session.lastMirrorAt >= MIRROR_MAX_LAG_MS) {
+    if (session.mirrorTimer) {
+      clearTimeout(session.mirrorTimer);
+      session.mirrorTimer = null;
+    }
+    session.lastMirrorAt = now;
+    mirrorNow(session);
+    return;
+  }
+  if (session.mirrorTimer) {
+    clearTimeout(session.mirrorTimer);
+  }
+  session.mirrorTimer = setTimeout(() => {
+    session.mirrorTimer = null;
+    session.lastMirrorAt = Date.now();
+    mirrorNow(session);
+  }, MIRROR_DEBOUNCE_MS);
+}
+async function mirrorNow(session) {
+  if (!_serialize || !session.synced) {
+    return;
+  }
+  try {
+    const text = await _serialize(session.tab);
+    session.collab.updateSourceText(session.handle.doc, text, session.collab.MIRROR_ORIGIN);
+  } catch {}
+}
+async function sourceParseNow(session) {
+  if (!_parse || !session.synced || !session.canWrite) {
+    return;
+  }
+  const { collab, handle, tab } = session;
+  const rev = collab.canonicalRevOf(handle.doc);
+  const text = collab.sourceText(handle.doc).toString();
+  let parsed;
+  try {
+    parsed = await _parse(tab, text);
+  } catch {
+    return;
+  }
+  if (!session.synced || collab.canonicalRevOf(handle.doc) !== rev) {
+    return;
+  }
+  const ops = collab.diffDocs(collab.yDocToJson(handle.doc), parsed.document);
+  if (ops === null) {
+    collab.replaceYStructure(handle.doc, parsed.document, collab.MIRROR_ORIGIN);
+  } else if (ops.length > 0) {
+    try {
+      collab.applyDocOpsToY(handle.doc, ops, collab.MIRROR_ORIGIN);
+    } catch {
+      collab.replaceYStructure(handle.doc, parsed.document, collab.MIRROR_ORIGIN);
+    }
+  }
+  const frontmatter = collab.frontmatterMap(handle.doc);
+  const next = parsed.frontmatter ?? {};
+  handle.doc.transact(() => {
+    const sharedKeys = [...frontmatter.keys()];
+    for (const key of sharedKeys) {
+      if (!(key in next)) {
+        frontmatter.delete(key);
+      }
+    }
+    for (const [key, value] of Object.entries(next)) {
+      if (!collab.deepEqual(frontmatter.get(key), value)) {
+        frontmatter.set(key, value);
+      }
+    }
+  }, collab.MIRROR_ORIGIN);
+}
+function collabSourceContext(tab) {
+  const session = runtimeOf(tab)?.session;
+  if (!session?.synced) {
+    return null;
+  }
+  const { collab, handle } = session;
+  let claim = null;
+  const holdsClaim = () => claim !== null && session.sourceLockOwner === claim;
+  return {
+    awareness: handle.awareness,
+    enter: async () => {
+      claim = {};
+      session.sourceLockOwner = claim;
+      const local = handle.awareness.getLocalState();
+      if (local) {
+        handle.awareness.setLocalState({ ...local, mode: "source" });
+      }
+      if (!session.canWrite) {
+        return;
+      }
+      let serialized = null;
+      if (_serialize) {
+        try {
+          serialized = await _serialize(tab);
+        } catch {
+          serialized = null;
+        }
+      }
+      if (!holdsClaim()) {
+        return;
+      }
+      collab.acquireSourceCanonical(handle.doc, serialized ?? collab.sourceText(handle.doc).toString(), collab.LOCAL_ORIGIN);
+    },
+    leave: () => {
+      if (!holdsClaim()) {
+        claim = null;
+        return;
+      }
+      claim = null;
+      session.sourceLockOwner = null;
+      const local = handle.awareness.getLocalState();
+      if (local) {
+        handle.awareness.setLocalState({ ...local, mode: "structure" });
+      }
+      if (!session.canWrite) {
+        return;
+      }
+      const others = collab.otherSourceEditors(handle.awareness, session.path, handle.awareness.clientID).filter((clientId) => {
+        const peer = handle.awareness.getStates().get(clientId);
+        return peer?.canWrite !== false;
+      });
+      if (others.length === 0) {
+        sourceParseNow(session).then(() => {
+          collab.releaseSourceCanonical(handle.doc, collab.LOCAL_ORIGIN);
+        });
+      }
+    },
+    localOrigin: collab.LOCAL_ORIGIN,
+    readOnly: !session.canWrite,
+    text: collab.sourceText(handle.doc)
+  };
+}
+function collabReadOnly(tab) {
+  const state = collabState(tab);
+  return state.active && state.readOnly;
+}
+async function collabSave(tab) {
+  const session = runtimeOf(tab)?.session;
+  if (!session?.synced || !session.canWrite) {
+    return false;
+  }
+  if (session.mirrorTimer) {
+    clearTimeout(session.mirrorTimer);
+    session.mirrorTimer = null;
+  }
+  await mirrorNow(session);
+  await session.handle.flush();
+  return true;
+}
+async function flushAllCollab() {
+  for (const tab of liveTabs) {
+    const session = runtimeOf(tab)?.session;
+    if (session?.synced) {
+      await collabSave(tab);
+    }
+  }
+}
+var liveTabs = new Set;
+function ensureCollab(tab) {
+  const platform = maybePlatform();
+  if (!platform?.collab || !tab.documentPath || tab.documentPath === PROJECT_CONFIG_PATH) {
+    return;
+  }
+  const runtime = runtimeFor(tab);
+  if (runtime.watcherInstalled) {
+    return;
+  }
+  runtime.watcherInstalled = true;
+  installGlobalHooks();
+  liveTabs.add(tab);
+  tab.scope.run(() => {
+    effect(() => {
+      if (runtime.optedOut.value) {
+        detachSession(tab);
+      } else {
+        attachSession(tab);
+      }
+    });
+    onScopeDispose(() => {
+      liveTabs.delete(tab);
+      detachSession(tab);
+    });
+  });
+}
+function setCollabEnabled(tab, enabled) {
+  const runtime = runtimeFor(tab);
+  if (runtime.optedOut.value === !enabled) {
+    return;
+  }
+  runtime.optedOut.value = !enabled;
+  if (!runtime.watcherInstalled && enabled) {
+    ensureCollab(tab);
+  }
+}
+function isCollabEnabled(tab) {
+  return runtimeOf(tab)?.optedOut.value !== true;
+}
+function rekeyCollab(tab) {
+  const runtime = runtimeOf(tab);
+  if (!runtime?.watcherInstalled) {
+    ensureCollab(tab);
+    return;
+  }
+  detachSession(tab);
+  attachSession(tab);
+}
+async function attachSession(tab) {
+  const runtime = runtimeFor(tab);
+  if (runtime.session || runtime.attaching) {
+    return;
+  }
+  const { documentPath: path } = tab;
+  const platform = maybePlatform();
+  if (!path || !platform?.collab) {
+    collabState(tab).status = "unavailable";
+    return;
+  }
+  const { generation } = runtime;
+  const state = collabState(tab);
+  state.status = "connecting";
+  state.attachError = "";
+  const attempt = (async () => {
+    try {
+      const [collab, handle] = await Promise.all([loadCollab(), platform.collab(path)]);
+      if (!handle) {
+        state.status = "detached";
+        return;
+      }
+      if (runtime.generation !== generation) {
+        handle.destroy();
+        return;
+      }
+      let timer = null;
+      const timeout = new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error("collab-sync-timeout")), SYNC_TIMEOUT_MS);
+      });
+      try {
+        await Promise.race([handle.whenSynced, timeout]);
+      } finally {
+        if (timer) {
+          clearTimeout(timer);
+        }
+      }
+      if (runtime.generation !== generation) {
+        handle.destroy();
+        return;
+      }
+      runtime.session = createSession(tab, path, collab, handle);
+      state.active = true;
+      state.status = "synced";
+      state.readOnly = !runtime.session.canWrite;
+      state.attachError = "";
+      registerCollabPath(path);
+    } catch (error) {
+      state.status = "failed";
+      state.active = false;
+      state.attachError = error instanceof Error ? error.message : String(error);
+      notify.warn(`Live collaboration is not available for "${path}" — ${state.attachError}`, {
+        key: `collab:${path}`,
+        path,
+        source: "Collaboration"
+      });
+    } finally {
+      runtime.attaching = null;
+    }
+  })();
+  runtime.attaching = attempt;
+  await attempt;
+}
+function detachSession(tab) {
+  const runtime = runtimeOf(tab);
+  if (!runtime) {
+    return;
+  }
+  runtime.generation += 1;
+  const { session } = runtime;
+  runtime.session = null;
+  const state = collabState(tab);
+  state.active = false;
+  state.status = "detached";
+  state.attachError = "";
+  state.peers = [];
+  if (!session) {
+    return;
+  }
+  unregisterCollabPath(session.path);
+  if (session.mirrorTimer) {
+    clearTimeout(session.mirrorTimer);
+  }
+  if (session.sourceParseTimer) {
+    clearTimeout(session.sourceParseTimer);
+  }
+  for (const dispose of session.disposers) {
+    try {
+      dispose();
+    } catch {}
+  }
+  setHistoryDelegate(tab, null);
+  tab.history.snapshots = [
+    {
+      document: jsonClone(toRaw(tab.doc.document)),
+      selection: cloneSelection(tab.session.selection)
+    }
+  ];
+  tab.history.index = 0;
+  session.undoManager?.destroy();
+  session.handle.destroy();
+}
+function createSession(tab, path, collab, handle) {
+  const identity = handle.identity();
+  const session = {
+    applyingRemoteFrontmatter: false,
+    batchNeedsDiff: false,
+    batchOps: null,
+    canWrite: identity ? identity.permission !== "read" : true,
+    collab,
+    disposers: [],
+    handle,
+    lastSeenRef: toRaw(tab.doc.document),
+    mirrorTimer: null,
+    path,
+    sourceLockOwner: null,
+    sourceParseTimer: null,
+    synced: false,
+    tab,
+    undoManager: null
+  };
+  const meta = collab.metaMap(handle.doc);
+  if (meta.get("structureSeeded") === true) {
+    const yJson = collab.yDocToJson(handle.doc);
+    const tabJson = jsonClone(toRaw(tab.doc.document));
+    if (!collab.deepEqual(yJson, tabJson)) {
+      const ops = collab.diffDocs(tabJson, yJson);
+      if (ops === null) {
+        session.synced = true;
+        reconcileTabFromY(session);
+        session.synced = false;
+      } else if (ops.length > 0) {
+        applyExternalDocOps(tab, ops);
+      }
+    }
+    session.applyingRemoteFrontmatter = true;
+    const sharedFrontmatter = collab.frontmatterMap(handle.doc);
+    for (const [key, value] of sharedFrontmatter.entries()) {
+      tab.doc.content.frontmatter[key] = value;
+    }
+    session.applyingRemoteFrontmatter = false;
+  } else if (session.canWrite) {
+    collab.seedStructure(handle.doc, jsonClone(toRaw(tab.doc.document)), {
+      frontmatter: jsonClone(toRaw(tab.doc.content.frontmatter)),
+      origin: collab.SEED_ORIGIN,
+      sourceFormat: tab.doc.sourceFormat
+    });
+  }
+  session.lastSeenRef = toRaw(tab.doc.document);
+  session.disposers.push(handle.onDirty((dirty) => {
+    tab.doc.dirty = dirty;
+  }));
+  handle.awareness.setLocalState({
+    canWrite: session.canWrite,
+    focusedPath: path,
+    structuralSelection: null,
+    user: identity ? {
+      avatarUrl: identity.avatarUrl,
+      color: identity.color,
+      login: identity.login,
+      name: identity.name
+    } : {
+      color: collab.colorForKey(String(handle.awareness.clientID)),
+      login: `guest-${handle.awareness.clientID % 1000}`
+    }
+  });
+  const undoManager = new collab.UndoManager([collab.structureMap(handle.doc), collab.frontmatterMap(handle.doc)], { trackedOrigins: new Set([collab.LOCAL_ORIGIN]) });
+  session.undoManager = undoManager;
+  const onStackAdd = ({ stackItem }) => {
+    stackItem.meta.set("selection", cloneSelection(tab.session.selection));
+  };
+  const onStackPop = ({ stackItem }) => {
+    const selection = stackItem.meta.get("selection");
+    tab.session.selection = cloneSelection(selection ?? []);
+  };
+  undoManager.on("stack-item-added", onStackAdd);
+  undoManager.on("stack-item-popped", onStackPop);
+  session.disposers.push(() => {
+    undoManager.off("stack-item-added", onStackAdd);
+    undoManager.off("stack-item-popped", onStackPop);
+  });
+  setHistoryDelegate(tab, {
+    canRedo: () => undoManager.canRedo(),
+    canUndo: () => undoManager.canUndo(),
+    redo: () => {
+      undoManager.redo();
+    },
+    undo: () => {
+      undoManager.undo();
+    }
+  });
+  const structure = collab.structureMap(handle.doc);
+  const structureObserver = (events, transaction) => {
+    if (transaction.origin === collab.LOCAL_ORIGIN || !session.synced) {
+      return;
+    }
+    const ops = collab.yEventsToDocOps(events);
+    if (ops === null) {
+      reconcileTabFromY(session);
+      return;
+    }
+    if (ops.length === 0) {
+      return;
+    }
+    try {
+      applyExternalDocOps(tab, ops);
+    } catch {
+      reconcileTabFromY(session);
+    }
+  };
+  structure.observeDeep(structureObserver);
+  session.disposers.push(() => structure.unobserveDeep(structureObserver));
+  const tabState = collabState(tab);
+  tabState.sourceCanonical = collab.canonicalOf(handle.doc) === "source";
+  const lockMeta = collab.metaMap(handle.doc);
+  const lockObserver = () => {
+    tabState.sourceCanonical = collab.canonicalOf(handle.doc) === "source";
+  };
+  lockMeta.observe(lockObserver);
+  session.disposers.push(() => lockMeta.unobserve(lockObserver));
+  const source = collab.sourceText(handle.doc);
+  const sourceObserver = (_event, transaction) => {
+    if (transaction.origin === collab.MIRROR_ORIGIN || !session.synced) {
+      return;
+    }
+    if (collab.canonicalOf(handle.doc) !== "source") {
+      return;
+    }
+    if (!collab.isSourceReconciler(handle.awareness, session.path)) {
+      return;
+    }
+    if (session.sourceParseTimer) {
+      clearTimeout(session.sourceParseTimer);
+    }
+    session.sourceParseTimer = setTimeout(() => {
+      session.sourceParseTimer = null;
+      sourceParseNow(session);
+    }, 600);
+  };
+  source.observe(sourceObserver);
+  session.disposers.push(() => source.unobserve(sourceObserver));
+  const frontmatter = collab.frontmatterMap(handle.doc);
+  const frontmatterObserver = (event, transaction) => {
+    if (transaction.origin === collab.LOCAL_ORIGIN || !session.synced) {
+      return;
+    }
+    session.applyingRemoteFrontmatter = true;
+    try {
+      for (const [key, change] of event.changes.keys) {
+        if (change.action === "delete") {
+          delete tab.doc.content.frontmatter[key];
+        } else {
+          tab.doc.content.frontmatter[key] = frontmatter.get(key);
+        }
+      }
+    } finally {
+      session.applyingRemoteFrontmatter = false;
+    }
+  };
+  frontmatter.observe(frontmatterObserver);
+  session.disposers.push(() => frontmatter.unobserve(frontmatterObserver));
+  tab.scope.run(() => {
+    let lastJson = JSON.stringify(tab.doc.content.frontmatter);
+    effect(() => {
+      const json = JSON.stringify(tab.doc.content.frontmatter);
+      if (json === lastJson) {
+        return;
+      }
+      lastJson = json;
+      if (session.applyingRemoteFrontmatter || !session.synced || !session.canWrite) {
+        return;
+      }
+      const local = JSON.parse(json);
+      handle.doc.transact(() => {
+        const sharedKeys = [...frontmatter.keys()];
+        for (const key of sharedKeys) {
+          if (!(key in local)) {
+            frontmatter.delete(key);
+          }
+        }
+        for (const [key, value] of Object.entries(local)) {
+          if (!collab.deepEqual(frontmatter.get(key), value)) {
+            frontmatter.set(key, value);
+          }
+        }
+      }, collab.LOCAL_ORIGIN);
+      scheduleMirror(session);
+    });
+    effect(() => {
+      const structuralSelection = tab.session.selection.length > 0 ? cloneSelection(tab.session.selection) : null;
+      const local = handle.awareness.getLocalState();
+      if (local) {
+        handle.awareness.setLocalState({ ...local, structuralSelection });
+      }
+    });
+    effect(() => {
+      const ref = toRaw(tab.doc.document);
+      queueMicrotask(() => {
+        const current = runtimeOf(tab)?.session;
+        if (current !== session || !session.synced || !session.canWrite) {
+          return;
+        }
+        const nowRef = toRaw(tab.doc.document);
+        if (nowRef !== ref || nowRef === session.lastSeenRef) {
+          return;
+        }
+        session.lastSeenRef = nowRef;
+        publishDiff(session);
+        scheduleMirror(session);
+      });
+    });
+  });
+  const state = collabState(tab);
+  const awarenessObserver = () => {
+    const peers = [];
+    for (const [clientId, peerState] of handle.awareness.getStates()) {
+      if (clientId !== handle.awareness.clientID && peerState["user"]) {
+        peers.push({ clientId, state: peerState });
+      }
+    }
+    state.peers = peers;
+  };
+  awarenessObserver();
+  handle.awareness.on("change", awarenessObserver);
+  session.disposers.push(() => handle.awareness.off("change", awarenessObserver), handle.onStatus((status) => {
+    if (status === "offline" || status === "connecting") {
+      state.status = "offline";
+    } else if (session.synced) {
+      state.status = "synced";
+    }
+  }), handle.onReset(() => {
+    detachSession(tab);
+    attachSession(tab);
+  }));
+  session.synced = true;
+  return session;
+}
+
+// src/commands/command-args.ts
+function refuse(commandId, key, problem) {
+  return new RangeError(`command "${commandId}" argument "${key}": ${problem}`);
+}
+function describe(value) {
+  if (value === undefined) {
+    return "missing";
+  }
+  return typeof value === "string" ? `"${value}"` : `${typeof value} ${JSON.stringify(value)}`;
+}
+function stringArg(commandId, args, key) {
+  const value = args[key];
+  if (typeof value !== "string" || value === "") {
+    throw refuse(commandId, key, `expected a non-empty string, got ${describe(value)}`);
+  }
+  return value;
+}
+function optionalStringArg(commandId, args, key) {
+  if (args[key] === undefined) {
+    return;
+  }
+  return stringArg(commandId, args, key);
+}
+function numberArg(commandId, args, key) {
+  const value = args[key];
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw refuse(commandId, key, `expected a finite number, got ${describe(value)}`);
+  }
+  return value;
+}
+function boundedNumberArg(commandId, args, key, minimum, maximum) {
+  const value = numberArg(commandId, args, key);
+  if (value < minimum || value > maximum) {
+    throw refuse(commandId, key, `${value} is outside the supported range ${minimum}–${maximum}`);
+  }
+  return value;
+}
+function booleanArg(commandId, args, key) {
+  const value = args[key];
+  if (typeof value !== "boolean") {
+    throw refuse(commandId, key, `expected a boolean, got ${describe(value)}`);
+  }
+  return value;
+}
+function enumArg(commandId, args, key, declared) {
+  const value = args[key];
+  if (typeof value !== "string" || !declared.includes(value)) {
+    throw refuse(commandId, key, `${describe(value)} is not declared — declared: ${declared.join(", ")}`);
+  }
+  return value;
+}
+function pathArg(commandId, args, key) {
+  const value = args[key];
+  if (!Array.isArray(value) || !value.every((s) => typeof s === "string" || typeof s === "number")) {
+    throw refuse(commandId, key, `expected an array of path segments (strings or numbers), got ${describe(value)}`);
+  }
+  return value;
+}
+function nullablePathArg(commandId, args, key) {
+  if (args[key] === null) {
+    return null;
+  }
+  return pathArg(commandId, args, key);
+}
+function pathListArg(commandId, args, key) {
+  const value = args[key];
+  if (!Array.isArray(value)) {
+    throw refuse(commandId, key, `expected an array of document paths, got ${describe(value)}`);
+  }
+  return value.map((entry, i) => {
+    if (!Array.isArray(entry) || !entry.every((s) => typeof s === "string" || typeof s === "number")) {
+      throw refuse(commandId, key, `entry ${i} is not a document path — expected an array of segments, got ${describe(entry)}`);
+    }
+    return entry;
+  });
+}
+function argsSchema(properties, required = Object.keys(properties)) {
+  return {
+    additionalProperties: false,
+    properties,
+    required: [...required],
+    type: "object"
+  };
+}
+function enumProperty(declared, description) {
+  return { description, enum: [...declared], type: "string" };
+}
+function derivedEnumProperty(declared, description) {
+  return {
+    description,
+    get enum() {
+      return [...declared()];
+    },
+    type: "string"
+  };
+}
+function numberProperty(description, bounds = {}) {
+  return { description, type: "number", ...bounds };
+}
+function booleanProperty(description) {
+  return { description, type: "boolean" };
+}
+function pathProperty(description, nullable = false) {
+  const path = {
+    items: { type: ["string", "number"] },
+    type: "array"
+  };
+  return nullable ? { description, oneOf: [path, { type: "null" }] } : { description, ...path };
+}
+function pathListProperty(description) {
+  return {
+    description,
+    items: { items: { type: ["string", "number"] }, type: "array" },
+    type: "array"
+  };
+}
+function stringProperty(description) {
+  return { description, type: "string" };
+}
+
+// src/workspace/workspace.ts
+var CLOSED_TAB_LIMIT = 20;
+var PRIMARY_PANE = "primary";
+var SECONDARY_PANE = "secondary";
+var MAX_PANES = 2;
+var workspace = reactive({
+  activePaneId: PRIMARY_PANE,
+  clipboard: null,
+  closedTabs: [],
+  componentRegistry: [],
+  mruOrder: [],
+  fileTree: {
+    dirs: new Map,
+    expanded: new Set,
+    searchQuery: "",
+    selectedPath: null
+  },
+  panes: [
+    {
+      activeTabId: null,
+      derived: null,
+      id: PRIMARY_PANE,
+      tabOrder: []
+    }
+  ],
+  projectConfig: null,
+  projectRoot: null,
+  styleClipboard: null,
+  tabs: new Map,
+  ui: {
+    activityBar: "files"
+  },
+  get activeTabId() {
+    const pane = activePane();
+    return pane.derived?.kind === "lens" ? paneById(pane.derived.sourcePaneId)?.activeTabId ?? null : pane.activeTabId;
+  },
+  get tabOrder() {
+    return activePane().tabOrder;
+  }
+});
+var activeTab = computed(() => workspace.activeTabId ? workspace.tabs.get(workspace.activeTabId) ?? null : null);
+function activePane() {
+  const { panes } = workspace;
+  return panes.find((pane) => pane.id === workspace.activePaneId) ?? panes[0];
+}
+function paneById(paneId) {
+  return workspace.panes.find((pane) => pane.id === paneId);
+}
+function paneOfTab(tabId) {
+  return workspace.panes.find((pane) => pane.tabOrder.includes(tabId));
+}
+function focusPane(paneId) {
+  const pane = paneById(paneId);
+  if (!pane || pane.id === workspace.activePaneId) {
+    return;
+  }
+  workspace.activePaneId = pane.id;
+  resetTabCycle();
+  const { activeTabId } = pane;
+  if (activeTabId) {
+    promoteMru(activeTabId);
+    const tab = workspace.tabs.get(activeTabId);
+    if (tab) {
+      syncTreeSelection(tab);
+    }
+  }
+}
+function isPaneFocused(paneId) {
+  return workspace.activePaneId === paneId;
+}
+function focusOtherPane() {
+  const other = workspace.panes.find((pane) => pane.id !== workspace.activePaneId);
+  if (other) {
+    focusPane(other.id);
+  }
+}
+function splitRight() {
+  const source = activePane();
+  const tabId = source.activeTabId;
+  const tab = tabId ? workspace.tabs.get(tabId) : null;
+  if (!tabId || !tab) {
+    return null;
+  }
+  const target = receivingPane();
+  detachTab(tabId);
+  insertIntoPane(target, tabId);
+  target.activeTabId = tabId;
+  workspace.activePaneId = target.id;
+  resetTabCycle();
+  promoteMru(tabId);
+  return target;
+}
+function sidePane() {
+  const source = activePane();
+  return workspace.panes.find((pane) => pane.id !== source.id) ?? addPane(SECONDARY_PANE);
+}
+function receivingPane() {
+  const target = sidePane();
+  if (target.derived) {
+    target.derived = null;
+  }
+  return target;
+}
+function addPane(paneId) {
+  const existing = paneById(paneId);
+  if (existing) {
+    return existing;
+  }
+  workspace.panes = [
+    ...workspace.panes,
+    {
+      activeTabId: null,
+      derived: null,
+      id: paneId,
+      tabOrder: []
+    }
+  ];
+  return paneById(paneId);
+}
+function closePane(paneId) {
+  if (workspace.panes.length < 2) {
+    return;
+  }
+  const closingId = paneId === PRIMARY_PANE ? workspace.panes.find((candidate) => candidate.id !== PRIMARY_PANE)?.id : paneId;
+  const pane = closingId === undefined ? undefined : paneById(closingId);
+  const survivor = workspace.panes.find((candidate) => candidate.id !== closingId);
+  if (!pane || !survivor) {
+    return;
+  }
+  for (const tabId of pane.tabOrder) {
+    insertIntoPane(survivor, tabId);
+  }
+  survivor.activeTabId = workspace.activePaneId === pane.id ? pane.activeTabId ?? survivor.activeTabId : survivor.activeTabId ?? pane.activeTabId;
+  workspace.activePaneId = survivor.id;
+  if (survivor.derived?.sourcePaneId === pane.id) {
+    survivor.derived = null;
+  }
+  workspace.panes = workspace.panes.filter((candidate) => candidate.id !== pane.id);
+  resetTabCycle();
+}
+function paneIsEmpty(pane) {
+  return pane.tabOrder.length === 0 && pane.derived === null;
+}
+function detachTab(tabId) {
+  const emptied = [];
+  for (const pane of workspace.panes) {
+    if (!pane.tabOrder.includes(tabId)) {
+      continue;
+    }
+    pane.tabOrder = pane.tabOrder.filter((id) => id !== tabId);
+    if (pane.activeTabId === tabId) {
+      pane.activeTabId = pane.tabOrder.at(-1) ?? null;
+    }
+    if (pane.id !== PRIMARY_PANE && paneIsEmpty(pane)) {
+      emptied.push(pane.id);
+    }
+  }
+  for (const paneId of emptied) {
+    closePane(paneId);
+  }
+}
+function insertIntoPane(pane, tabId, index) {
+  if (pane.tabOrder.includes(tabId)) {
+    return;
+  }
+  const at = index ?? defaultSlot(pane, tabId);
+  pane.tabOrder = [...pane.tabOrder.slice(0, at), tabId, ...pane.tabOrder.slice(at)];
+}
+function pinnedCount(pane) {
+  let count = 0;
+  for (const id of pane.tabOrder) {
+    if (workspace.tabs.get(id)?.pinned !== true) {
+      break;
+    }
+    count += 1;
+  }
+  return count;
+}
+function defaultSlot(pane, tabId) {
+  return workspace.tabs.get(tabId)?.pinned === true ? pinnedCount(pane) : pane.tabOrder.length;
+}
+function setWorkspaceProject(root, config = null) {
+  workspace.projectRoot = root;
+  workspace.projectConfig = config;
+}
+function isTabActive(tab) {
+  const active = activeTab.value;
+  return tab !== null && active !== null && toRaw(active) === toRaw(tab);
+}
+function tabIsLive(tab) {
+  if (!tab) {
+    return false;
+  }
+  const held = workspace.tabs.get(tab.id);
+  return held !== undefined && toRaw(held) === toRaw(tab);
+}
+function promoteMru(tabId) {
+  workspace.mruOrder = [tabId, ...workspace.mruOrder.filter((id) => id !== tabId)];
+}
+var _cycleList = null;
+var _cycleIndex = 0;
+function resetTabCycle() {
+  _cycleList = null;
+  _cycleIndex = 0;
+}
+function syncTreeSelection(tab) {
+  if (projectState && tab.documentPath) {
+    projectState.selectedPath = tab.documentPath;
+  }
+}
+function setActiveTab(tabId, opts = {}) {
+  const tab = workspace.tabs.get(tabId);
+  const pane = paneOfTab(tabId);
+  if (!tab || !pane) {
+    return;
+  }
+  pane.activeTabId = tabId;
+  if (opts.focus === false) {
+    return;
+  }
+  workspace.activePaneId = pane.id;
+  if (!opts.cycling) {
+    resetTabCycle();
+    promoteMru(tabId);
+  }
+  syncTreeSelection(tab);
+}
+function openTab(opts) {
+  const previous = workspace.tabs.get(opts.id);
+  const preview = opts.preview === true && previous?.pinned !== true;
+  const tab = createTab({ ...opts, preview });
+  const pane = (opts.paneId === undefined ? undefined : paneById(opts.paneId)) ?? activePane();
+  let slot;
+  if (previous) {
+    tab.pinned = previous.pinned;
+    disposeTab(previous);
+  } else {
+    if (preview) {
+      const sitting = previewTabIn(pane);
+      const sittingTab = sitting ? workspace.tabs.get(sitting) : null;
+      if (sittingTab) {
+        commitTabBuffers(sittingTab);
+      }
+      promoteDirtyPreviewTabs();
+    }
+    const replaced = preview ? previewTabIn(pane) : null;
+    if (replaced) {
+      slot = pane.tabOrder.indexOf(replaced);
+      closeTab(replaced);
+    }
+    insertIntoPane(pane, tab.id, slot);
+  }
+  workspace.tabs.set(tab.id, tab);
+  setActiveTab(tab.id, { focus: opts.focus !== false });
+  ensureCollab(tab);
+  return tab;
+}
+function previewTabIn(pane) {
+  return pane.tabOrder.find((id) => workspace.tabs.get(id)?.preview === true) ?? null;
+}
+function promoteTab(tabId) {
+  const tab = workspace.tabs.get(tabId);
+  if (tab?.preview === true) {
+    tab.preview = false;
+  }
+}
+function promoteDirtyPreviewTabs() {
+  for (const [id, tab] of workspace.tabs) {
+    if (tab.preview && tab.doc.dirty) {
+      promoteTab(id);
+    }
+  }
+}
+function setTabPinned(tabId, pinned) {
+  const tab = workspace.tabs.get(tabId);
+  const pane = paneOfTab(tabId);
+  if (!tab || !pane) {
+    return;
+  }
+  tab.pinned = pinned;
+  if (pinned) {
+    tab.preview = false;
+  }
+  const without = pane.tabOrder.filter((id) => id !== tabId);
+  const boundary = without.filter((id) => workspace.tabs.get(id)?.pinned === true).length;
+  pane.tabOrder = [...without.slice(0, boundary), tabId, ...without.slice(boundary)];
+}
+function moveTab(tabId, toIndex) {
+  const tab = workspace.tabs.get(tabId);
+  const pane = paneOfTab(tabId);
+  if (!tab || !pane) {
+    return;
+  }
+  const without = pane.tabOrder.filter((id) => id !== tabId);
+  const boundary = without.filter((id) => workspace.tabs.get(id)?.pinned === true).length;
+  const lower = tab.pinned ? 0 : boundary;
+  const upper = tab.pinned ? boundary : without.length;
+  const at = Math.min(Math.max(toIndex, lower), upper);
+  pane.tabOrder = [...without.slice(0, at), tabId, ...without.slice(at)];
+}
+function closeTab(tabId) {
+  const tab = workspace.tabs.get(tabId);
+  if (!tab) {
+    return;
+  }
+  const pane = paneOfTab(tabId);
+  const wasActive = pane?.activeTabId === tabId;
+  rememberClosedTab(tab);
+  disposeTab(tab);
+  workspace.tabs.delete(tabId);
+  detachTab(tabId);
+  workspace.mruOrder = workspace.mruOrder.filter((id) => id !== tabId);
+  resetTabCycle();
+  if (pane && paneIsEmpty(pane)) {
+    closePane(pane.id);
+  }
+  if (!wasActive) {
+    return;
+  }
+  const survivor = activePane();
+  const next = workspace.mruOrder.find((id) => survivor.tabOrder.includes(id)) ?? survivor.tabOrder.at(-1) ?? null;
+  if (next) {
+    setActiveTab(next);
+  }
+}
+function closeAllTabs() {
+  const tabs = [...workspace.tabs.values()];
+  workspace.tabs.clear();
+  resetPanes();
+  workspace.mruOrder = [];
+  resetTabCycle();
+  for (const tab of tabs) {
+    disposeTab(tab);
+  }
+}
+function resetPanes() {
+  workspace.panes = [{ activeTabId: null, derived: null, id: PRIMARY_PANE, tabOrder: [] }];
+  workspace.activePaneId = PRIMARY_PANE;
+}
+function rememberClosedTab(tab) {
+  if (!tab.documentPath) {
+    return;
+  }
+  const path = tab.documentPath;
+  workspace.closedTabs = [
+    { documentPath: path },
+    ...workspace.closedTabs.filter((entry) => entry.documentPath !== path)
+  ].slice(0, CLOSED_TAB_LIMIT);
+}
+function takeClosedTabPath() {
+  const [entry] = workspace.closedTabs;
+  if (!entry) {
+    return;
+  }
+  workspace.closedTabs = workspace.closedTabs.slice(1);
+  return entry.documentPath;
+}
+function cycleTab(step) {
+  if (!_cycleList) {
+    _cycleList = workspace.mruOrder.filter((id2) => workspace.tabs.has(id2));
+    _cycleIndex = 0;
+  }
+  const list = _cycleList;
+  if (list.length < 2) {
+    return;
+  }
+  _cycleIndex = ((_cycleIndex + step) % list.length + list.length) % list.length;
+  const id = list[_cycleIndex];
+  setActiveTab(id, { cycling: true });
+  return id;
+}
+function endTabCycle() {
+  const settled = workspace.activeTabId;
+  resetTabCycle();
+  if (settled) {
+    promoteMru(settled);
+  }
+}
+function replaceAllTabs(newTabOpts) {
+  const oldIds = [...workspace.tabs.keys()];
+  const oldTabs = [...workspace.tabs.values()];
+  const newTab = createTab(newTabOpts);
+  workspace.tabs.set(newTab.id, newTab);
+  resetPanes();
+  workspace.panes[0].tabOrder = [newTab.id];
+  workspace.mruOrder = [];
+  resetTabCycle();
+  setActiveTab(newTab.id);
+  ensureCollab(newTab);
+  for (const id of oldIds) {
+    if (id === newTab.id) {
+      continue;
+    }
+    workspace.tabs.delete(id);
+  }
+  for (const tab of oldTabs) {
+    disposeTab(tab);
+  }
+  return newTab;
+}
+function activateTab(tabId, opts = {}) {
+  setActiveTab(tabId, opts);
+}
+function moveTabToPane(tabId, paneId) {
+  const pane = paneById(paneId);
+  if (!pane || !workspace.tabs.has(tabId)) {
+    return null;
+  }
+  if (pane.tabOrder.includes(tabId)) {
+    return pane;
+  }
+  detachTab(tabId);
+  insertIntoPane(pane, tabId);
+  return pane;
+}
+function renameTab(oldId, newId, newDocumentPath) {
+  const tab = workspace.tabs.get(oldId);
+  if (!tab) {
+    return;
+  }
+  tab.id = newId;
+  tab.documentPath = newDocumentPath;
+  workspace.tabs.delete(oldId);
+  workspace.tabs.set(newId, tab);
+  for (const pane of workspace.panes) {
+    pane.tabOrder = pane.tabOrder.map((id) => id === oldId ? newId : id);
+    if (pane.activeTabId === oldId) {
+      pane.activeTabId = newId;
+    }
+  }
+  workspace.mruOrder = workspace.mruOrder.map((id) => id === oldId ? newId : id);
+  resetTabCycle();
+  rekeyCollab(tab);
+}
+function registerTabCommands(registry, deps) {
+  registry.registerAll([...tabCommands(deps), ...paneCommands(deps)]);
+}
+function tabCommands(deps) {
+  const twoOrMoreTabs = () => workspace.tabs.size > 1;
+  return [
+    {
+      id: "document.nextTab",
+      title: "Next Tab",
+      category: "Document",
+      level: "document",
+      keybinding: ["ctrl+tab", "mod+tab"],
+      menus: ["palette"],
+      group: "2_navigate",
+      when: (ctx) => ctx.document.open,
+      enablement: twoOrMoreTabs,
+      requires: "a second open document",
+      run: () => {
+        cycleTab(1);
+      }
+    },
+    {
+      id: "document.previousTab",
+      title: "Previous Tab",
+      category: "Document",
+      level: "document",
+      keybinding: ["ctrl+shift+tab", "mod+shift+tab"],
+      menus: ["palette"],
+      group: "2_navigate",
+      when: (ctx) => ctx.document.open,
+      enablement: twoOrMoreTabs,
+      requires: "a second open document",
+      run: () => {
+        cycleTab(-1);
+      }
+    },
+    {
+      id: "document.reopenClosed",
+      title: "Reopen Closed Document",
+      category: "Document",
+      level: "document",
+      keybinding: "mod+shift+t",
+      menus: ["context/tab", "palette"],
+      group: "1_file",
+      enablement: () => workspace.closedTabs.length > 0,
+      requires: "a document closed in this session",
+      run: async () => {
+        const path = takeClosedTabPath();
+        if (path) {
+          await deps.openFile(path);
+        }
+      }
+    },
+    {
+      id: "document.togglePinned",
+      title: "Pin / Unpin Document",
+      category: "Document",
+      level: "document",
+      menus: ["context/tab", "palette"],
+      group: "1_file",
+      when: (ctx) => ctx.document.open,
+      requires: "an open document",
+      run: () => {
+        const id = workspace.activeTabId;
+        const tab = id ? workspace.tabs.get(id) : null;
+        if (id && tab) {
+          setTabPinned(id, !tab.pinned);
+        }
+      }
+    },
+    {
+      args: argsSchema({
+        pinned: booleanProperty("True to pin the active document's tab, false to unpin it.")
+      }),
+      id: "document.setPinned",
+      title: "Set Document Pinned",
+      category: "Document",
+      level: "document",
+      menus: ["palette"],
+      group: "1_file",
+      when: (ctx) => ctx.document.open,
+      requires: "an open document",
+      run: (_ctx, args) => {
+        const id = workspace.activeTabId;
+        if (id && workspace.tabs.get(id)) {
+          setTabPinned(id, booleanArg("document.setPinned", args, "pinned"));
+        }
+      }
+    },
+    {
+      id: "document.keepOpen",
+      title: "Keep Document Open",
+      category: "Document",
+      level: "document",
+      menus: ["context/tab", "palette"],
+      group: "1_file",
+      when: (ctx) => ctx.document.open,
+      enablement: () => {
+        const id = workspace.activeTabId;
+        return id !== null && workspace.tabs.get(id)?.preview === true;
+      },
+      requires: "a preview document — one opened by a single click",
+      run: () => {
+        const id = workspace.activeTabId;
+        if (id) {
+          promoteTab(id);
+        }
+      }
+    }
+  ];
+}
+function paneCommands(deps) {
+  const twoPanes = () => workspace.panes.length > 1;
+  return [
+    {
+      id: "pane.splitRight",
+      title: "Split Right",
+      category: "View",
+      level: "document",
+      keybinding: "mod+\\",
+      menus: ["context/pane", "context/tab", "palette"],
+      group: "5_pane",
+      when: (ctx) => ctx.document.open,
+      enablement: () => workspace.activeTabId !== null,
+      requires: "an open document",
+      undo: "none",
+      run: () => {
+        splitRight();
+      }
+    },
+    {
+      args: argsSchema({
+        path: stringProperty("Project-relative path of the document to open beside this one.")
+      }),
+      id: "pane.compareWith",
+      title: "Compare With…",
+      category: "View",
+      level: "document",
+      menus: ["context/pane", "context/tab", "palette"],
+      group: "5_pane",
+      when: (ctx) => ctx.document.open,
+      enablement: () => workspace.activeTabId !== null,
+      requires: "an open document",
+      undo: "none",
+      aiTool: {
+        description: "Open a second document in the pane beside the current one, without moving the document " + "you are in.",
+        name: "compare_with"
+      },
+      run: async (_ctx, args) => {
+        const path = stringArg("pane.compareWith", args, "path");
+        const here = activePane();
+        const held = here.activeTabId ? workspace.tabs.get(here.activeTabId) : null;
+        if (held?.documentPath === path) {
+          throw new RangeError(`command "pane.compareWith" argument "path": "${path}" is the document this pane is ` + `already showing — name a different one`);
+        }
+        await deps.openFileInPane(receivingPane().id, path);
+      }
+    },
+    {
+      id: "pane.focusPrimary",
+      title: "Focus Primary Pane",
+      category: "View",
+      level: "document",
+      keybinding: "mod+0",
+      menus: ["palette"],
+      group: "5_pane",
+      enablement: twoPanes,
+      requires: "a split pane grid",
+      undo: "none",
+      run: () => {
+        focusPane(PRIMARY_PANE);
+      }
+    },
+    {
+      id: "pane.focusSecondary",
+      title: "Focus Side Pane",
+      category: "View",
+      level: "document",
+      keybinding: "mod+alt+0",
+      menus: ["palette"],
+      group: "5_pane",
+      enablement: twoPanes,
+      requires: "a split pane grid",
+      undo: "none",
+      run: () => {
+        focusPane(SECONDARY_PANE);
+      }
+    },
+    {
+      id: "pane.unsplit",
+      title: "Close Side Pane",
+      category: "View",
+      level: "document",
+      menus: ["context/pane", "palette"],
+      group: "5_pane",
+      enablement: twoPanes,
+      requires: "a second pane",
+      undo: "none",
+      run: runUnsplit
+    }
+  ];
+}
+function runUnsplit() {
+  const derived = workspace.panes.find((pane) => pane.derived !== null);
+  if (derived?.id === PRIMARY_PANE) {
+    derived.derived = null;
+    if (!paneIsEmpty(derived)) {
+      return;
+    }
+  }
+  closePane(derived?.id ?? SECONDARY_PANE);
+}
+
+export { LANGUAGE_TAG_PATTERN, canonicalizeLocale, isWellFormedLocale, localeDirection, localeLabel, resolveI18n, localeOfPath, servedLocaleOfPath, translationKeyOfPath, translationPathFor, EDITOR_KIND_LABELS, editorKindForMode, canvasViewForMode, inCanvas, hasSelection, hasElementSelection, emptyContext, makeContext, keyScopeStack, PROJECT_CONFIG_PATH, createTab, editorKindOf, editorKindsOf, modeForEditorKind, disposeTab, primarySelection, selectionAnchor, isSelected, cloneSelection, toggleSelected, rangeSelection, isSpliceablePath, structuralBatch, uniquePaths, unifyValues, setPatchConsumer, recordDocOp, transactDoc, transact, beginBatch, endBatch, isBatching, batchTab, setHistoryDelegate, canUndo, canRedo, undo, redo, mutateInsertNode, mutateRemoveNode, mutateDuplicateNode, mutateRemoveNodes, mutateDuplicateNodes, mutateWrapNode, mutateMoveNode, mutateUpdateProperty, mutateUpdateStyle, mutateUpdateAttribute, mutateUpdateMediaStyle, mutateUpdateNestedStyle, mutateUpdateMediaNestedStyle, mutateUpdateNestedStylePath, mutateUpdateMediaNestedStylePath, mutateReplaceStyle, mutateAddDef, mutateRemoveDef, mutateUpdateDef, mutateRenameDef, mutateUpdateProp, mutateAddSwitchCase, mutateRemoveSwitchCase, mutateRenameSwitchCase, mutateUpdateFrontmatter, collabState, isCollabPath, stringArg, optionalStringArg, boundedNumberArg, booleanArg, enumArg, pathArg, nullablePathArg, pathListArg, argsSchema, enumProperty, derivedEnumProperty, numberProperty, booleanProperty, pathProperty, pathListProperty, stringProperty, LOCALE_PLACEHOLDER, collectionForDirectory, collectionForFile, camelToKebab, camelToLabel, toCamelCase, kebabToLabel, propLabel, attrLabel, abbreviateValue, isMediaFormat, inferInputType, findContentTypeSchema, friendlyNameToVar, varDisplayName, parseCemType, jsonClone, configureCollabSerializer, configureCollabParser, configureCollabNotifier, collabSourceContext, collabReadOnly, collabSave, flushAllCollab, setCollabEnabled, isCollabEnabled, PRIMARY_PANE, SECONDARY_PANE, MAX_PANES, workspace, activeTab, activePane, paneById, paneOfTab, focusPane, isPaneFocused, focusOtherPane, splitRight, sidePane, receivingPane, closePane, detachTab, insertIntoPane, setWorkspaceProject, isTabActive, tabIsLive, openTab, promoteTab, promoteDirtyPreviewTabs, setTabPinned, moveTab, closeTab, closeAllTabs, takeClosedTabPath, cycleTab, endTabCycle, replaceAllTabs, activateTab, moveTabToPane, renameTab, registerTabCommands, tabCommands, paneCommands };
+
+//# debugId=FC372971F7D8792C64756E2164756E21
+//# sourceMappingURL=studio-2zkz8evn.js.map