@jxsuite/studio 2.0.0 → 2.1.0

package/dist/chunks/studio-d77qm3pk.js

@@ -1,3427 +0,0 @@
-import {
-  UPLOAD_ACCEPT,
-  flushCanvasEdits,
-  isImage,
-  rectOf,
-  setEditZoom,
-  uploadAssets,
-  validateComponentSlots
-} from "./studio-ygzav7z5.js";
-import {
-  loadComponentRegistry
-} from "./studio-hhj92gcr.js";
-import {
-  classMap
-} from "./studio-cx91mnh8.js";
-import {
-  autoSyncProjectOnOpen,
-  maybePromptJxsuiteUpdate,
-  showProgressModal
-} from "./studio-568nx4t5.js";
-import {
-  applyPanelCollapse,
-  errorMessage,
-  openModal,
-  renderPopover,
-  showConfirmDialog,
-  showPromptDialog,
-  statusMessage,
-  view
-} from "./studio-asvf0j9e.js";
-import {
-  activateTab,
-  activeTab,
-  closeAllTabs,
-  collabSave,
-  collabState,
-  createState,
-  effect,
-  findContentTypeSchema,
-  isCollabPath,
-  onScopeDispose,
-  openTab,
-  projectState,
-  reactive,
-  renameTab,
-  renderOnly,
-  replaceAllTabs,
-  requireProjectState,
-  setHistoryDelegate,
-  setProjectState,
-  setWorkspaceProject,
-  toRaw,
-  updateUi,
-  workspace
-} from "./studio-rq0vxb19.js";
-import {
-  ref
-} from "./studio-4k0m4fmp.js";
-import {
-  html,
-  nothing
-} from "./studio-5x5774ak.js";
-import {
-  defaultContentFormat,
-  documentExtensions,
-  formatByName,
-  formatForPath,
-  formatParse,
-  formatSerialize,
-  loadFormats,
-  noFormatError,
-  refreshExtensionUi,
-  refreshFormats,
-  splitFormatDocument
-} from "./studio-97qcgvdn.js";
-import {
-  getPlatform,
-  hasPlatform
-} from "./studio-9smfzqhc.js";
-import {
-  combine,
-  draggable,
-  dropTargetForElements,
-  monitorForElements
-} from "./studio-kr88ryr7.js";
-import {
-  __require
-} from "./studio-md4gps17.js";
-
-// src/project-list.ts
-var cache = [];
-function platformListsProjects() {
-  return hasPlatform() && typeof getPlatform().listProjects === "function";
-}
-async function hydrateProjectList() {
-  if (!platformListsProjects()) {
-    cache = [];
-    return;
-  }
-  try {
-    cache = await getPlatform().listProjects?.() ?? [];
-  } catch {
-    cache = [];
-  }
-}
-function getProjectList() {
-  return cache;
-}
-function seedProjectList(entries) {
-  cache = entries;
-}
-
-// src/services/automation.ts
-function shouldInstallAutomation(search) {
-  return new URLSearchParams(search).get("automation") === "1";
-}
-function createAutomationApi(deps) {
-  return {
-    editDef(defName) {
-      updateUi("editingFunction", { defName, type: "def" });
-      deps.render();
-    },
-    editFunction(path, eventKey) {
-      updateUi("editingFunction", { eventKey, path, type: "event" });
-      deps.render();
-    },
-    openBrowse() {
-      deps.openBrowseModal();
-    },
-    openDataGrid(options) {
-      deps.openConnectorGrid(options.connection, options.table);
-    },
-    openNewProject() {
-      deps.openNewProjectModal();
-    },
-    openQuickSearch() {
-      deps.openQuickSearchPalette();
-    },
-    openSettings(section) {
-      deps.openSettingsModal(section);
-    },
-    seedAssistant(options) {
-      deps.seedAssistantMessages(options.messages);
-    },
-    seedCollab(options) {
-      const tab = activeTab.value;
-      if (!tab) {
-        return;
-      }
-      const state = collabState(tab);
-      state.status = "synced";
-      state.active = true;
-      state.peers = options.peers.map((peer) => ({
-        ...peer,
-        state: {
-          ...peer.state,
-          focusedPath: peer.state.focusedPath ?? tab.documentPath
-        }
-      }));
-      deps.render();
-    },
-    seedPublish(options) {
-      deps.seedPublishConnected(options);
-    },
-    showWelcome(options) {
-      closeAllTabs();
-      setProjectState(null);
-      if (options?.projects) {
-        seedProjectList(options.projects);
-      }
-      view.chatPanelCollapsed = true;
-      applyPanelCollapse();
-      deps.render();
-    },
-    getState() {
-      return {
-        activeTabId: workspace.activeTabId,
-        canvasMode: deps.getCanvasMode(),
-        canvasStatus: activeTab.value?.session.canvas.status ?? null,
-        leftTab: view.leftTab
-      };
-    },
-    select(path) {
-      const tab = activeTab.value;
-      if (tab) {
-        tab.session.selection = path;
-      }
-      deps.render();
-    },
-    setActivity(tab) {
-      view.leftTab = tab;
-      view.leftPanelCollapsed = false;
-      applyPanelCollapse();
-      renderOnly("leftPanel");
-      deps.renderActivityBar();
-    },
-    setCanvasMode(mode) {
-      deps.setCanvasMode(mode);
-      deps.render();
-    },
-    setRightTab(tab) {
-      if (tab === "assistant") {
-        view.chatPanelCollapsed = false;
-        applyPanelCollapse();
-        renderOnly("chatPanel");
-        deps.render();
-        return;
-      }
-      updateUi("rightTab", tab);
-      deps.render();
-    },
-    setStatus(text) {
-      deps.statusMessage(text);
-    },
-    setTheme(color) {
-      document.querySelector("sp-theme")?.setAttribute("color", color);
-    },
-    setZoom(zoom) {
-      updateUi("zoom", zoom);
-      deps.render();
-    },
-    setEditZoom(zoom) {
-      setEditZoom(zoom);
-    },
-    waitForCanvasReady(timeoutMs = 30000) {
-      return new Promise((resolve, reject) => {
-        const started = Date.now();
-        const tick = () => {
-          if (activeTab.value?.session.canvas.status === "ready") {
-            resolve();
-            return;
-          }
-          if (Date.now() - started > timeoutMs) {
-            reject(new Error(`canvas not ready after ${timeoutMs}ms`));
-            return;
-          }
-          setTimeout(tick, 50);
-        };
-        tick();
-      });
-    }
-  };
-}
-function installAutomationHook(deps) {
-  if (!shouldInstallAutomation(location.search)) {
-    return false;
-  }
-  globalThis.__jxAutomation = createAutomationApi(deps);
-  return true;
-}
-
-// src/packages/ensure-deps.ts
-async function ensureDependenciesInstalled() {
-  if (shouldInstallAutomation(location.search)) {
-    return;
-  }
-  const platform = getPlatform();
-  if (!platform.dependenciesNeedInstall || !platform.installDependencies) {
-    return;
-  }
-  let needs = false;
-  try {
-    needs = await platform.dependenciesNeedInstall();
-  } catch {
-    return;
-  }
-  if (!needs) {
-    return;
-  }
-  const progress = showProgressModal({
-    status: "Running bun install…",
-    title: "Installing dependencies"
-  });
-  try {
-    const result = await platform.installDependencies();
-    if (result.ok) {
-      progress.done();
-    } else {
-      progress.fail(result.log ?? "bun install failed");
-    }
-  } catch (error) {
-    progress.fail(error instanceof Error ? error.message : String(error));
-  }
-}
-
-// src/files/fs-events.ts
-var RECENT_MS = 1500;
-var recentLocal = new Map;
-var norm = (p) => p.replaceAll("\\", "/");
-function markLocalMutation(...paths) {
-  const expiry = Date.now() + RECENT_MS;
-  for (const p of paths) {
-    if (p) {
-      recentLocal.set(norm(p), expiry);
-    }
-  }
-}
-function isRecentLocal(path) {
-  const key = norm(path);
-  const expiry = recentLocal.get(key);
-  if (expiry === undefined) {
-    return false;
-  }
-  if (Date.now() > expiry) {
-    recentLocal.delete(key);
-    return false;
-  }
-  return true;
-}
-function parentDir(path) {
-  const i = path.lastIndexOf("/");
-  return i === -1 ? "." : path.slice(0, i);
-}
-function baseName(path) {
-  const i = path.lastIndexOf("/");
-  return i === -1 ? path : path.slice(i + 1);
-}
-function applyFsEvents(dirs, expanded, events) {
-  const changedDirs = new Set;
-  for (const ev of events) {
-    const parent = parentDir(ev.path);
-    if (ev.type === "add" || ev.type === "addDir") {
-      const entries = dirs.get(parent);
-      if (entries && !entries.some((e) => e.path === ev.path)) {
-        entries.push({
-          name: baseName(ev.path),
-          path: ev.path,
-          type: ev.isDir ? "directory" : "file"
-        });
-        changedDirs.add(parent);
-      }
-      if (ev.type === "addDir" && !dirs.has(ev.path)) {
-        dirs.set(ev.path, []);
-      }
-    } else if (ev.type === "unlink" || ev.type === "unlinkDir") {
-      const entries = dirs.get(parent);
-      if (entries) {
-        const idx = entries.findIndex((e) => e.path === ev.path);
-        if (idx !== -1) {
-          entries.splice(idx, 1);
-          changedDirs.add(parent);
-        }
-      }
-      if (ev.type === "unlinkDir") {
-        dirs.delete(ev.path);
-        const nestedDirs = [];
-        for (const key of dirs.keys()) {
-          if (key.startsWith(`${ev.path}/`)) {
-            nestedDirs.push(key);
-          }
-        }
-        for (const key of nestedDirs) {
-          dirs.delete(key);
-        }
-        const staleExpanded = [];
-        for (const key of expanded) {
-          if (key === ev.path || key.startsWith(`${ev.path}/`)) {
-            staleExpanded.push(key);
-          }
-        }
-        for (const key of staleExpanded) {
-          expanded.delete(key);
-        }
-      }
-    }
-  }
-  return changedDirs;
-}
-function startFsSync(ctx) {
-  const platform = getPlatform();
-  if (!platform.subscribeFileEvents) {
-    return () => {};
-  }
-  let pending = [];
-  let timer = null;
-  const flush = () => {
-    timer = null;
-    const state = projectState;
-    const batch = pending.filter((e) => !isRecentLocal(e.path));
-    pending = [];
-    if (!state || batch.length === 0) {
-      return;
-    }
-    const changedDirs = applyFsEvents(state.dirs, state.expanded, batch);
-    if (ctx.onContentChange) {
-      for (const ev of batch) {
-        if (ev.type === "change") {
-          ctx.onContentChange(ev.path);
-        }
-      }
-    }
-    if (changedDirs.size > 0) {
-      ctx.renderLeftPanel();
-    }
-  };
-  return platform.subscribeFileEvents((events) => {
-    pending.push(...events);
-    if (timer) {
-      clearTimeout(timer);
-    }
-    timer = setTimeout(flush, 50);
-  });
-}
-
-// src/services/data-service.ts
-function platformOrNull() {
-  try {
-    return getPlatform();
-  } catch {
-    return null;
-  }
-}
-function dataSurfaceAvailable() {
-  return typeof platformOrNull()?.dataRows === "function";
-}
-async function fetchConnections() {
-  const platform = platformOrNull();
-  if (typeof platform?.dataConnections !== "function") {
-    return null;
-  }
-  return platform.dataConnections();
-}
-async function testConnection(connection) {
-  const platform = platformOrNull();
-  if (typeof platform?.dataConnectionTest !== "function") {
-    return { error: "Connection tests are not supported by this backend", ok: false };
-  }
-  try {
-    return await platform.dataConnectionTest(connection);
-  } catch (error) {
-    return { error: error instanceof Error ? error.message : String(error), ok: false };
-  }
-}
-async function pushSchema(opts) {
-  const platform = platformOrNull();
-  if (typeof platform?.dataPush !== "function") {
-    return { applied: false, errors: ["Schema push is not supported by this backend"], plan: [] };
-  }
-  try {
-    return await platform.dataPush(opts);
-  } catch (error) {
-    return {
-      applied: false,
-      errors: [error instanceof Error ? error.message : String(error)],
-      plan: []
-    };
-  }
-}
-function requireMember(name) {
-  const platform = platformOrNull();
-  const member = platform?.[name];
-  if (member === undefined || member === null) {
-    throw new Error(`The ${String(name)} surface is not supported by this backend`);
-  }
-  return member;
-}
-function fetchRows(query) {
-  return requireMember("dataRows")(query);
-}
-function insertRow(req) {
-  return requireMember("dataInsertRow")(req);
-}
-function updateRow(req) {
-  return requireMember("dataUpdateRow")(req);
-}
-function deleteRow(req) {
-  return requireMember("dataDeleteRow")(req);
-}
-function deriveSecretEnvName(sectionKey, entryKey, fieldKey) {
-  const constant = (raw) => raw.replaceAll(/([a-z0-9])([A-Z])/g, "$1_$2").replaceAll(/[^A-Za-z0-9]+/g, "_").replaceAll(/^_+|_+$/g, "").toUpperCase();
-  const parts = [entryKey ?? sectionKey, fieldKey.replace(/Env$/, "")].map((part) => constant(part)).filter(Boolean);
-  const name = parts.join("_") || "SECRET";
-  return /^\d/.test(name) ? `JX_${name}` : name;
-}
-
-// src/grid/grid-source.ts
-function cellValuesEqual(a, b) {
-  if (a === b) {
-    return true;
-  }
-  if (Array.isArray(a) && Array.isArray(b)) {
-    return a.length === b.length && a.every((v, i) => v === b[i]);
-  }
-  if (a !== null && b !== null && typeof a === "object" && typeof b === "object" && !Array.isArray(a) && !Array.isArray(b)) {
-    return a.$ref === b.$ref;
-  }
-  return false;
-}
-var GRID_SCHEME = "grid://";
-function makeGridTabId(ref2) {
-  switch (ref2.kind) {
-    case "pages": {
-      return `${GRID_SCHEME}pages`;
-    }
-    case "collection": {
-      return `${GRID_SCHEME}collection/${encodeURIComponent(ref2.name)}`;
-    }
-    default: {
-      return `${GRID_SCHEME}data/${encodeURIComponent(ref2.connection)}/${encodeURIComponent(ref2.table)}`;
-    }
-  }
-}
-function isGridTabId(id) {
-  return id.startsWith(GRID_SCHEME);
-}
-function parseGridTabId(id) {
-  if (!isGridTabId(id)) {
-    return null;
-  }
-  const parts = id.slice(GRID_SCHEME.length).split("/");
-  if (parts[0] === "pages" && parts.length === 1) {
-    return { kind: "pages" };
-  }
-  if (parts[0] === "collection" && parts.length === 2 && parts[1]) {
-    return { kind: "collection", name: decodeURIComponent(parts[1]) };
-  }
-  if (parts[0] === "data" && parts.length === 3 && parts[1] && parts[2]) {
-    return {
-      connection: decodeURIComponent(parts[1]),
-      kind: "data",
-      table: decodeURIComponent(parts[2])
-    };
-  }
-  return null;
-}
-function gridTabLabel(id) {
-  const ref2 = parseGridTabId(id);
-  if (!ref2) {
-    return null;
-  }
-  switch (ref2.kind) {
-    case "pages": {
-      return "Pages · grid";
-    }
-    case "collection": {
-      return `${ref2.name} · grid`;
-    }
-    default: {
-      return `${ref2.table} @ ${ref2.connection} · grid`;
-    }
-  }
-}
-
-// src/grid/edit-buffer.ts
-var _tempCounter = 0;
-function createEditBuffer(opts) {
-  const coalesceMs = opts.coalesceMs ?? 800;
-  const now = opts.now ?? (() => Date.now());
-  const state = reactive({
-    deletes: new Set,
-    errors: new Map,
-    inserts: new Map,
-    pending: new Map,
-    redoStack: [],
-    stale: new Set,
-    undoStack: []
-  });
-  let groupOps = null;
-  const setError = (rowKey, field, message) => {
-    const row = state.errors.get(rowKey);
-    if (row) {
-      row.set(field, message);
-    } else {
-      state.errors.set(rowKey, new Map([[field, message]]));
-    }
-  };
-  const clearCellError = (rowKey, field) => {
-    const row = state.errors.get(rowKey);
-    row?.delete(field);
-    if (row?.size === 0) {
-      state.errors.delete(rowKey);
-    }
-  };
-  const pushOp = (op) => {
-    state.redoStack.length = 0;
-    if (groupOps) {
-      groupOps.push(op);
-      return;
-    }
-    const last = state.undoStack.at(-1);
-    if (op.kind === "cell" && last?.kind === "cell" && last.rowKey === op.rowKey && last.field === op.field && op.at - last.at <= coalesceMs) {
-      last.after = op.after;
-      last.at = op.at;
-      return;
-    }
-    state.undoStack.push(op);
-  };
-  const writeCell = (rowKey, field, value) => {
-    const insertCells = state.inserts.get(rowKey);
-    if (insertCells) {
-      if (value === null) {
-        delete insertCells[field];
-      } else {
-        insertCells[field] = value;
-      }
-      return;
-    }
-    if (cellValuesEqual(value, opts.resolveBaseline(rowKey, field))) {
-      const row2 = state.pending.get(rowKey);
-      row2?.delete(field);
-      if (row2?.size === 0) {
-        state.pending.delete(rowKey);
-      }
-      return;
-    }
-    const row = state.pending.get(rowKey);
-    if (row) {
-      row.set(field, { value });
-    } else {
-      state.pending.set(rowKey, new Map([[field, { value }]]));
-    }
-  };
-  const effectiveValue = (rowKey, field) => {
-    const insertCells = state.inserts.get(rowKey);
-    if (insertCells) {
-      return insertCells[field] ?? null;
-    }
-    const pending = state.pending.get(rowKey)?.get(field);
-    return pending ? pending.value : opts.resolveBaseline(rowKey, field);
-  };
-  const cellError = (rowKey, field) => {
-    const row = state.errors.get(rowKey);
-    return row?.get(field) ?? row?.get("*") ?? null;
-  };
-  const applyOp = (op, direction) => {
-    switch (op.kind) {
-      case "cell": {
-        writeCell(op.rowKey, op.field, direction === "undo" ? op.before : op.after);
-        break;
-      }
-      case "insert": {
-        if (direction === "undo") {
-          state.inserts.delete(op.tempKey);
-        } else {
-          state.inserts.set(op.tempKey, { ...op.cells });
-        }
-        break;
-      }
-      case "drop-insert": {
-        if (direction === "undo") {
-          state.inserts.set(op.tempKey, { ...op.cells });
-        } else {
-          state.inserts.delete(op.tempKey);
-        }
-        break;
-      }
-      case "delete": {
-        if (direction === "undo") {
-          state.deletes.delete(op.rowKey);
-        } else {
-          state.deletes.add(op.rowKey);
-        }
-        break;
-      }
-      default: {
-        const ops = direction === "undo" ? op.ops.toReversed() : op.ops;
-        for (const child of ops) {
-          applyOp(child, direction);
-        }
-        break;
-      }
-    }
-  };
-  const beginGroup = () => {
-    if (groupOps) {
-      throw new Error("edit-buffer: groups may not nest");
-    }
-    groupOps = [];
-  };
-  const endGroup = () => {
-    const ops = groupOps;
-    groupOps = null;
-    if (!ops) {
-      return;
-    }
-    if (ops.length === 1) {
-      state.undoStack.push(ops[0]);
-    } else if (ops.length > 1) {
-      state.undoStack.push({ kind: "group", ops });
-    }
-  };
-  const pruneHistory = (dropRow) => {
-    const keep = (op) => {
-      switch (op.kind) {
-        case "cell": {
-          return dropRow(op.rowKey) ? null : op;
-        }
-        case "insert":
-        case "drop-insert": {
-          return dropRow(op.tempKey) ? null : op;
-        }
-        case "delete": {
-          return dropRow(op.rowKey) ? null : op;
-        }
-        default: {
-          const ops = op.ops.map((child) => keep(child)).filter((o) => o !== null);
-          return ops.length > 0 ? { kind: "group", ops } : null;
-        }
-      }
-    };
-    state.undoStack = state.undoStack.map(keep).filter((o) => o !== null);
-    state.redoStack = state.redoStack.map(keep).filter((o) => o !== null);
-  };
-  return {
-    applyCommitResult(result) {
-      const committedRows = new Set;
-      for (const cell of result.cells) {
-        if (cell.ok) {
-          const row = state.pending.get(cell.rowKey);
-          row?.delete(cell.field);
-          if (row?.size === 0) {
-            state.pending.delete(cell.rowKey);
-          }
-          clearCellError(cell.rowKey, cell.field);
-        } else {
-          setError(cell.rowKey, cell.field, cell.error ?? "Save failed");
-          if (cell.stale) {
-            state.stale.add(cell.rowKey);
-          }
-        }
-      }
-      for (const ins of result.inserts) {
-        if (ins.ok) {
-          state.inserts.delete(ins.tempKey);
-          state.errors.delete(ins.tempKey);
-          committedRows.add(ins.tempKey);
-        } else {
-          setError(ins.tempKey, "*", ins.error ?? "Insert failed");
-        }
-      }
-      for (const del of result.deletes) {
-        if (del.ok) {
-          state.deletes.delete(del.rowKey);
-          state.pending.delete(del.rowKey);
-          state.errors.delete(del.rowKey);
-          committedRows.add(del.rowKey);
-        } else {
-          setError(del.rowKey, "*", del.error ?? "Delete failed");
-          if (del.stale) {
-            state.stale.add(del.rowKey);
-          }
-        }
-      }
-      for (const row of committedRows) {
-        state.stale.delete(row);
-      }
-      if (committedRows.size > 0) {
-        pruneHistory((rowKey) => committedRows.has(rowKey));
-      }
-    },
-    buildBatch() {
-      const cells = [];
-      for (const [rowKey, fields] of state.pending) {
-        if (state.deletes.has(rowKey)) {
-          continue;
-        }
-        for (const [field, cell] of fields) {
-          cells.push({
-            baseline: opts.resolveBaseline(rowKey, field),
-            field,
-            rowKey,
-            value: cell.value
-          });
-        }
-      }
-      return {
-        cells,
-        deletes: [...state.deletes].map((rowKey) => ({ rowKey })),
-        inserts: [...state.inserts].map(([tempKey, insertCells]) => ({
-          cells: { ...insertCells },
-          tempKey
-        }))
-      };
-    },
-    canRedo: () => state.redoStack.length > 0,
-    canUndo: () => state.undoStack.length > 0,
-    cellError,
-    cellState(rowKey, field) {
-      if (cellError(rowKey, field) !== null) {
-        return "error";
-      }
-      if (state.stale.has(rowKey)) {
-        return "stale";
-      }
-      if (state.inserts.has(rowKey) || state.pending.get(rowKey)?.has(field)) {
-        return "dirty";
-      }
-      return "clean";
-    },
-    deleteRow(rowKey) {
-      if (state.deletes.has(rowKey)) {
-        return;
-      }
-      const insertCells = state.inserts.get(rowKey);
-      if (insertCells) {
-        const cells = { ...insertCells };
-        state.inserts.delete(rowKey);
-        state.errors.delete(rowKey);
-        state.stale.delete(rowKey);
-        pushOp({ cells, kind: "drop-insert", tempKey: rowKey });
-        return;
-      }
-      state.deletes.add(rowKey);
-      pushOp({ kind: "delete", rowKey });
-    },
-    dirtyCount() {
-      let count = state.inserts.size + state.deletes.size;
-      for (const [rowKey, fields] of state.pending) {
-        if (!state.deletes.has(rowKey)) {
-          count += fields.size;
-        }
-      }
-      return count;
-    },
-    discardRow(rowKey) {
-      state.pending.delete(rowKey);
-      state.deletes.delete(rowKey);
-      state.inserts.delete(rowKey);
-      state.errors.delete(rowKey);
-      state.stale.delete(rowKey);
-      pruneHistory((key) => key === rowKey);
-    },
-    effectiveValue,
-    beginGroup,
-    endGroup,
-    group(fn) {
-      beginGroup();
-      try {
-        fn();
-      } finally {
-        endGroup();
-      }
-    },
-    insertRow(cells = {}) {
-      _tempCounter += 1;
-      const tempKey = `__new-${_tempCounter}`;
-      state.inserts.set(tempKey, { ...cells });
-      pushOp({ cells: { ...cells }, kind: "insert", tempKey });
-      return tempKey;
-    },
-    isDirty: () => state.pending.size > 0 || state.inserts.size > 0 || state.deletes.size > 0,
-    isInsertKey: (rowKey) => state.inserts.has(rowKey),
-    markStale(rowKeys) {
-      for (const rowKey of rowKeys) {
-        state.stale.add(rowKey);
-      }
-    },
-    redo() {
-      const op = state.redoStack.pop();
-      if (!op) {
-        return false;
-      }
-      applyOp(op, "redo");
-      state.undoStack.push(op);
-      return true;
-    },
-    reset() {
-      state.pending.clear();
-      state.inserts.clear();
-      state.deletes.clear();
-      state.errors.clear();
-      state.stale.clear();
-      state.undoStack.length = 0;
-      state.redoStack.length = 0;
-    },
-    rowState(rowKey) {
-      if (state.deletes.has(rowKey)) {
-        return "pending-delete";
-      }
-      if (state.inserts.has(rowKey)) {
-        return "pending-insert";
-      }
-      if (state.stale.has(rowKey)) {
-        return "stale";
-      }
-      if (state.pending.has(rowKey) || state.errors.has(rowKey)) {
-        return "dirty";
-      }
-      return "clean";
-    },
-    setCell(rowKey, field, value) {
-      const before = effectiveValue(rowKey, field);
-      if (cellValuesEqual(before, value)) {
-        return;
-      }
-      writeCell(rowKey, field, value);
-      pushOp({ after: value, at: now(), before, field, kind: "cell", rowKey });
-    },
-    state,
-    undo() {
-      const op = state.undoStack.pop();
-      if (!op) {
-        return false;
-      }
-      applyOp(op, "undo");
-      state.redoStack.push(op);
-      return true;
-    }
-  };
-}
-
-// src/grid/grid-controller.ts
-var ROW_KEY_FIELD = "__key";
-var _controllers = new WeakMap;
-function getGridController(tab) {
-  return tab ? _controllers.get(toRaw(tab)) ?? null : null;
-}
-function createGridController(tab, source) {
-  const state = reactive({
-    columns: [],
-    error: null,
-    loading: false,
-    query: {},
-    rows: [],
-    saving: false,
-    total: 0
-  });
-  let rowByKey = new Map;
-  const indexRows = (rows) => {
-    rowByKey = new Map(rows.map((row) => [row.key, row]));
-  };
-  const buffer = createEditBuffer({
-    resolveBaseline: (rowKey, field) => rowByKey.get(rowKey)?.cells[field] ?? null
-  });
-  const reloadRows = async () => {
-    const result = await source.rows(state.query);
-    state.rows = result.rows;
-    state.total = result.total;
-    indexRows(result.rows);
-  };
-  const requiredViolations = (batch) => {
-    const required = state.columns.filter((c) => c.required && c.editable);
-    if (required.length === 0) {
-      return null;
-    }
-    const cells = batch.cells.filter((cell) => cell.value === null && required.some((c) => c.field === cell.field)).map((cell) => ({ error: "Required", field: cell.field, ok: false, rowKey: cell.rowKey }));
-    const inserts = batch.inserts.filter((insert) => required.some((c) => insert.cells[c.field] === null || insert.cells[c.field] === undefined)).map((insert) => {
-      const missing = required.filter((c) => insert.cells[c.field] === null || insert.cells[c.field] === undefined).map((c) => c.field).join(", ");
-      return { error: `Missing required: ${missing}`, ok: false, tempKey: insert.tempKey };
-    });
-    if (cells.length === 0 && inserts.length === 0) {
-      return null;
-    }
-    return { cells, deletes: [], inserts };
-  };
-  let viewBinding = null;
-  const syncView = () => viewBinding?.refreshData();
-  const controller = {
-    addRow(cells = {}) {
-      const tempKey = buffer.insertRow(cells);
-      syncView();
-      return tempKey;
-    },
-    bindView(view2) {
-      viewBinding = view2;
-    },
-    buffer,
-    deleteRows(rowKeys) {
-      if (rowKeys.length === 0) {
-        return;
-      }
-      buffer.group(() => {
-        for (const rowKey of rowKeys) {
-          buffer.deleteRow(rowKey);
-        }
-      });
-      syncView();
-    },
-    discardRow(rowKey) {
-      buffer.discardRow(rowKey);
-      syncView();
-    },
-    replaceAll(find, replace) {
-      if (find === "") {
-        return 0;
-      }
-      const textColumns = state.columns.filter((column) => column.editable && (column.kind === "string" || column.kind === "text"));
-      const rowKeys = [...state.rows.map((row) => row.key), ...buffer.state.inserts.keys()];
-      let changed = 0;
-      buffer.group(() => {
-        for (const rowKey of rowKeys) {
-          if (buffer.rowState(rowKey) === "pending-delete") {
-            continue;
-          }
-          for (const column of textColumns) {
-            const value = buffer.effectiveValue(rowKey, column.field);
-            if (typeof value === "string" && value.includes(find)) {
-              buffer.setCell(rowKey, column.field, value.replaceAll(find, replace));
-              changed += 1;
-            }
-          }
-        }
-      });
-      if (changed > 0) {
-        syncView();
-      }
-      return changed;
-    },
-    effectiveRows() {
-      const plain = (value) => Array.isArray(value) ? [...value] : value !== null && typeof value === "object" ? { $ref: value.$ref } : value;
-      const rowObject = (key) => {
-        const cells = { [ROW_KEY_FIELD]: key };
-        for (const column of state.columns) {
-          cells[column.field] = plain(buffer.effectiveValue(key, column.field));
-        }
-        return cells;
-      };
-      const rows = state.rows.map((row) => rowObject(row.key));
-      for (const [tempKey] of buffer.state.inserts) {
-        rows.push(rowObject(tempKey));
-      }
-      return rows;
-    },
-    async load() {
-      state.loading = true;
-      state.error = null;
-      try {
-        state.columns = await source.columns();
-        await reloadRows();
-      } catch (error) {
-        state.error = errorMessage(error);
-      } finally {
-        state.loading = false;
-      }
-      syncView();
-    },
-    async refresh() {
-      if (buffer.isDirty()) {
-        const confirmed = await showConfirmDialog("Refresh Grid", `Discard ${buffer.dirtyCount()} pending change(s) and reload?`, { confirmLabel: "Discard & Reload", destructive: true });
-        if (!confirmed) {
-          return;
-        }
-      }
-      buffer.reset();
-      await source.refresh?.();
-      await this.load();
-    },
-    async save() {
-      if (state.saving) {
-        return;
-      }
-      const batch = buffer.buildBatch();
-      const changeCount = batch.cells.length + batch.inserts.length + batch.deletes.length;
-      if (changeCount === 0) {
-        statusMessage("No grid changes to save");
-        return;
-      }
-      const violations = requiredViolations(batch);
-      if (violations) {
-        buffer.applyCommitResult(violations);
-        statusMessage("Required cells are empty — fix the marked rows and save again", 5000);
-        return;
-      }
-      if (batch.deletes.length > 0) {
-        const confirmed = await showConfirmDialog("Delete Rows", `Save will permanently delete ${batch.deletes.length} row(s). Continue?`, { confirmLabel: "Delete & Save", destructive: true });
-        if (!confirmed) {
-          return;
-        }
-      }
-      const affectedRows = new Set(batch.cells.map((c) => c.rowKey)).size + batch.inserts.length + batch.deletes.length;
-      const progress = affectedRows > 5 ? showProgressModal({ title: "Saving grid" }) : null;
-      state.saving = true;
-      try {
-        const result = await source.commit(batch);
-        const cellKey = (rowKey, field) => `${rowKey}\x00${field}`;
-        const batchCells = new Map(batch.cells.map((c) => [cellKey(c.rowKey, c.field), c]));
-        for (const outcome of result.cells) {
-          const cell = batchCells.get(cellKey(outcome.rowKey, outcome.field));
-          if (outcome.ok && cell) {
-            const row = rowByKey.get(outcome.rowKey);
-            if (row) {
-              row.cells[outcome.field] = cell.value;
-            }
-          }
-        }
-        buffer.applyCommitResult(result);
-        const structural = result.inserts.some((r) => r.ok) || result.deletes.some((r) => r.ok);
-        if (structural) {
-          await reloadRows();
-        }
-        const okCount = result.cells.filter((r) => r.ok).length + result.inserts.filter((r) => r.ok).length + result.deletes.filter((r) => r.ok).length;
-        const failed = changeCount - okCount;
-        const staleCount = result.cells.filter((r) => r.stale).length + result.deletes.filter((r) => r.stale).length;
-        statusMessage(failed === 0 ? `Saved ${okCount} change(s)` : `Saved ${okCount} · ${failed} failed${staleCount ? ` (${staleCount} stale)` : ""} — kept pending`, failed === 0 ? 3000 : 6000);
-      } catch (error) {
-        statusMessage(`Save error: ${errorMessage(error)}`, 6000);
-      } finally {
-        state.saving = false;
-        progress?.done();
-        syncView();
-      }
-    },
-    serializeForSource() {
-      if (!source.serializeForSource) {
-        return null;
-      }
-      return source.serializeForSource(buffer.buildBatch());
-    },
-    async setQuery(query) {
-      state.query = query;
-      state.loading = true;
-      try {
-        await reloadRows();
-      } catch (error) {
-        state.error = errorMessage(error);
-      } finally {
-        state.loading = false;
-      }
-      syncView();
-    },
-    source,
-    state,
-    tab
-  };
-  tab.scope.run(() => {
-    effect(() => {
-      tab.doc.dirty = buffer.isDirty();
-    });
-    setHistoryDelegate(tab, {
-      canRedo: () => buffer.canRedo(),
-      canUndo: () => buffer.canUndo(),
-      redo: () => {
-        buffer.redo();
-        syncView();
-      },
-      undo: () => {
-        buffer.undo();
-        syncView();
-      }
-    });
-    const platform = getPlatform();
-    if (platform.subscribeFileEvents && source.backingPaths) {
-      const unsubscribe = platform.subscribeFileEvents((events) => {
-        const backing = source.backingPaths();
-        const hitKeys = new Set;
-        for (const event of events) {
-          if (event.isDir) {
-            continue;
-          }
-          const path = event.path.replaceAll("\\", "/");
-          const rowKey = backing.get(path);
-          if (rowKey !== undefined && !isRecentLocal(path)) {
-            hitKeys.add(rowKey);
-          }
-        }
-        if (hitKeys.size === 0) {
-          return;
-        }
-        if (buffer.isDirty()) {
-          const keys = hitKeys.has("*") ? state.rows.map((row) => row.key) : [...hitKeys];
-          buffer.markStale(keys);
-          statusMessage("Grid rows changed on disk — marked stale (refresh to reload)", 5000);
-          syncView();
-        } else {
-          controller.refresh();
-        }
-      });
-      onScopeDispose(unsubscribe);
-    }
-    onScopeDispose(() => {
-      setHistoryDelegate(tab, null);
-      _controllers.delete(toRaw(tab));
-      source.dispose?.();
-    });
-  });
-  _controllers.set(toRaw(tab), controller);
-  return controller;
-}
-
-// src/grid/csv-codec.ts
-function splitRecords(text) {
-  const records = [];
-  let fields = [];
-  let field = "";
-  let inQuotes = false;
-  let fieldStarted = false;
-  const endField = () => {
-    fields.push(field);
-    field = "";
-    fieldStarted = false;
-  };
-  const endRecord = () => {
-    endField();
-    if (fields.length === 1 && fields[0] === "") {
-      fields = [];
-      return;
-    }
-    records.push(fields);
-    fields = [];
-  };
-  for (let i = 0;i < text.length; i++) {
-    const ch = text[i];
-    if (inQuotes) {
-      if (ch === '"') {
-        if (text[i + 1] === '"') {
-          field += '"';
-          i += 1;
-        } else {
-          inQuotes = false;
-        }
-      } else {
-        field += ch;
-      }
-      continue;
-    }
-    if (ch === '"' && !fieldStarted) {
-      inQuotes = true;
-      fieldStarted = true;
-    } else if (ch === '"') {
-      field += ch;
-    } else if (ch === ",") {
-      endField();
-    } else if (ch === `
-`) {
-      endRecord();
-    } else if (ch === "\r") {
-      if (text[i + 1] === `
-`) {
-        i += 1;
-      }
-      endRecord();
-    } else {
-      field += ch;
-      fieldStarted = true;
-    }
-  }
-  if (field !== "" || fields.length > 0) {
-    endRecord();
-  }
-  return records;
-}
-function parseCsv(text) {
-  const crlf = (text.match(/\r\n/g) ?? []).length;
-  const bareLf = (text.match(/(?<!\r)\n/g) ?? []).length;
-  const eol = crlf > bareLf ? `\r
-` : `
-`;
-  const trailingNewline = text.endsWith(`
-`);
-  const records = splitRecords(text);
-  const headers = records[0] ?? [];
-  const rows = records.slice(1);
-  const width = Math.max(headers.length, ...rows.map((r) => r.length), 0);
-  while (headers.length < width) {
-    headers.push("");
-  }
-  for (const row of rows) {
-    while (row.length < width) {
-      row.push("");
-    }
-  }
-  return { eol, headers, rows, trailingNewline };
-}
-function encodeField(value) {
-  if (/[",\n\r]/.test(value)) {
-    return `"${value.replaceAll('"', '""')}"`;
-  }
-  return value;
-}
-function serializeCsv(doc) {
-  const lines = [doc.headers, ...doc.rows].map((fields) => fields.map((field) => encodeField(field)).join(","));
-  return lines.join(doc.eol) + (doc.trailingNewline ? doc.eol : "");
-}
-
-// src/grid/schema-columns.ts
-var KIND_WIDTHS = {
-  array: 220,
-  boolean: 70,
-  date: 130,
-  enum: 140,
-  image: 180,
-  number: 110,
-  readonly: 200,
-  reference: 200,
-  string: 180,
-  text: 340
-};
-function clampWidth(maxLen) {
-  return Math.min(340, Math.max(90, Math.round(maxLen * 7.5)));
-}
-function kindForProp(prop) {
-  if (prop.$ref) {
-    return "reference";
-  }
-  if (prop.enum !== undefined && Array.isArray(prop.enum)) {
-    return "enum";
-  }
-  const format = prop.type === "array" ? undefined : prop.format;
-  if (format === "image") {
-    return "image";
-  }
-  if (format === "date" || format === "date-time") {
-    return "date";
-  }
-  switch (prop.type) {
-    case "number":
-    case "integer": {
-      return "number";
-    }
-    case "boolean": {
-      return "boolean";
-    }
-    case "array": {
-      return "array";
-    }
-    case "object": {
-      return "readonly";
-    }
-    default: {
-      return (prop.maxLength ?? 0) > 200 || prop.format === "markdown" ? "text" : "string";
-    }
-  }
-}
-function titleForField(field) {
-  const spaced = field.replaceAll(/([a-z0-9])([A-Z])/g, "$1 $2").replaceAll(/[_-]+/g, " ").trim();
-  return spaced.charAt(0).toUpperCase() + spaced.slice(1);
-}
-function columnsFromSchema(schema, opts = {}) {
-  const props = Object.entries(schema?.properties ?? {});
-  const required = new Set(schema?.required);
-  const readonly = new Set(opts.readonlyFields);
-  const columns = props.map(([field, prop]) => {
-    const kind = readonly.has(field) ? "readonly" : kindForProp(prop);
-    const enumLen = Array.isArray(prop.enum) ? Math.max(...prop.enum.map((v) => String(v).length), 4) : 0;
-    return {
-      editable: kind !== "readonly",
-      field,
-      kind,
-      pk: field === opts.idField,
-      required: required.has(field),
-      schema: prop,
-      title: titleForField(field),
-      widthHint: kind === "enum" ? clampWidth(enumLen + 3) : KIND_WIDTHS[kind]
-    };
-  });
-  columns.sort((a, b) => {
-    const rank = (c) => c.pk ? 0 : c.required ? 1 : 2;
-    const diff = rank(a) - rank(b);
-    return diff === 0 ? 0 : diff;
-  });
-  return columns;
-}
-function inferColumnsFromRows(rows, sampleLimit = 50) {
-  const sample = rows.slice(0, sampleLimit);
-  const fields = [];
-  for (const row of sample) {
-    for (const key of Object.keys(row)) {
-      if (!fields.includes(key)) {
-        fields.push(key);
-      }
-    }
-  }
-  return fields.map((field) => {
-    const values = sample.map((row) => row[field]).filter((v) => v !== null && v !== undefined && v !== "");
-    const kind = inferKind(values);
-    const maxLen = Math.max(...values.map((v) => cellToText(v).length), field.length, 4);
-    return {
-      editable: true,
-      field,
-      kind,
-      title: titleForField(field),
-      widthHint: kind === "string" || kind === "text" ? clampWidth(maxLen) : KIND_WIDTHS[kind]
-    };
-  });
-}
-function inferKind(values) {
-  if (values.length === 0) {
-    return "string";
-  }
-  if (values.some((v) => Array.isArray(v))) {
-    return "array";
-  }
-  const texts = values.map(String);
-  if (values.every((v) => typeof v === "boolean") || texts.every((t) => /^(true|false)$/i.test(t))) {
-    return "boolean";
-  }
-  if (values.every((v) => typeof v === "number") || texts.every((t) => t.trim() !== "" && !Number.isNaN(Number(t.replaceAll(/[$€£¥,\s]/g, ""))))) {
-    return "number";
-  }
-  if (texts.every((t) => /^\d{4}-\d{2}-\d{2}([T ].*)?$/.test(t))) {
-    return "date";
-  }
-  if (texts.some((t) => t.length > 200)) {
-    return "text";
-  }
-  return "string";
-}
-function coerceCellInput(raw, col) {
-  if (raw === null || raw === undefined) {
-    return null;
-  }
-  switch (col.kind) {
-    case "number": {
-      if (typeof raw === "number") {
-        return Number.isNaN(raw) ? null : raw;
-      }
-      const cleaned = String(raw).trim().replaceAll(/[$€£¥,\s]/g, "");
-      if (cleaned === "") {
-        return null;
-      }
-      const n = Number(cleaned);
-      return Number.isNaN(n) ? null : n;
-    }
-    case "boolean": {
-      if (typeof raw === "boolean") {
-        return raw;
-      }
-      return String(raw).trim().toLowerCase() === "true";
-    }
-    case "array": {
-      if (Array.isArray(raw)) {
-        return raw.map(String);
-      }
-      const text = String(raw).trim();
-      return text === "" ? [] : text.split(",").map((s) => s.trim()).filter(Boolean);
-    }
-    case "reference": {
-      if (typeof raw === "object" && raw !== null && "$ref" in raw) {
-        const ref2 = raw.$ref;
-        return typeof ref2 === "string" && ref2 !== "" ? ref2 : null;
-      }
-      const text = String(raw).trim();
-      return text === "" ? null : text;
-    }
-    default: {
-      const text = String(raw);
-      return text === "" ? null : text;
-    }
-  }
-}
-function cellToText(value) {
-  if (value === null || value === undefined) {
-    return "";
-  }
-  if (Array.isArray(value)) {
-    return value.join(", ");
-  }
-  if (typeof value === "object") {
-    return value.$ref;
-  }
-  return String(value);
-}
-
-// src/grid/sources/csv-file-source.ts
-var ID_FIELDS = ["id", "sku", "slug", "Slug"];
-function fieldNamesForHeaders(headers) {
-  const used = new Set;
-  return headers.map((header, i) => {
-    let name = header.trim() === "" ? `column${i + 1}` : header;
-    if (used.has(name)) {
-      name = `${name}__${i + 1}`;
-    }
-    used.add(name);
-    return name;
-  });
-}
-function pickIdField(fields, doc) {
-  for (const candidate of ID_FIELDS) {
-    const idx = fields.indexOf(candidate);
-    if (idx === -1) {
-      continue;
-    }
-    const values = doc.rows.map((row) => row[idx] ?? "");
-    if (values.every((v) => v !== "") && new Set(values).size === values.length) {
-      return candidate;
-    }
-  }
-  return null;
-}
-function buildModel(text, path) {
-  const doc = parseCsv(text);
-  const fields = fieldNamesForHeaders(doc.headers);
-  const idField = pickIdField(fields, doc);
-  const idIndex = idField ? fields.indexOf(idField) : -1;
-  const keys = doc.rows.map((row, i) => idIndex === -1 ? String(i) : row[idIndex]);
-  const keyToIndex = new Map(keys.map((key, i) => [key, i]));
-  const contentType = findContentTypeSchema(path, projectState?.projectConfig);
-  const schemaProps = contentType?.schema?.properties ?? {};
-  const sampleRows = doc.rows.slice(0, 50).map((row) => {
-    const cells = {};
-    for (const [i, field] of fields.entries()) {
-      cells[field] = row[i] ?? "";
-    }
-    return cells;
-  });
-  const inferred = new Map(inferColumnsFromRows(sampleRows).map((c) => [c.field, c]));
-  const typed = new Map(columnsFromSchema(contentType?.schema, { idField: idField ?? undefined }).map((c) => [
-    c.field,
-    c
-  ]));
-  const columns = fields.map((field, i) => {
-    const fromSchema = field in schemaProps ? typed.get(field) : undefined;
-    const column = fromSchema ?? inferred.get(field) ?? {
-      editable: true,
-      field,
-      kind: "string",
-      title: doc.headers[i] || field
-    };
-    return { ...column, pk: field === idField, title: doc.headers[i]?.trim() || column.title };
-  });
-  return { columns, doc, fields, keys, keyToIndex, loadText: text };
-}
-function rowCells(model, rowIndex) {
-  const cells = {};
-  const row = model.doc.rows[rowIndex] ?? [];
-  for (const [i, field] of model.fields.entries()) {
-    const column = model.columns[i];
-    const raw = row[i] ?? "";
-    cells[field] = column.kind === "string" || column.kind === "text" || column.kind === "readonly" ? raw : coerceCellInput(raw, column);
-  }
-  return cells;
-}
-function applyBatch(model, batch) {
-  const rows = model.doc.rows.map((row) => [...row]);
-  const colFor = (field) => model.fields.indexOf(field);
-  for (const cell of batch.cells) {
-    const rowIndex = model.keyToIndex.get(cell.rowKey);
-    const colIndex = colFor(cell.field);
-    if (rowIndex === undefined || colIndex === -1) {
-      continue;
-    }
-    rows[rowIndex][colIndex] = cellToText(cell.value);
-  }
-  for (const insert of batch.inserts) {
-    const row = model.fields.map((field) => cellToText(insert.cells[field] ?? null));
-    rows.push(row);
-  }
-  const dropIndexes = batch.deletes.map((del) => model.keyToIndex.get(del.rowKey)).filter((i) => i !== undefined).toSorted((a, b) => b - a);
-  for (const index of dropIndexes) {
-    rows.splice(index, 1);
-  }
-  return { ...model.doc, rows };
-}
-function uniformResult(batch, outcome) {
-  return {
-    cells: batch.cells.map((c) => ({ field: c.field, rowKey: c.rowKey, ...outcome })),
-    deletes: batch.deletes.map((d) => ({ rowKey: d.rowKey, ...outcome })),
-    inserts: batch.inserts.map((i) => ({
-      error: outcome.error,
-      ok: outcome.ok,
-      tempKey: i.tempKey
-    }))
-  };
-}
-function createCsvFileSource(path) {
-  let loadPromise = null;
-  const load = (force = false) => {
-    if (!force && loadPromise) {
-      return loadPromise;
-    }
-    loadPromise = getPlatform().readFile(path).then((text) => buildModel(text, path));
-    return loadPromise;
-  };
-  return {
-    backingPaths: () => new Map([[path, "*"]]),
-    capabilities: { delete: true, insert: true, remotePaging: false, remoteSort: false },
-    async columns() {
-      const current = await load();
-      return current.columns;
-    },
-    async commit(batch) {
-      const current = await load();
-      const platform = getPlatform();
-      let onDisk = null;
-      try {
-        onDisk = await platform.readFile(path);
-      } catch {
-        onDisk = null;
-      }
-      if (onDisk !== current.loadText && !isRecentLocal(path)) {
-        return uniformResult(batch, {
-          error: "File changed on disk — refresh to reload",
-          ok: false,
-          stale: true
-        });
-      }
-      const nextDoc = applyBatch(current, batch);
-      const text = serializeCsv(nextDoc);
-      markLocalMutation(path);
-      await platform.writeFile(path, text);
-      loadPromise = Promise.resolve(buildModel(text, path));
-      return uniformResult(batch, { ok: true });
-    },
-    id: path,
-    label: path.split("/").pop() ?? path,
-    async refresh() {
-      await load(true);
-    },
-    async rows() {
-      const current = await load();
-      const rows = current.doc.rows.map((_, i) => ({
-        cells: rowCells(current, i),
-        key: current.keys[i]
-      }));
-      return { rows, total: rows.length };
-    },
-    async serializeForSource(batch) {
-      const current = await load();
-      return serializeCsv(applyBatch(current, batch));
-    }
-  };
-}
-
-// src/files/file-ops.ts
-async function parseFormatSource(format, source) {
-  const doc = await formatParse(format.name, source);
-  return splitFormatDocument(format, doc);
-}
-async function parseSourceForPath(path, source) {
-  await loadFormats();
-  const format = formatForPath(path);
-  if (!format || !format.capabilities.parse) {
-    throw noFormatError(path);
-  }
-  const result = await parseFormatSource(format, source);
-  return { ...result, format };
-}
-function savedMessage(tab, savedMsg) {
-  const doc = tab.doc.document;
-  const warning = typeof doc.tagName === "string" && doc.tagName.includes("-") ? validateComponentSlots(doc) : null;
-  if (warning) {
-    statusMessage(`${savedMsg} — Warning: ${warning}`, 6000);
-  } else {
-    statusMessage(savedMsg);
-  }
-}
-async function saveFile() {
-  const tab = activeTab.value;
-  if (!tab) {
-    return;
-  }
-  await flushCanvasEdits(tab.id);
-  const grid = getGridController(tab);
-  if (grid) {
-    await grid.save();
-    return;
-  }
-  try {
-    if (await collabSave(tab)) {
-      savedMessage(tab, "Synced");
-      return;
-    }
-    const output = await serializeDocument(tab);
-    if (tab.documentPath) {
-      const platform = getPlatform();
-      await platform.writeFile(tab.documentPath, output);
-      tab.doc.dirty = false;
-      savedMessage(tab, "Saved");
-    } else if (tab.fileHandle && "createWritable" in tab.fileHandle) {
-      const writable = await tab.fileHandle.createWritable();
-      await writable.write(output);
-      await writable.close();
-      tab.doc.dirty = false;
-      savedMessage(tab, "Saved");
-    } else {
-      statusMessage("No save target — use Export");
-    }
-  } catch (error) {
-    if (!(error instanceof Error && error.name === "AbortError")) {
-      statusMessage(`Save error: ${errorMessage(error)}`);
-    }
-  }
-}
-function tabFormat(tab) {
-  return formatByName(tab.doc.sourceFormat) ?? (tab.doc.mode === "content" ? defaultContentFormat() : undefined);
-}
-async function exportFile() {
-  const tab = activeTab.value;
-  if (!tab) {
-    return;
-  }
-  try {
-    await loadFormats();
-    const format = tabFormat(tab);
-    const output = await serializeDocument(tab);
-    const mimeType = format ? format.mediaType ?? "text/plain" : "application/json";
-    const ext = format ? format.extensions[0] : ".json";
-    const description = format ? format.name : "Jx Component";
-    const fallbackName = format ? `content${ext}` : "component.json";
-    if ("showSaveFilePicker" in window) {
-      const suggestedName = tab.documentPath ? tab.documentPath.split("/").pop() : fallbackName;
-      const handle = await window.showSaveFilePicker({
-        suggestedName,
-        types: [{ accept: { [mimeType]: [ext] }, description }]
-      });
-      const writable = await handle.createWritable();
-      await writable.write(output);
-      await writable.close();
-      tab.doc.dirty = false;
-      savedMessage(tab, `Exported as ${handle.name}`);
-    } else {
-      const blob = new Blob([output], { type: mimeType });
-      const url = URL.createObjectURL(blob);
-      const a = document.createElement("a");
-      a.href = url;
-      a.download = fallbackName;
-      a.click();
-      URL.revokeObjectURL(url);
-      tab.doc.dirty = false;
-      savedMessage(tab, "Downloaded");
-    }
-  } catch (error) {
-    if (!(error instanceof Error && error.name === "AbortError")) {
-      statusMessage(`Export error: ${errorMessage(error)}`);
-    }
-  }
-}
-async function serializeDocument(tab) {
-  const grid = getGridController(tab);
-  const gridText = grid?.serializeForSource();
-  if (gridText) {
-    return gridText;
-  }
-  await loadFormats();
-  const sourceFormat = formatByName(tab.doc.sourceFormat);
-  if (sourceFormat?.capabilities.serialize) {
-    const fm = tab.doc.content?.frontmatter || {};
-    const doc = tab.doc.document;
-    const fullDoc = { ...fm, ...doc, children: doc.children ?? [] };
-    return formatSerialize(sourceFormat.name, fullDoc, { mode: "roundtrip" });
-  }
-  if (tab.doc.mode === "content") {
-    const format = defaultContentFormat();
-    if (format) {
-      const fm = tab.doc.content?.frontmatter ?? {};
-      const hasFrontmatter = Object.keys(fm).length > 0;
-      const fullDoc = { ...fm, ...tab.doc.document };
-      return formatSerialize(format.name, fullDoc, {
-        frontmatter: hasFrontmatter,
-        mode: "roundtrip"
-      });
-    }
-  }
-  return JSON.stringify(tab.doc.document, null, 2);
-}
-
-// src/grid/sources/content-source.ts
-var PATH_FIELD = "__path";
-function collectionInfo(typeName) {
-  const content = projectState?.projectConfig?.content ?? {};
-  const def = content[typeName];
-  if (!def?.source) {
-    return null;
-  }
-  const dir = def.source.replace(/^\.\//, "").replace(/\/$/, "");
-  const ext = def.format === "json" ? ".json" : formatByName(def.format)?.extensions[0] ?? defaultContentFormat()?.extensions[0] ?? ".json";
-  return { def, dir, ext, name: typeName };
-}
-function collectionDirs() {
-  const content = projectState?.projectConfig?.content ?? {};
-  return Object.entries(content).filter(([, def]) => {
-    const source = def.source?.replace(/^\.\//, "") ?? "";
-    return source !== "" && !/\.[a-z0-9]+$/i.test(source);
-  }).map(([name, def]) => ({ dir: def.source.replace(/^\.\//, "").replace(/\/$/, ""), name }));
-}
-async function listEntryFiles(dir, exts) {
-  const platform = getPlatform();
-  const results = [];
-  const walk = async (current) => {
-    let children;
-    try {
-      children = await platform.listDirectory(current);
-    } catch {
-      return;
-    }
-    for (const entry of children) {
-      if (entry.type === "directory") {
-        await walk(entry.path);
-      } else if (exts.some((ext) => entry.path.endsWith(ext))) {
-        results.push(entry.path);
-      }
-    }
-  };
-  await walk(dir);
-  return results.toSorted();
-}
-async function listCollectionEntryIds(typeName) {
-  await loadFormats().catch(() => {});
-  const info = collectionInfo(typeName);
-  if (!info) {
-    return [];
-  }
-  const files = await listEntryFiles(info.dir, [info.ext]);
-  return files.map((path) => {
-    const base = path.split("/").pop() ?? path;
-    return base.slice(0, base.length - info.ext.length);
-  });
-}
-async function mapLimit(items, limit, fn) {
-  const results = Array.from({ length: items.length });
-  let next = 0;
-  const workers = Array.from({ length: Math.min(limit, items.length) }, async () => {
-    while (next < items.length) {
-      const index = next;
-      next += 1;
-      results[index] = await fn(items[index]);
-    }
-  });
-  await Promise.all(workers);
-  return results;
-}
-function toCellValue(value) {
-  if (value === null || value === undefined) {
-    return null;
-  }
-  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-    return value;
-  }
-  if (Array.isArray(value) && value.every((v) => typeof v !== "object" || v === null)) {
-    return value.map(String);
-  }
-  return JSON.stringify(value);
-}
-function openTabFor(path) {
-  for (const tab of workspace.tabs.values()) {
-    if (tab.documentPath === path) {
-      return tab;
-    }
-  }
-  return null;
-}
-function extraRowsAreStrings(rows, field) {
-  return rows.every((row) => {
-    const value = row[field];
-    return value === null || value === undefined || typeof value !== "string" ? true : !value.startsWith("{") && !value.startsWith("[");
-  });
-}
-function createEntryFileSource(opts) {
-  const entries = new Map;
-  let loadPromise = null;
-  let columnsCache = null;
-  const load = (force = false) => {
-    if (!force && loadPromise) {
-      return loadPromise;
-    }
-    loadPromise = (async () => {
-      await loadFormats().catch(() => {});
-      const platform = getPlatform();
-      const files = await opts.list();
-      entries.clear();
-      columnsCache = null;
-      await mapLimit(files, 8, async (path) => {
-        try {
-          const text = await platform.readFile(path);
-          const parsed = await parseSourceForPath(path, text);
-          entries.set(path, {
-            document: parsed.document,
-            formatName: parsed.format.name,
-            frontmatter: parsed.frontmatter ?? {},
-            rawText: text
-          });
-        } catch {}
-      });
-    })();
-    return loadPromise;
-  };
-  const buildColumns = () => {
-    if (columnsCache) {
-      return columnsCache;
-    }
-    const pathColumn = {
-      editable: false,
-      field: PATH_FIELD,
-      insertOnly: true,
-      kind: "string",
-      pk: true,
-      required: true,
-      title: "Path",
-      widthHint: 220
-    };
-    const schemaColumns = columnsFromSchema(opts.schema());
-    const known = new Set([PATH_FIELD, ...schemaColumns.map((c) => c.field)]);
-    const extraRows = [...entries.values()].map((entry) => {
-      const cells = {};
-      for (const [key, value] of Object.entries(entry.frontmatter)) {
-        if (!known.has(key) && !key.startsWith("$")) {
-          cells[key] = toCellValue(value);
-        }
-      }
-      return cells;
-    });
-    const extraColumns = inferColumnsFromRows(extraRows);
-    for (const column of extraColumns) {
-      column.editable = column.kind !== "text" || extraRowsAreStrings(extraRows, column.field);
-    }
-    if (opts.priorityFields?.length) {
-      const rank = (c) => {
-        const index = opts.priorityFields.indexOf(c.field);
-        return index === -1 ? opts.priorityFields.length : index;
-      };
-      extraColumns.sort((a, b) => rank(a) - rank(b));
-    }
-    columnsCache = [pathColumn, ...schemaColumns, ...extraColumns];
-    return columnsCache;
-  };
-  const rowFor = (path, entry) => {
-    const cells = { [PATH_FIELD]: path };
-    for (const column of buildColumns()) {
-      if (column.field === PATH_FIELD) {
-        continue;
-      }
-      cells[column.field] = toCellValue(entry.frontmatter[column.field]);
-    }
-    return { cells, fingerprint: entry.rawText, key: path };
-  };
-  const writeEntry = async (path, entry, patches) => {
-    const platform = getPlatform();
-    const frontmatter = { ...entry.frontmatter };
-    for (const patch of patches) {
-      if (patch.value === null) {
-        delete frontmatter[patch.field];
-      } else {
-        frontmatter[patch.field] = patch.value;
-      }
-    }
-    const doc = entry.document;
-    const fullDoc = { ...frontmatter, ...doc, children: doc.children ?? [] };
-    const text = await formatSerialize(entry.formatName, fullDoc, { mode: "roundtrip" });
-    markLocalMutation(path);
-    await platform.writeFile(path, text);
-    entries.set(path, { ...entry, frontmatter, rawText: text });
-  };
-  return {
-    backingPaths: () => new Map([...entries.keys()].map((path) => [path, path])),
-    capabilities: { delete: true, insert: true, remotePaging: false, remoteSort: false },
-    async columns() {
-      await load();
-      return buildColumns();
-    },
-    async commit(batch) {
-      await load();
-      const platform = getPlatform();
-      const result = { cells: [], deletes: [], inserts: [] };
-      const byRow = new Map;
-      for (const cell of batch.cells) {
-        const list = byRow.get(cell.rowKey) ?? [];
-        list.push({ field: cell.field, value: cell.value });
-        byRow.set(cell.rowKey, list);
-      }
-      for (const [path, patches] of byRow) {
-        const outcome = (ok, error, stale) => {
-          for (const patch of patches) {
-            result.cells.push({ error, field: patch.field, ok, rowKey: path, stale });
-          }
-        };
-        const entry = entries.get(path);
-        if (!entry) {
-          outcome(false, "Entry no longer loaded — refresh the grid");
-          continue;
-        }
-        const openTab2 = openTabFor(path);
-        if (openTab2?.doc.dirty) {
-          outcome(false, "Open in a tab with unsaved changes — save or close it first");
-          continue;
-        }
-        let onDisk = null;
-        try {
-          onDisk = await platform.readFile(path);
-        } catch {
-          onDisk = null;
-        }
-        if (onDisk !== entry.rawText && !isRecentLocal(path)) {
-          outcome(false, "File changed on disk — refresh to reload", true);
-          continue;
-        }
-        try {
-          await writeEntry(path, entry, patches);
-          outcome(true);
-          if (openTab2) {
-            const { reloadFileInTab } = await import("./files-02zn5y24.js");
-            reloadFileInTab(path);
-          }
-        } catch (error) {
-          outcome(false, error instanceof Error ? error.message : String(error));
-        }
-      }
-      for (const insert of batch.inserts) {
-        const rawPath = insert.cells[PATH_FIELD];
-        if (typeof rawPath !== "string" || rawPath.trim() === "") {
-          result.inserts.push({ error: "Path is required", ok: false, tempKey: insert.tempKey });
-          continue;
-        }
-        const path = opts.resolveInsertPath(rawPath);
-        let exists = entries.has(path);
-        if (!exists) {
-          try {
-            await platform.readFile(path);
-            exists = true;
-          } catch {
-            exists = false;
-          }
-        }
-        if (exists) {
-          result.inserts.push({
-            error: `${path} already exists`,
-            ok: false,
-            tempKey: insert.tempKey
-          });
-          continue;
-        }
-        const formatName = opts.insertFormatName(path);
-        if (!formatName) {
-          result.inserts.push({
-            error: `No format can serialize ${path}`,
-            ok: false,
-            tempKey: insert.tempKey
-          });
-          continue;
-        }
-        try {
-          const frontmatter = {};
-          for (const [field, value] of Object.entries(insert.cells)) {
-            if (field !== PATH_FIELD && value !== null) {
-              frontmatter[field] = value;
-            }
-          }
-          const text = await formatSerialize(formatName, { ...frontmatter, children: [] }, { frontmatter: Object.keys(frontmatter).length > 0, mode: "roundtrip" });
-          markLocalMutation(path);
-          await platform.writeFile(path, text);
-          const parsed = await parseSourceForPath(path, text);
-          entries.set(path, {
-            document: parsed.document,
-            formatName: parsed.format.name,
-            frontmatter: parsed.frontmatter ?? {},
-            rawText: text
-          });
-          result.inserts.push({ newKey: path, ok: true, tempKey: insert.tempKey });
-        } catch (error) {
-          result.inserts.push({
-            error: error instanceof Error ? error.message : String(error),
-            ok: false,
-            tempKey: insert.tempKey
-          });
-        }
-      }
-      for (const del of batch.deletes) {
-        if (openTabFor(del.rowKey)) {
-          result.deletes.push({
-            error: "Open in a tab — close it first",
-            ok: false,
-            rowKey: del.rowKey
-          });
-          continue;
-        }
-        try {
-          markLocalMutation(del.rowKey);
-          await platform.deleteFile(del.rowKey);
-          entries.delete(del.rowKey);
-          result.deletes.push({ ok: true, rowKey: del.rowKey });
-        } catch (error) {
-          result.deletes.push({
-            error: error instanceof Error ? error.message : String(error),
-            ok: false,
-            rowKey: del.rowKey
-          });
-        }
-      }
-      return result;
-    },
-    id: opts.id,
-    label: opts.label,
-    async refresh() {
-      await load(true);
-    },
-    async rows() {
-      await load();
-      const rows = [...entries.entries()].map(([path, entry]) => rowFor(path, entry));
-      return { rows, total: rows.length };
-    }
-  };
-}
-function createCollectionSource(typeName) {
-  const requireInfo = () => {
-    const info = collectionInfo(typeName);
-    if (!info) {
-      throw new Error(`No content collection named "${typeName}" in project.json`);
-    }
-    return info;
-  };
-  return createEntryFileSource({
-    id: makeGridTabId({ kind: "collection", name: typeName }),
-    insertFormatName: (path) => {
-      const info = requireInfo();
-      return (info.def.format ? formatByName(info.def.format)?.name : undefined) ?? formatForPath(path)?.name ?? defaultContentFormat()?.name ?? null;
-    },
-    label: typeName,
-    list: () => {
-      const info = requireInfo();
-      return listEntryFiles(info.dir, [info.ext]);
-    },
-    resolveInsertPath: (raw) => {
-      const info = requireInfo();
-      let path = raw.trim().replace(/^\.\//, "").replace(/^\//, "");
-      if (!path.includes("/")) {
-        path = `${info.dir}/${path}`;
-      }
-      if (!path.endsWith(info.ext)) {
-        path = `${path}${info.ext}`;
-      }
-      return path;
-    },
-    schema: () => requireInfo().def.schema
-  });
-}
-function createPagesSource() {
-  const pageExts = () => {
-    const exts = documentExtensions("page").filter((ext) => ext !== ".json");
-    return exts.length > 0 ? exts : [".md"];
-  };
-  return createEntryFileSource({
-    id: makeGridTabId({ kind: "pages" }),
-    insertFormatName: (path) => formatForPath(path)?.name ?? null,
-    label: "Pages",
-    list: () => listEntryFiles("pages", pageExts()),
-    priorityFields: ["title", "description"],
-    resolveInsertPath: (raw) => {
-      let path = raw.trim().replace(/^\.\//, "").replace(/^\//, "");
-      if (!path.startsWith("pages/")) {
-        path = `pages/${path}`;
-      }
-      if (!pageExts().some((ext) => path.endsWith(ext))) {
-        path = `${path}${pageExts()[0]}`;
-      }
-      return path;
-    },
-    schema: () => null
-  });
-}
-
-// src/grid/sources/connector-source.ts
-var DATA_PAGE_SIZE = 50;
-function kindForSqlType(type) {
-  const t = type.toLowerCase();
-  if (/(int|real|floa|doub|num|dec)/.test(t)) {
-    return "number";
-  }
-  if (t.includes("bool")) {
-    return "boolean";
-  }
-  if (/(timestamp|datetime|date)/.test(t)) {
-    return "date";
-  }
-  return "string";
-}
-function editableColumn(column) {
-  return !column.pk && column.name !== "created_at" && column.name !== "updated_at";
-}
-function toCellValue2(value) {
-  if (value === null || value === undefined) {
-    return null;
-  }
-  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-    return value;
-  }
-  return JSON.stringify(value);
-}
-function createConnectorSource(connection, table) {
-  let columnsMeta = [];
-  let pkName = "id";
-  const pkValues = new Map;
-  const applyMeta = (columns) => {
-    if (columns.length > 0) {
-      columnsMeta = columns;
-      pkName = columns.find((c) => c.pk)?.name ?? "id";
-    }
-  };
-  const toQuery = (query) => ({
-    table,
-    ...connection ? { connection } : {},
-    limit: query?.limit ?? DATA_PAGE_SIZE,
-    offset: query?.offset ?? 0,
-    ...query?.orderBy ? { dir: query.dir ?? "asc", orderBy: query.orderBy } : {}
-  });
-  const rowKeyOf = (row, index) => {
-    const pk = row[pkName];
-    if (typeof pk === "string" || typeof pk === "number") {
-      pkValues.set(String(pk), pk);
-      return String(pk);
-    }
-    return `row-${index}`;
-  };
-  return {
-    capabilities: { delete: true, insert: true, remotePaging: true, remoteSort: true },
-    async columns() {
-      if (columnsMeta.length === 0) {
-        const result = await fetchRows(toQuery({ limit: 1, offset: 0 }));
-        applyMeta(result.columns);
-      }
-      return columnsMeta.map((meta) => {
-        const kind = editableColumn(meta) ? kindForSqlType(meta.type) : "readonly";
-        return {
-          editable: kind !== "readonly",
-          field: meta.name,
-          kind,
-          pk: meta.pk === true,
-          title: meta.name,
-          widthHint: meta.pk ? 80 : undefined
-        };
-      });
-    },
-    async commit(batch) {
-      const result = { cells: [], deletes: [], inserts: [] };
-      const byRow = new Map;
-      for (const cell of batch.cells) {
-        const list = byRow.get(cell.rowKey) ?? [];
-        list.push({ field: cell.field, value: cell.value });
-        byRow.set(cell.rowKey, list);
-      }
-      for (const [rowKey, patches] of byRow) {
-        const pk = pkValues.get(rowKey);
-        const outcome = (ok, error) => {
-          for (const patch of patches) {
-            result.cells.push({ error, field: patch.field, ok, rowKey });
-          }
-        };
-        if (pk === undefined) {
-          outcome(false, "Row has no primary key — refresh the grid");
-          continue;
-        }
-        try {
-          const set = {};
-          for (const patch of patches) {
-            set[patch.field] = patch.value;
-          }
-          await updateRow({ pk, set, table, ...connection ? { connection } : {} });
-          outcome(true);
-        } catch (error) {
-          outcome(false, error instanceof Error ? error.message : String(error));
-        }
-      }
-      for (const insert of batch.inserts) {
-        try {
-          const values = {};
-          for (const [field, value] of Object.entries(insert.cells)) {
-            if (value !== null) {
-              values[field] = value;
-            }
-          }
-          const { row } = await insertRow({ table, values, ...connection ? { connection } : {} });
-          const pk = row[pkName];
-          const newKey = typeof pk === "string" || typeof pk === "number" ? String(pk) : undefined;
-          if (newKey !== undefined && (typeof pk === "string" || typeof pk === "number")) {
-            pkValues.set(newKey, pk);
-          }
-          result.inserts.push({ newKey, ok: true, tempKey: insert.tempKey });
-        } catch (error) {
-          result.inserts.push({
-            error: error instanceof Error ? error.message : String(error),
-            ok: false,
-            tempKey: insert.tempKey
-          });
-        }
-      }
-      for (const del of batch.deletes) {
-        const pk = pkValues.get(del.rowKey);
-        if (pk === undefined) {
-          result.deletes.push({
-            error: "Row has no primary key — refresh the grid",
-            ok: false,
-            rowKey: del.rowKey
-          });
-          continue;
-        }
-        try {
-          await deleteRow({ pk, table, ...connection ? { connection } : {} });
-          result.deletes.push({ ok: true, rowKey: del.rowKey });
-        } catch (error) {
-          result.deletes.push({
-            error: error instanceof Error ? error.message : String(error),
-            ok: false,
-            rowKey: del.rowKey
-          });
-        }
-      }
-      return result;
-    },
-    id: makeGridTabId({ connection: connection ?? "default", kind: "data", table }),
-    label: table,
-    async refresh() {
-      columnsMeta = [];
-      pkValues.clear();
-    },
-    async rows(query) {
-      const result = await fetchRows(toQuery(query));
-      applyMeta(result.columns);
-      const rows = result.rows.map((row, index) => {
-        const key = rowKeyOf(row, index);
-        const cells = {};
-        for (const meta of columnsMeta) {
-          cells[meta.name] = toCellValue2(row[meta.name]);
-        }
-        return { cells, key };
-      });
-      return { rows, total: result.total };
-    }
-  };
-}
-
-// src/grid/grid-open.ts
-var GRID_STUB_DOCUMENT = { children: [], tagName: "div" };
-async function openCsvGridTab(path) {
-  const existing = workspace.tabs.get(path);
-  if (existing) {
-    activateTab(path);
-    return existing;
-  }
-  try {
-    await loadFormats();
-  } catch {}
-  const source = createCsvFileSource(path);
-  const tab = openTab({
-    capabilities: { modes: ["grid", "source"] },
-    document: structuredClone(GRID_STUB_DOCUMENT),
-    documentPath: path,
-    id: path,
-    sourceFormat: formatForPath(path)?.name ?? null
-  });
-  const controller = createGridController(tab, source);
-  controller.load();
-  return tab;
-}
-function openVirtualGridTab(source) {
-  const tab = openTab({
-    capabilities: { modes: ["grid"] },
-    document: structuredClone(GRID_STUB_DOCUMENT),
-    documentPath: null,
-    id: source.id
-  });
-  const controller = createGridController(tab, source);
-  controller.load();
-  return tab;
-}
-function openCollectionGrid(typeName) {
-  const id = makeGridTabId({ kind: "collection", name: typeName });
-  const existing = workspace.tabs.get(id);
-  if (existing) {
-    activateTab(id);
-    return existing;
-  }
-  return openVirtualGridTab(createCollectionSource(typeName));
-}
-function openPagesGrid() {
-  const id = makeGridTabId({ kind: "pages" });
-  const existing = workspace.tabs.get(id);
-  if (existing) {
-    activateTab(id);
-    return existing;
-  }
-  return openVirtualGridTab(createPagesSource());
-}
-function openConnectorGrid(connection, table) {
-  const id = makeGridTabId({ connection: connection ?? "default", kind: "data", table });
-  const existing = workspace.tabs.get(id);
-  if (existing) {
-    activateTab(id);
-    return existing;
-  }
-  return openVirtualGridTab(createConnectorSource(connection, table));
-}
-async function openGridSourcePicker() {
-  const collections = collectionDirs();
-  let connections = [];
-  if (dataSurfaceAvailable()) {
-    const response = await fetchConnections().catch(() => null);
-    connections = response?.connections ?? [];
-  }
-  const handle = openModal(html`<sp-dialog-wrapper
-      open
-      dismissable
-      underlay
-      headline="Open Grid"
-      @close=${() => handle.close()}
-    >
-      <sp-menu class="jx-grid-picker">
-        <sp-menu-group>
-          <span slot="header">Project</span>
-          <sp-menu-item
-            @click=${() => {
-    handle.close();
-    openPagesGrid();
-  }}
-            >Pages</sp-menu-item
-          >
-          ${collections.map(({ name }) => html`<sp-menu-item
-                @click=${() => {
-    handle.close();
-    openCollectionGrid(name);
-  }}
-                >Collection: ${name}</sp-menu-item
-              >`)}
-        </sp-menu-group>
-        ${connections.map((conn) => html`<sp-menu-group>
-              <span slot="header">Data · ${conn.name}</span>
-              ${conn.tables.length === 0 ? html`<sp-menu-item disabled>No tables — push a schema first</sp-menu-item>` : conn.tables.map((table) => html`<sp-menu-item
-                          @click=${() => {
-    handle.close();
-    openConnectorGrid(conn.name, table);
-  }}
-                          >${table}</sp-menu-item
-                        >`)}
-            </sp-menu-group>`)}
-      </sp-menu>
-    </sp-dialog-wrapper>`);
-}
-
-// src/recent-projects.ts
-var STORAGE_KEY = "jx-studio-recent-projects";
-var FILES_STORAGE_KEY = "jx-studio-recent-files";
-var MAX_RECENT = 8;
-var MAX_RECENT_FILES = 10;
-var cache2 = [];
-function backend() {
-  if (!hasPlatform()) {
-    return null;
-  }
-  const platform = getPlatform();
-  return platform.getRecentProjects && platform.saveRecentProjects ? platform : null;
-}
-function loadFromLocalStorage() {
-  try {
-    const raw = localStorage.getItem(STORAGE_KEY);
-    if (!raw) {
-      return [];
-    }
-    const parsed = JSON.parse(raw);
-    return Array.isArray(parsed) ? parsed : [];
-  } catch {
-    return [];
-  }
-}
-function currentList() {
-  return backend() ? cache2 : loadFromLocalStorage();
-}
-function commit(list) {
-  cache2 = list;
-  const store = backend();
-  if (store) {
-    store.saveRecentProjects(list);
-  } else {
-    try {
-      localStorage.setItem(STORAGE_KEY, JSON.stringify(list));
-    } catch {}
-  }
-}
-async function hydrateRecentProjects() {
-  const store = backend();
-  if (!store) {
-    return;
-  }
-  try {
-    cache2 = await store.getRecentProjects();
-  } catch {
-    cache2 = [];
-  }
-}
-function getRecentProjects() {
-  return currentList().toSorted((a, b) => b.timestamp - a.timestamp);
-}
-function addRecentProject(name, root) {
-  const projects = currentList().filter((p) => p.root !== root);
-  projects.unshift({ name, root, timestamp: Date.now() });
-  if (projects.length > MAX_RECENT) {
-    projects.length = MAX_RECENT;
-  }
-  commit(projects);
-}
-function removeRecentProject(root) {
-  commit(currentList().filter((p) => p.root !== root));
-}
-function clearRecentProjects() {
-  cache2 = [];
-  const store = backend();
-  if (store) {
-    store.saveRecentProjects([]);
-  } else {
-    localStorage.removeItem(STORAGE_KEY);
-  }
-}
-function loadRecentFiles() {
-  try {
-    const raw = localStorage.getItem(FILES_STORAGE_KEY);
-    if (!raw) {
-      return [];
-    }
-    const parsed = JSON.parse(raw);
-    return Array.isArray(parsed) ? parsed : [];
-  } catch {
-    return [];
-  }
-}
-function getRecentFiles(root) {
-  const all = loadRecentFiles().toSorted((a, b) => b.timestamp - a.timestamp);
-  return root == null ? all : all.filter((f) => f.root === root);
-}
-function trackRecentFile(file) {
-  const all = loadRecentFiles().filter((f) => !(f.root === file.root && f.path === file.path));
-  all.unshift({ name: file.name, path: file.path, root: file.root, timestamp: Date.now() });
-  const perRoot = new Map;
-  const kept = [];
-  for (const f of all.toSorted((a, b) => b.timestamp - a.timestamp)) {
-    const n = (perRoot.get(f.root) ?? 0) + 1;
-    perRoot.set(f.root, n);
-    if (n <= MAX_RECENT_FILES) {
-      kept.push(f);
-    }
-  }
-  localStorage.setItem(FILES_STORAGE_KEY, JSON.stringify(kept));
-}
-
-// src/files/files.ts
-var fileIconMap = {
-  "sp-icon-document": html`<sp-icon-document></sp-icon-document>`,
-  "sp-icon-file-code": html`<sp-icon-file-code></sp-icon-file-code>`,
-  "sp-icon-file-txt": html`<sp-icon-file-txt></sp-icon-file-txt>`,
-  "sp-icon-folder": html`<sp-icon-folder></sp-icon-folder>`,
-  "sp-icon-folder-open": html`<sp-icon-folder-open></sp-icon-folder-open>`,
-  "sp-icon-image": html`<sp-icon-image></sp-icon-image>`
-};
-async function loadDirectory(dirPath) {
-  if (!projectState) {
-    return;
-  }
-  try {
-    const platform = getPlatform();
-    const entries = await platform.listDirectory(dirPath);
-    projectState.dirs.set(dirPath, entries);
-  } catch {
-    projectState.dirs.set(dirPath, []);
-  }
-}
-async function loadProject() {
-  try {
-    const platform = getPlatform();
-    const result = await platform.probeRootProject();
-    if (!result) {
-      return;
-    }
-    const { meta, info } = result;
-    refreshFormats();
-    loadFormats();
-    refreshExtensionUi(platform);
-    setProjectState({
-      dirs: new Map,
-      expanded: new Set,
-      isSiteProject: info.isSiteProject,
-      name: info.isSiteProject ? info.projectConfig?.name || meta.name : meta.name,
-      projectConfig: (info.isSiteProject ? info.projectConfig : null) || null,
-      projectDirs: info.directories || [],
-      projectRoot: ".",
-      root: meta.root,
-      searchQuery: "",
-      selectedPath: null
-    });
-    if (info.isSiteProject) {
-      setWorkspaceProject(meta.root || ".", info.projectConfig || null);
-    }
-    if (info.isSiteProject) {
-      addRecentProject(requireProjectState().name, meta.root);
-      await autoSyncProjectOnOpen();
-      await ensureDependenciesInstalled();
-      await loadDirectory(".");
-      await loadComponentRegistry();
-      await openHomePage();
-      maybePromptJxsuiteUpdate(meta.root);
-    }
-  } catch {}
-}
-async function openProject({
-  renderActivityBar,
-  renderLeftPanel
-}) {
-  try {
-    const platform = getPlatform();
-    const result = await platform.openProject();
-    if (!result) {
-      return;
-    }
-    const { config, handle } = result;
-    replaceAllTabs({
-      document: { children: [], tagName: "div" },
-      id: "initial"
-    });
-    refreshFormats();
-    loadFormats();
-    refreshExtensionUi(platform);
-    setProjectState({
-      ...projectState,
-      dirs: new Map,
-      expanded: new Set,
-      isSiteProject: true,
-      name: config.name || handle.name,
-      projectConfig: config,
-      projectRoot: handle.root,
-      searchQuery: "",
-      selectedPath: null
-    });
-    setWorkspaceProject(handle.root, config);
-    await autoSyncProjectOnOpen();
-    await ensureDependenciesInstalled();
-    await loadDirectory(".");
-    await loadComponentRegistry();
-    const conventionalDirs = new Set([
-      "pages",
-      "layouts",
-      "components",
-      "content",
-      "data",
-      "public",
-      "styles"
-    ]);
-    const entries = requireProjectState().dirs.get(".") || [];
-    const foundDirs = [];
-    for (const e of entries) {
-      if (e.type === "directory" && conventionalDirs.has(e.name)) {
-        foundDirs.push(e.name);
-        requireProjectState().expanded.add(e.path || e.name);
-        await loadDirectory(e.path || e.name);
-      }
-    }
-    requireProjectState().projectDirs = foundDirs;
-    view.leftTab = "files";
-    addRecentProject(requireProjectState().name, requireProjectState().projectRoot);
-    renderActivityBar();
-    renderLeftPanel();
-    statusMessage(`Opened project: ${requireProjectState().name}`);
-    await openHomePage();
-    maybePromptJxsuiteUpdate(requireProjectState().projectRoot);
-  } catch (error) {
-    statusMessage(`Error: ${errorMessage(error)}`);
-  }
-}
-async function findHomePage() {
-  await loadFormats();
-  const exts = [...documentExtensions("page"), ".json"];
-  let entries;
-  try {
-    entries = await getPlatform().listDirectory("pages");
-  } catch {
-    return null;
-  }
-  const files = new Set(entries.filter((e) => e.type === "file").map((e) => e.name));
-  for (const ext of exts) {
-    if (files.has(`index${ext}`)) {
-      return `pages/index${ext}`;
-    }
-  }
-  return null;
-}
-async function openHomePage() {
-  const home = await findHomePage();
-  if (home) {
-    await openFileInTab(home);
-  }
-}
-function fileTypeIconTpl(name, type) {
-  let tag;
-  if (type === "directory") {
-    tag = projectState?.expanded?.has(name) ? "sp-icon-folder-open" : "sp-icon-folder";
-  } else {
-    const ext = name.split(".").pop()?.toLowerCase();
-    switch (ext) {
-      case "json": {
-        tag = "sp-icon-file-code";
-        break;
-      }
-      case "md": {
-        tag = "sp-icon-file-txt";
-        break;
-      }
-      case "js":
-      case "ts": {
-        tag = "sp-icon-file-code";
-        break;
-      }
-      case "css": {
-        tag = "sp-icon-file-code";
-        break;
-      }
-      default: {
-        tag = ext && isImage(ext) ? "sp-icon-image" : "sp-icon-document";
-        break;
-      }
-    }
-  }
-  return fileIconMap[tag] || fileIconMap["sp-icon-document"];
-}
-function renderFilesTemplate({
-  openProject: openProjectFn,
-  openFileFromTree: openFileFn,
-  renderLeftPanel
-}) {
-  if (!projectState) {
-    return html`<div class="file-tree-empty">No project loaded</div>`;
-  }
-  if (!projectState.isSiteProject && projectState.projectRoot === ".") {
-    return html`<div class="file-tree-empty">
-      <p style="margin:0 0 12px">Open a project folder to get started.</p>
-      <sp-button variant="accent" size="s" @click=${openProjectFn}>Open Project</sp-button>
-    </div>`;
-  }
-  return html`
-    ${projectState.isSiteProject ? html`
-            <div class="project-header">
-              <span class="project-name"
-                >${projectState.projectConfig?.name || projectState.name}</span
-              >
-            </div>
-          ` : nothing}
-    <div class="files-toolbar">
-      <sp-action-group size="xs" compact quiet>
-        <sp-action-button
-          size="xs"
-          label="New File"
-          @click=${() => createNewFile(".", renderLeftPanel)}
-        >
-          <sp-icon-add slot="icon"></sp-icon-add>
-        </sp-action-button>
-        <sp-action-button
-          size="xs"
-          label="Refresh"
-          @click=${async () => {
-    requireProjectState().dirs.clear();
-    await loadDirectory(".");
-    for (const dir of requireProjectState().expanded) {
-      await loadDirectory(dir);
-    }
-    renderLeftPanel();
-  }}
-        >
-          <sp-icon-refresh slot="icon"></sp-icon-refresh>
-        </sp-action-button>
-      </sp-action-group>
-      <sp-search
-        size="s"
-        quiet
-        placeholder="Filter files…"
-        value=${requireProjectState().searchQuery}
-        @input=${(e) => {
-    requireProjectState().searchQuery = e.target.value;
-    renderLeftPanel();
-  }}
-        @submit=${(e) => e.preventDefault()}
-      ></sp-search>
-    </div>
-    <div class="file-tree" role="tree" aria-label="Project files">
-      ${renderTreeLevelTemplate(".", 0, { openFileFn, renderLeftPanel })}
-    </div>
-  `;
-}
-function renderTreeLevelTemplate(dirPath, depth, ctx) {
-  const entries = requireProjectState().dirs.get(dirPath);
-  if (!entries) {
-    loadDirectory(dirPath).then(() => ctx.renderLeftPanel());
-    return html`<div
-      class="file-tree-item"
-      style="padding-left:${8 + depth * 16}px;color:var(--fg-dim);font-style:italic"
-    >
-      Loading…
-    </div>`;
-  }
-  const sorted = [...entries].toSorted((a, b) => {
-    if (a.type === "directory" && b.type !== "directory") {
-      return -1;
-    }
-    if (a.type !== "directory" && b.type === "directory") {
-      return 1;
-    }
-    return a.name.localeCompare(b.name);
-  });
-  const query = requireProjectState().searchQuery.toLowerCase();
-  const filtered = query ? sorted.filter((e) => e.type === "directory" || e.name.toLowerCase().includes(query)) : sorted;
-  return filtered.map((entry) => {
-    const isDir = entry.type === "directory";
-    const isExpanded = requireProjectState().expanded.has(entry.path);
-    const isSelected = requireProjectState().selectedPath === entry.path;
-    return html`
-      <div
-        class=${classMap({ "file-tree-item": true, selected: isSelected })}
-        style="padding-left:${8 + depth * 16}px"
-        role="treeitem"
-        aria-level=${depth + 1}
-        tabindex="-1"
-        data-path=${entry.path}
-        data-type=${entry.type}
-        aria-expanded=${isDir ? String(isExpanded) : nothing}
-        @click=${async (e) => {
-      e.stopPropagation();
-      if (isDir) {
-        if (isExpanded) {
-          requireProjectState().expanded.delete(entry.path);
-        } else {
-          requireProjectState().expanded.add(entry.path);
-          if (!requireProjectState().dirs.has(entry.path)) {
-            await loadDirectory(entry.path);
-          }
-        }
-        ctx.renderLeftPanel();
-      } else {
-        ctx.openFileFn(entry.path);
-      }
-    }}
-        @contextmenu=${(e) => {
-      e.preventDefault();
-      e.stopPropagation();
-      showFileContextMenu(e, entry, ctx);
-    }}
-      >
-        ${isDir ? html`<span class="file-tree-toggle">${isExpanded ? "▼" : "▶"}</span>` : html`<span class="file-tree-toggle empty"> </span>`}
-        <span class="file-tree-icon">${fileTypeIconTpl(entry.path, entry.type)}</span>
-        <span class="file-tree-name">${entry.name}</span>
-      </div>
-      ${isDir && isExpanded ? html`<div role="group">${renderTreeLevelTemplate(entry.path, depth + 1, ctx)}</div>` : nothing}
-    `;
-  });
-}
-function setupTreeKeyboard(tree) {
-  tree.addEventListener("keydown", (e) => {
-    const items = [...tree.querySelectorAll(".file-tree-item")];
-    const focused = tree.querySelector(".file-tree-item:focus");
-    if (!focused || items.length === 0) {
-      return;
-    }
-    const idx = items.indexOf(focused);
-    let handled = true;
-    switch (e.key) {
-      case "ArrowDown": {
-        if (idx < items.length - 1) {
-          items[idx + 1].focus();
-        }
-        break;
-      }
-      case "ArrowUp": {
-        if (idx > 0) {
-          items[idx - 1].focus();
-        }
-        break;
-      }
-      case "ArrowRight": {
-        if (focused.dataset.type === "directory") {
-          const path = focused.dataset.path;
-          if (!requireProjectState().expanded.has(path)) {
-            requireProjectState().expanded.add(path);
-            loadDirectory(path).then(() => {
-              const panel = tree.closest(".panel-body");
-              if (panel) {
-                panel.querySelector(".file-tree-item:focus")?.click();
-              }
-            });
-          }
-        }
-        break;
-      }
-      case "ArrowLeft": {
-        if (focused.dataset.type === "directory") {
-          const path = focused.dataset.path;
-          if (requireProjectState().expanded.has(path)) {
-            requireProjectState().expanded.delete(path);
-          }
-        }
-        break;
-      }
-      case "Enter": {
-        focused.click();
-        break;
-      }
-      default: {
-        handled = false;
-      }
-    }
-    if (handled) {
-      e.preventDefault();
-    }
-  });
-  const first = tree.querySelector(".file-tree-item");
-  if (first) {
-    first.setAttribute("tabindex", "0");
-  }
-}
-var _fileTreeDndCleanups = [];
-function isFileDrag(e) {
-  return [...e.dataTransfer?.types ?? []].includes("Files");
-}
-function registerFileDropTarget(element, dir, activeClass, renderLeftPanel) {
-  const onDragOver = (e) => {
-    if (!isFileDrag(e)) {
-      return;
-    }
-    e.preventDefault();
-    e.stopPropagation();
-    if (e.dataTransfer) {
-      e.dataTransfer.dropEffect = "copy";
-    }
-    element.classList.add(activeClass);
-  };
-  const onDragLeave = () => element.classList.remove(activeClass);
-  const onDrop = (e) => {
-    element.classList.remove(activeClass);
-    const files = e.dataTransfer?.files;
-    if (!files?.length) {
-      return;
-    }
-    e.preventDefault();
-    e.stopPropagation();
-    uploadFilesToDir(files, dir, renderLeftPanel);
-  };
-  element.addEventListener("dragover", onDragOver);
-  element.addEventListener("dragleave", onDragLeave);
-  element.addEventListener("drop", onDrop);
-  return () => {
-    element.removeEventListener("dragover", onDragOver);
-    element.removeEventListener("dragleave", onDragLeave);
-    element.removeEventListener("drop", onDrop);
-  };
-}
-async function uploadFilesToDir(files, dir, renderLeftPanel) {
-  const uploaded = await uploadAssets([...files], { dir });
-  if (uploaded.length === 0) {
-    return;
-  }
-  if (dir !== ".") {
-    requireProjectState().expanded.add(dir);
-  }
-  renderLeftPanel();
-}
-function pickAndUploadTo(dir, renderLeftPanel) {
-  const input = document.createElement("input");
-  input.type = "file";
-  input.multiple = true;
-  input.accept = UPLOAD_ACCEPT;
-  input.addEventListener("change", () => {
-    if (input.files?.length) {
-      uploadFilesToDir(input.files, dir, renderLeftPanel);
-    }
-  });
-  input.click();
-}
-function registerFileTreeDnD({ renderLeftPanel }) {
-  for (const fn of _fileTreeDndCleanups) {
-    fn();
-  }
-  _fileTreeDndCleanups = [];
-  requestAnimationFrame(() => {
-    const tree = document.querySelector(".file-tree");
-    if (!tree) {
-      return;
-    }
-    const items = tree.querySelectorAll(".file-tree-item");
-    for (const row of items) {
-      const { path } = row.dataset;
-      const { type } = row.dataset;
-      if (!path) {
-        continue;
-      }
-      const cleanups = [
-        draggable({
-          element: row,
-          getInitialData() {
-            return { entryType: type, path, type: "file-tree" };
-          },
-          onDragStart() {
-            row.classList.add("dragging");
-          },
-          onDrop() {
-            row.classList.remove("dragging");
-          }
-        }),
-        registerFileDropTarget(row, type === "directory" ? path : parentDir2(path), "drag-over", renderLeftPanel)
-      ];
-      if (type === "directory") {
-        cleanups.push(dropTargetForElements({
-          canDrop({ source }) {
-            if (source.data.type !== "file-tree") {
-              return false;
-            }
-            const srcPath = source.data.path;
-            if (srcPath === path) {
-              return false;
-            }
-            if (srcPath.startsWith(`${path}/`)) {
-              return false;
-            }
-            const srcParent = parentDir2(srcPath);
-            if (srcParent === path) {
-              return false;
-            }
-            return true;
-          },
-          element: row,
-          getData() {
-            return { targetDir: path, type: "file-tree-target" };
-          },
-          onDrag() {
-            if (!row.classList.contains("drag-over")) {
-              row.classList.add("drag-over");
-            }
-          },
-          onDragEnter() {
-            row.classList.add("drag-over");
-          },
-          onDragLeave() {
-            row.classList.remove("drag-over");
-          },
-          onDrop() {
-            row.classList.remove("drag-over");
-          }
-        }));
-      }
-      _fileTreeDndCleanups.push(combine(...cleanups));
-    }
-    const rootCleanup = dropTargetForElements({
-      canDrop({ source }) {
-        if (source.data.type !== "file-tree") {
-          return false;
-        }
-        const srcPath = source.data.path;
-        return parentDir2(srcPath) !== ".";
-      },
-      element: tree,
-      getData() {
-        return { targetDir: ".", type: "file-tree-target" };
-      },
-      onDragEnter() {
-        tree.classList.add("drag-over-root");
-      },
-      onDragLeave() {
-        tree.classList.remove("drag-over-root");
-      },
-      onDrop() {
-        tree.classList.remove("drag-over-root");
-      }
-    });
-    _fileTreeDndCleanups.push(rootCleanup, registerFileDropTarget(tree, ".", "drag-over-root", renderLeftPanel));
-    const monitorCleanup = monitorForElements({
-      onDrop({ source, location: location2 }) {
-        const [target] = location2.current.dropTargets;
-        if (!target) {
-          return;
-        }
-        if (source.data.type !== "file-tree") {
-          return;
-        }
-        if (target.data.type !== "file-tree-target") {
-          return;
-        }
-        const srcPath = source.data.path;
-        const targetDirPath = target.data.targetDir;
-        const fileName = srcPath.split("/").pop();
-        const newPath = targetDirPath === "." ? fileName : `${targetDirPath}/${fileName}`;
-        if (newPath === srcPath) {
-          return;
-        }
-        moveFileEntry(srcPath, newPath, renderLeftPanel);
-      }
-    });
-    _fileTreeDndCleanups.push(monitorCleanup);
-  });
-}
-async function moveFileEntry(oldPath, newPath, renderLeftPanel) {
-  const platform = getPlatform();
-  markLocalMutation(oldPath, newPath);
-  try {
-    const report = await platform.renameFile(oldPath, newPath);
-    for (const [id] of workspace.tabs.entries()) {
-      if (id === oldPath) {
-        renameTab(oldPath, newPath, newPath);
-      } else if (id.startsWith(`${oldPath}/`)) {
-        const newTabPath = newPath + id.slice(oldPath.length);
-        renameTab(id, newTabPath, newTabPath);
-      }
-    }
-    const oldParent = parentDir2(oldPath);
-    const newParent = parentDir2(newPath);
-    await loadDirectory(oldParent);
-    if (newParent !== oldParent) {
-      await loadDirectory(newParent);
-    }
-    if (newParent !== ".") {
-      requireProjectState().expanded.add(newParent);
-    }
-    reloadRewrittenTabs(report, newPath);
-    renderLeftPanel();
-    statusMessage(`Moved to ${newPath}`);
-  } catch (error) {
-    statusMessage(`Error: ${errorMessage(error)}`);
-  }
-}
-function parentDir2(path) {
-  const normalized = path.replaceAll("\\", "/");
-  const lastSlash = normalized.lastIndexOf("/");
-  return lastSlash === -1 ? "." : normalized.slice(0, lastSlash);
-}
-var _fileCtxHandle = null;
-function dismissFileContextMenu() {
-  if (_fileCtxHandle) {
-    _fileCtxHandle.dismiss();
-    _fileCtxHandle = null;
-  }
-}
-function showFileContextMenu(e, entry, ctx) {
-  e.preventDefault();
-  dismissFileContextMenu();
-  const isDir = entry.type === "directory";
-  const items = [];
-  if (!isDir) {
-    items.push({ action: () => ctx.openFileFn(entry.path), label: "Open" });
-  }
-  if (isDir) {
-    items.push({
-      action: () => createNewFile(entry.path, ctx.renderLeftPanel),
-      label: "New File…"
-    }, {
-      action: () => pickAndUploadTo(entry.path, ctx.renderLeftPanel),
-      label: "Upload Files…"
-    });
-    const collection = collectionDirs().find(({ dir }) => entry.path === dir || entry.path.endsWith(`/${dir}`));
-    if (collection) {
-      items.push({
-        action: () => {
-          openCollectionGrid(collection.name);
-        },
-        label: "Edit Collection in Grid"
-      });
-    }
-    if (entry.path === "pages" || entry.path.endsWith("/pages")) {
-      items.push({
-        action: () => {
-          openPagesGrid();
-        },
-        label: "Edit Pages in Grid"
-      });
-    }
-  }
-  items.push({ label: "—" }, {
-    action: () => renameFile(entry, ctx.renderLeftPanel),
-    label: "Rename…"
-  }, {
-    action: () => deleteFile(entry, ctx.renderLeftPanel),
-    danger: true,
-    label: "Delete"
-  });
-  let { clientX: x, clientY: y } = e;
-  _fileCtxHandle = renderPopover(html`<sp-popover
-      open
-      style="position:fixed;z-index:10000;left:${x}px;top:${y}px"
-      ${ref((el) => {
-    if (!el) {
-      return;
-    }
-    requestAnimationFrame(() => {
-      const popover = el;
-      const menuRect = rectOf(popover);
-      if (x + menuRect.width > window.innerWidth) {
-        x = window.innerWidth - menuRect.width - 4;
-      }
-      if (y + menuRect.height > window.innerHeight) {
-        y = window.innerHeight - menuRect.height - 4;
-      }
-      popover.style.left = `${x}px`;
-      popover.style.top = `${y}px`;
-    });
-  })}
-    >
-      <sp-menu>
-        ${items.map((item) => item.label === "—" ? html`<sp-menu-divider></sp-menu-divider>` : html`<sp-menu-item
-                style=${item.danger ? "color: var(--danger)" : ""}
-                @click=${() => {
-    dismissFileContextMenu();
-    item.action?.();
-  }}
-                >${item.label}</sp-menu-item
-              >`)}
-      </sp-menu>
-    </sp-popover>`, {
-    dismissOnOutsideClick: true,
-    onDismiss: () => {
-      _fileCtxHandle = null;
-    }
-  });
-}
-async function createNewFile(dirPath, renderLeftPanel) {
-  const name = await showPromptDialog("New File", {
-    confirmLabel: "Create",
-    message: dirPath === "." ? "Creating in the project root." : `Creating in ${dirPath}/`,
-    placeholder: "untitled.json",
-    select: "stem",
-    validate: (v) => v.trim() ? "" : "Enter a file name.",
-    value: "untitled.json"
-  });
-  if (!name) {
-    return;
-  }
-  const path = dirPath === "." ? name : `${dirPath}/${name}`;
-  markLocalMutation(path);
-  await loadFormats();
-  const format = formatForPath(name);
-  const content = format?.studio?.newFileTemplate ?? (format ? "" : JSON.stringify({ children: [{ children: [], tagName: "p" }], tagName: "div" }, null, 2));
-  try {
-    const platform = getPlatform();
-    await platform.writeFile(path, content);
-    await loadDirectory(dirPath);
-    renderLeftPanel();
-    statusMessage(`Created ${path}`);
-  } catch (error) {
-    statusMessage(`Error: ${errorMessage(error)}`);
-  }
-}
-function showRenameFileDialog(currentName) {
-  return showPromptDialog("Rename", {
-    confirmLabel: "Rename",
-    select: "stem",
-    validate: (v) => v.trim() ? "" : "Enter a file name.",
-    value: currentName
-  });
-}
-function renameStatus(newName, report) {
-  const refs = report.references;
-  const tagNote = report.tag ? `; tag → <${report.tag.to}> (${report.tag.refsUpdated})` : "";
-  if (refs && refs.refsUpdated > 0) {
-    return `Renamed to ${newName}; updated ${refs.refsUpdated} reference(s) in ${refs.filesChanged} file(s)${tagNote}`;
-  }
-  if (tagNote) {
-    return `Renamed to ${newName}${tagNote}`;
-  }
-  return `Renamed to ${newName}`;
-}
-function reloadRewrittenTabs(report, skipPath) {
-  for (const f of report.references?.files ?? []) {
-    if (f.path !== skipPath && workspace.tabs.has(f.path)) {
-      reloadFileInTab(f.path);
-    }
-  }
-}
-async function renameFile(entry, renderLeftPanel) {
-  const newName = await showRenameFileDialog(entry.name);
-  if (!newName || newName === entry.name) {
-    return;
-  }
-  const entryPath = entry.path.replaceAll("\\", "/");
-  const parentDirPath = entryPath.includes("/") ? entryPath.slice(0, entryPath.lastIndexOf("/")) : ".";
-  const newPath = parentDirPath === "." ? newName : `${parentDirPath}/${newName}`;
-  markLocalMutation(entry.path, newPath);
-  try {
-    const platform = getPlatform();
-    const report = await platform.renameFile(entry.path, newPath);
-    await loadDirectory(parentDirPath);
-    if (requireProjectState().selectedPath === entry.path) {
-      requireProjectState().selectedPath = newPath;
-    }
-    if (workspace.tabs.has(entry.path)) {
-      renameTab(entry.path, newPath, newPath);
-    }
-    reloadRewrittenTabs(report, newPath);
-    renderLeftPanel();
-    statusMessage(renameStatus(newName, report));
-  } catch (error) {
-    statusMessage(`Error: ${errorMessage(error)}`);
-  }
-}
-async function deleteFile(entry, renderLeftPanel) {
-  const confirmed = await showConfirmDialog("Delete File", `Delete "${entry.name}"?`, {
-    confirmLabel: "Delete",
-    destructive: true
-  });
-  if (!confirmed) {
-    return;
-  }
-  try {
-    const platform = getPlatform();
-    markLocalMutation(entry.path);
-    await platform.deleteFile(entry.path);
-    const delPath = entry.path.replaceAll("\\", "/");
-    const parentDirPath = delPath.includes("/") ? delPath.slice(0, delPath.lastIndexOf("/")) : ".";
-    await loadDirectory(parentDirPath);
-    if (requireProjectState().selectedPath === entry.path) {
-      requireProjectState().selectedPath = null;
-    }
-    renderLeftPanel();
-    statusMessage(`Deleted ${entry.name}`);
-  } catch (error) {
-    statusMessage(`Error: ${errorMessage(error)}`);
-  }
-}
-async function openFileFromTree(ctx, path) {
-  const platform = getPlatform();
-  await loadFormats();
-  if (ctx.S.dirty && ctx.S.documentPath) {
-    try {
-      const tabLike = {
-        doc: {
-          content: ctx.S.content,
-          document: ctx.S.document,
-          mode: ctx.S.mode,
-          sourceFormat: formatForPath(ctx.S.documentPath)?.name ?? null
-        }
-      };
-      const output = await serializeDocument(tabLike);
-      await platform.writeFile(ctx.S.documentPath, output);
-    } catch (error) {
-      statusMessage(`Save error: ${errorMessage(error)}`);
-    }
-  }
-  try {
-    const content = await platform.readFile(path);
-    if (!content) {
-      return;
-    }
-    if (formatForPath(path)) {
-      ctx.loadMarkdown(content, null);
-      ctx.S.documentPath = path;
-      ctx.S.dirty = false;
-      ctx.commit(ctx.S);
-    } else if (path.endsWith(".json")) {
-      const doc = JSON.parse(content);
-      const newS = createState(doc);
-      newS.documentPath = path;
-      newS.dirty = false;
-      ctx.commit(newS);
-    } else {
-      throw noFormatError(path);
-    }
-    requireProjectState().selectedPath = path;
-    ctx.render();
-    statusMessage(`Opened ${path}`);
-  } catch (error) {
-    statusMessage(`Error: ${errorMessage(error)}`);
-  }
-}
-async function openFileInTab(path) {
-  for (const [id, tab] of workspace.tabs.entries()) {
-    if (tab.documentPath === path) {
-      activateTab(id);
-      requireProjectState().selectedPath = path;
-      return;
-    }
-  }
-  if (path.toLowerCase().endsWith(".csv")) {
-    try {
-      await openCsvGridTab(path);
-      requireProjectState().selectedPath = path;
-      trackRecentFile({
-        name: path.split("/").pop() || path,
-        path,
-        root: requireProjectState().projectRoot
-      });
-      statusMessage(`Opened ${path.split("/").pop()}`);
-    } catch (error) {
-      statusMessage(`Error: ${errorMessage(error)}`);
-    }
-    return;
-  }
-  const platform = getPlatform();
-  try {
-    const content = await platform.readFile(path);
-    if (!content) {
-      return;
-    }
-    await loadFormats();
-    let document2;
-    let frontmatter;
-    const format = formatForPath(path);
-    if (format) {
-      const result = await parseSourceForPath(path, content);
-      ({ document: document2 } = result);
-      ({ frontmatter } = result);
-    } else if (path.endsWith(".json")) {
-      document2 = JSON.parse(content);
-    } else {
-      throw noFormatError(path);
-    }
-    const id = path;
-    openTab({
-      id,
-      documentPath: path,
-      document: document2,
-      ...frontmatter != null && { frontmatter },
-      sourceFormat: format?.name ?? null
-    });
-    requireProjectState().selectedPath = path;
-    trackRecentFile({
-      name: path.split("/").pop() || path,
-      path,
-      root: requireProjectState().projectRoot
-    });
-    statusMessage(`Opened ${path.split("/").pop()}`);
-  } catch (error) {
-    statusMessage(`Error: ${errorMessage(error)}`);
-  }
-}
-function reloadCleanTab(path) {
-  if (isCollabPath(path)) {
-    return;
-  }
-  for (const [, tab] of workspace.tabs.entries()) {
-    if (tab.documentPath === path && !tab.doc.dirty) {
-      reloadFileInTab(path);
-      return;
-    }
-  }
-}
-async function reloadFileInTab(path) {
-  for (const [, tab] of workspace.tabs.entries()) {
-    if (tab.documentPath === path) {
-      const platform = getPlatform();
-      try {
-        const content = await platform.readFile(path);
-        if (!content) {
-          return;
-        }
-        await loadFormats();
-        if (formatForPath(path)) {
-          const { document: document2, frontmatter } = await parseSourceForPath(path, content);
-          tab.doc.document = document2;
-          tab.doc.content.frontmatter = frontmatter;
-        } else if (path.endsWith(".json")) {
-          tab.doc.document = JSON.parse(content);
-        }
-        tab.doc.dirty = false;
-      } catch {}
-      return;
-    }
-  }
-}
-
-export { hydrateProjectList, getProjectList, installAutomationHook, ensureDependenciesInstalled, startFsSync, dataSurfaceAvailable, testConnection, pushSchema, deriveSecretEnvName, cellValuesEqual, parseGridTabId, gridTabLabel, ROW_KEY_FIELD, getGridController, createGridController, coerceCellInput, cellToText, createCsvFileSource, parseSourceForPath, saveFile, exportFile, serializeDocument, listCollectionEntryIds, openConnectorGrid, openGridSourcePicker, hydrateRecentProjects, getRecentProjects, addRecentProject, removeRecentProject, clearRecentProjects, getRecentFiles, trackRecentFile, loadDirectory, loadProject, openProject, findHomePage, openHomePage, renderFilesTemplate, setupTreeKeyboard, isFileDrag, uploadFilesToDir, pickAndUploadTo, registerFileTreeDnD, openFileFromTree, openFileInTab, reloadCleanTab, reloadFileInTab };
-
-//# debugId=F6DA95B972A0DA6E64756E2164756E21
-//# sourceMappingURL=studio-d77qm3pk.js.map