@jxsuite/studio 4.1.0 → 5.1.0

package/dist/chunks/studio-b0k5tqgp.js

@@ -0,0 +1,2432 @@
+import {
+  nothing2
+} from "./studio-1k325pwf.js";
+import {
+  errorMessage2
+} from "./studio-yxa81f45.js";
+import {
+  localeLabel,
+  resolveI18n,
+  localeOfPath,
+  isCollabPath,
+  collectionForDirectory,
+  collectionForFile,
+  workspace2,
+  paneOfTab2,
+  receivingPane2,
+  setWorkspaceProject2,
+  openTab2,
+  replaceAllTabs2,
+  activateTab2,
+  moveTabToPane2,
+  renameTab2
+} from "./studio-k75n7vhp.js";
+import {
+  registerSurface,
+  mountSurface,
+  runReported,
+  runActiveReported,
+  showPromptDialog2
+} from "./studio-vfq8qpjt.js";
+import {
+  activeRegistry
+} from "./studio-kkqkcp3d.js";
+import {
+  reactive,
+  now,
+  notify2
+} from "./studio-p1dw8wfw.js";
+import {
+  projectState,
+  setProjectState,
+  requireProjectState
+} from "./studio-6ewqv390.js";
+import {
+  getPlatform2,
+  hasPlatform2
+} from "./studio-6nzaktvy.js";
+import {
+  loadFormats2,
+  refreshFormats2,
+  refreshExtensionUi2,
+  getFormats2,
+  formatByExtension2,
+  noFormatError2,
+  formatForPath2,
+  documentExtensions2
+} from "./studio-vw7mzp6z.js";
+import {
+  resetIgnoreCache,
+  ensureIgnoreLayers,
+  isIgnoredEntry,
+  markLocalMutation2
+} from "./studio-g3jevyjt.js";
+import {
+  invalidateUsages2
+} from "./studio-nq5yf5mp.js";
+import {
+  parseJsonDocument,
+  restoreSession,
+  persistedSession,
+  markSessionRestored,
+  setActivityTab,
+  resetProjectShell
+} from "./studio-qk90fgqm.js";
+import {
+  SETTINGS,
+  readStoredSetting,
+  setSetting
+} from "./studio-y9zedyjn.js";
+import {
+  showProgressModal
+} from "./studio-tqgryxwg.js";
+import {
+  registerPanel
+} from "./studio-8scdew0e.js";
+import {
+  disarmPreviewOverlay,
+  parseSourceForPath2,
+  confirmFileDelete2,
+  renamePromptMessage2
+} from "./studio-gb13095a.js";
+import {
+  loadComponentRegistry2
+} from "./studio-zdn2g6dt.js";
+import {
+  combine,
+  dropTargetForElements2,
+  monitorForElements2,
+  draggable2
+} from "./studio-esrxgwh6.js";
+import {
+  shouldInstallAutomation,
+  maybePromptJxsuiteUpdate,
+  autoSyncProjectOnOpen,
+  isViewableMedia,
+  openMediaTab,
+  cleanupGitPanel2
+} from "./studio-5wt9nvhd.js";
+import {
+  uploadAccept,
+  isImage,
+  uploadAssets
+} from "./studio-jxp12rnj.js";
+import {
+  openCsvGridTab,
+  openPagesGrid
+} from "./studio-pxbgypmg.js";
+import {
+  openMenu2
+} from "./studio-aj37eer3.js";
+import {
+  listWindow,
+  revealListRow,
+  watchListWindow
+} from "./studio-38emantv.js";
+import {
+  collectionOfPath
+} from "./studio-qhhm6hbt.js";
+import {
+  __preload
+} from "./studio-5te5tqng.js";
+
+// src/packages/ensure-deps.ts
+async function ensureDependenciesInstalled() {
+  if (shouldInstallAutomation(location.search)) {
+    return false;
+  }
+  const platform = getPlatform2();
+  if (!platform.dependenciesNeedInstall || !platform.installDependencies) {
+    return false;
+  }
+  let needs = false;
+  try {
+    needs = await platform.dependenciesNeedInstall();
+  } catch {
+    return false;
+  }
+  if (!needs) {
+    return false;
+  }
+  const progress = showProgressModal({
+    status: "Running bun install…",
+    title: "Installing dependencies"
+  });
+  try {
+    const result = await platform.installDependencies();
+    if (result.ok) {
+      progress.done();
+      return true;
+    }
+    progress.fail(result.log ?? "bun install failed");
+  } catch (error) {
+    progress.fail(error instanceof Error ? error.message : String(error));
+  }
+  return false;
+}
+
+// src/format/format-choices.ts
+var DOCUMENT_KINDS = ["page", "component"];
+var DOCUMENT_ROOTS = { components: "component", pages: "page" };
+function normalize(path) {
+  return path.replaceAll("\\", "/").replace(/^\.\//, "");
+}
+function documentRootOf(path) {
+  const lower = normalize(path).toLowerCase();
+  for (const [dir, kind] of Object.entries(DOCUMENT_ROOTS)) {
+    if (lower.startsWith(`${dir}/`)) {
+      return kind;
+    }
+  }
+  return null;
+}
+function declaresDocumentKind(kinds) {
+  return DOCUMENT_KINDS.some((kind) => kinds.includes(kind));
+}
+function isLayoutPath(path) {
+  const declared = projectState?.projectConfig?.layout;
+  if (typeof declared !== "string") {
+    return false;
+  }
+  return normalize(declared).toLowerCase() === normalize(path).toLowerCase();
+}
+function creationFormats(kind) {
+  const rows = [{ ext: ".json", label: "JSON (.json)" }];
+  for (const ext of documentExtensions2(kind)) {
+    const reader = formatByExtension2(ext, "parse");
+    if (reader && formatByExtension2(ext, "serialize")) {
+      rows.push({ ext, label: `${reader.name} (${ext})` });
+    }
+  }
+  return rows;
+}
+function knownDocumentExtensions() {
+  return new Set([".json", ...getFormats2().flatMap((format) => format.extensions)]);
+}
+function convertTargets(path) {
+  if (path === null || path === undefined || path === "") {
+    return [];
+  }
+  const root = documentRootOf(path);
+  if (root === null || isLayoutPath(path) || collectionForFile(path)) {
+    return [];
+  }
+  const source = formatForPath2(path);
+  const readable = source ? Boolean(source.capabilities.parse) && declaresDocumentKind(source.documentKinds) : normalize(path).toLowerCase().endsWith(".json");
+  if (!readable) {
+    return [];
+  }
+  const rows = [];
+  if (source) {
+    rows.push({ ext: ".json", label: "JSON (.json)" });
+  }
+  for (const ext of documentExtensions2()) {
+    const writer = formatByExtension2(ext, "serialize");
+    if (!writer || writer.name === source?.name || !declaresDocumentKind(writer.documentKinds) || !writer.documentKinds.includes(root)) {
+      continue;
+    }
+    rows.push({ ext, label: `${writer.name} (${ext})` });
+  }
+  return rows;
+}
+function convertTargetExtensions() {
+  const exts = new Set([".json"]);
+  for (const format of getFormats2()) {
+    if (!format.capabilities.serialize || !declaresDocumentKind(format.documentKinds)) {
+      continue;
+    }
+    for (const ext of format.extensions) {
+      exts.add(ext);
+    }
+  }
+  return [...exts].toSorted();
+}
+
+// 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 cache = [];
+function backend() {
+  if (!hasPlatform2()) {
+    return null;
+  }
+  const platform = getPlatform2();
+  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() ? cache : loadFromLocalStorage();
+}
+function commit(list) {
+  cache = 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 {
+    cache = await store.getRecentProjects();
+  } catch {
+    cache = [];
+  }
+}
+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: now() });
+  if (projects.length > MAX_RECENT) {
+    projects.length = MAX_RECENT;
+  }
+  commit(projects);
+}
+function removeRecentProject(root) {
+  commit(currentList().filter((p) => p.root !== root));
+}
+function clearRecentProjects() {
+  cache = [];
+  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: 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/surfaces/files-panel.json
+var files_panel_default = {
+  $schema: "https://jxsuite.com/schema/v1",
+  $id: "StudioFilesPanel",
+  $description: 'The Navigator\'s Files tree, as a Jx document over the kit. `files/files.ts` keeps every decision — which directories are listed, which entries `.gitignore` masks, which rows the window draws, what a click on a row means, what the context menu offers and what each verb does to the filesystem — and hands this document one projection: a word saying which of three things to draw, a toolbar whose state is already resolved, and rows whose every field is already a string. Nothing here asks what a file is, how tall the Navigator is, or whether a directory has been read. THE TREE IS `jx-tree`, and that is what this document no longer says: `role="tree"`, `role="treeitem"`, `aria-level`, `aria-posinset`, `aria-setsize`, the roving `tabindex` and the five arrow-key cases were each written out here and written out again in `panel-outline.json`, two copies of one keyboard contract with nothing holding them in agreement. The element owns all of it; what is left here is what this tree IS — a flat projection of rows, each already carrying its own level and set counts, because the DOM holds a WINDOW onto the model and an expanded `node_modules` is eleven rows rather than ten thousand. The window reaches the element as `padtop`/`padbottom`, and a caret move past either comes back as `move` for the flow to scroll and repaint. Four facts a row carries are bound against ONE scope field each — the current path, the selected path, the dragged path and the drop target — so moving the caret or dragging a file re-evaluates an attribute per drawn row instead of rebuilding the list under the reader\'s pointer. The pragmatic-drag-and-drop handles are an ISLAND: the document draws the rows and the tree, and the adapter attaches sources and targets to them through `onNodeCreated` (specs/studio-ui-guidelines.md §9.4).',
+  tagName: "div",
+  attributes: {
+    part: "files"
+  },
+  style: {
+    $description: "What the twenty `.file-tree*`, `.files-toolbar`, `.project-header` and `.project-name` rules in `styles/panels.css` said, keyed on `part` and re-pointed at the studio token layer. Three names could not come with the declarations. The five `var(--spectrum-font-size-50 | -75, …)` reads are the kit's `--jx-text-sm` and `--jx-text-md`, which are the same 11px and 12px — a `--spectrum-*` name is declared by `<sp-theme>` and by nothing else in this package, so a document that reads one is a document whose type size changes when a component it does not use is removed. The `.selected`, `.dragging`, `.drag-over` and `.drag-over-root` classes are `data-` attributes on a part, because a part is the handle now and because a state a handler adds and forgets to take off is exactly the defect a cancelled drag used to leave on screen. MOST OF THE ROW'S OWN RULES ARE GONE, and that is the point of the element rather than an omission: `jx-tree-item` declares the flex line, the one-control-height box the window reserves scroll by, the indent (`--jx-tree-indent` times one less than `level` — exactly the `8 + depth * 16` this file composed per row), the hover and focus states, the selected wash and the faded dragged row. What is left here is what is TRUE OF THIS TREE and not of trees in general: it owns its own scrollbar, a click on a row opens it, and the row a drag is over wears the drop mark this file draws.",
+    display: "flex",
+    flexDirection: "column",
+    height: "100%",
+    minHeight: "0",
+    overflow: "hidden",
+    fontFamily: "var(--jx-font-sans)",
+    fontSize: "var(--jx-text-md)",
+    color: "var(--fg)",
+    '& [part="empty"]': {
+      $description: "The two states that are not a tree. They are two states and not one sentence: a window with no project at all and a monorepo root that has not been pointed at a site are different situations, and only the second has anything to offer (§11).",
+      padding: "var(--jx-space-6)",
+      textAlign: "center",
+      color: "var(--fg-dim)",
+      fontSize: "var(--jx-text-md)",
+      display: "flex",
+      flexDirection: "column",
+      alignItems: "center",
+      gap: "var(--jx-space-4)"
+    },
+    '& [part="empty"] p': {
+      margin: "0"
+    },
+    '& [part="frame"]': {
+      display: "flex",
+      flexDirection: "column",
+      height: "100%",
+      minHeight: "0"
+    },
+    '& [part="project-header"]': {
+      display: "flex",
+      alignItems: "center",
+      gap: "var(--jx-space-3)",
+      padding: "var(--jx-space-3) var(--jx-space-4)",
+      borderBottom: "1px solid var(--border)",
+      flexShrink: "0"
+    },
+    '& [part="project-name"]': {
+      fontSize: "var(--jx-text-md)",
+      fontWeight: "600",
+      overflow: "hidden",
+      textOverflow: "ellipsis",
+      whiteSpace: "nowrap"
+    },
+    '& [part="toolbar"]': {
+      display: "flex",
+      gap: "var(--jx-space-2)",
+      padding: "var(--jx-space-2) var(--jx-space-3)",
+      borderBottom: "1px solid var(--border)",
+      alignItems: "center",
+      flexShrink: "0"
+    },
+    '& [part="search"]': {
+      flex: "1",
+      minWidth: "0"
+    },
+    '& [part="tree"]': {
+      $description: "The scroller as well as the list. `ui/virtual-window.ts` walks up from the element it is given looking for the nearest thing that scrolls, and finding itself is the shortest answer — which is why the element declares no `overflow` of its own and leaves the question to the two trees that answer it differently. The colour is re-declared because `jx-tree` sets `--jx-fg` on itself, and this panel's text colour is the studio alias of it.",
+      flex: "1",
+      minHeight: "0",
+      overflowY: "auto",
+      color: "var(--fg)"
+    },
+    '& [part="tree"][data-drop="true"]': {
+      background: "var(--hover-bg)"
+    },
+    '& [part="row"]': {
+      $description: "What the element does not decide. A click on a row OPENS it here — a directory unfolds, a file takes a tab — so the pointer is a pointer rather than the element's default arrow; and the gap is the wider one this tree has always drawn between a 16px file glyph and its name.",
+      gap: "var(--jx-space-3)",
+      cursor: "pointer"
+    },
+    '& [part="loading-row"]': {
+      $description: "A directory whose listing has not arrived yet. It holds the place and it is NOT a row: it is not a `jx-tree-item`, so the caret cannot land on it, the set counts do not include it and typeahead cannot match it — and it is replaced by the real rows on the repaint the listing provokes. It draws the same box by hand because it is the only line in this tree the element does not draw, and a placeholder of a different height would desynchronise the window's scroll reservation from the rows it reserves for.",
+      display: "flex",
+      alignItems: "center",
+      boxSizing: "border-box",
+      blockSize: "var(--jx-control-h)",
+      paddingInline: "calc(var(--jx-space-3) + var(--depth, 0) * 16px) var(--jx-space-3)",
+      color: "var(--fg-dim)",
+      fontStyle: "italic",
+      cursor: "default",
+      userSelect: "none",
+      whiteSpace: "nowrap"
+    },
+    '& [part="row-icon"]': {
+      flexShrink: "0",
+      display: "flex",
+      alignItems: "center",
+      "--jx-icon-size": "16px"
+    },
+    '& [part="locale"]': {
+      $description: "The language chip. Deliberately declares no block size, no padding and no line height: the row above is one control-height by contract, and a chip that grew the box would desynchronise the window's scroll reservation from the height it reserves by. It only ever shrinks the text. A chip, not a filter term: the search matches the file's name alone, because a query that silently also matched a language would make “why is this file here” unanswerable from what is on screen.",
+      marginInlineStart: "auto",
+      flexShrink: "0",
+      fontSize: "var(--jx-text-sm)",
+      color: "var(--fg-dim)",
+      overflow: "hidden",
+      textOverflow: "ellipsis",
+      whiteSpace: "nowrap",
+      maxInlineSize: "6em"
+    },
+    '& [part="view-slot"], & [part="header-slot"], & [part="locale-slot"]': {
+      $description: "A `$switch` renders its own container, and none of these three is a box: each stands exactly where its case does, so the case's own rule is the only one that lays anything out.",
+      display: "contents"
+    }
+  },
+  children: [
+    {
+      tagName: "div",
+      attributes: {
+        part: "view-slot",
+        role: "none"
+      },
+      $switch: {
+        $ref: "#/state/view"
+      },
+      cases: {
+        none: {
+          tagName: "div",
+          attributes: {
+            part: "empty"
+          },
+          children: [
+            {
+              tagName: "p",
+              textContent: "No project loaded"
+            }
+          ]
+        },
+        welcome: {
+          tagName: "div",
+          attributes: {
+            part: "empty"
+          },
+          children: [
+            {
+              tagName: "p",
+              textContent: "Open a project folder to get started."
+            },
+            {
+              tagName: "jx-button",
+              attributes: {
+                part: "open-project"
+              },
+              $props: {
+                variant: "accent",
+                size: "sm"
+              },
+              onclick: {
+                $prototype: "Function",
+                body: [
+                  {
+                    operator: "call",
+                    target: {
+                      $ref: "#/state/openProject"
+                    },
+                    value: []
+                  }
+                ],
+                description: "The declared `project.open` command, run through the registry — not a second opener of this surface's own. It is the one the chord, the palette and the status bar's PROJECT field already run, so a window that opens a project from here reports the outcome the same way they do (§12.5)."
+              },
+              children: [
+                {
+                  tagName: "span",
+                  textContent: "Open Project"
+                }
+              ]
+            }
+          ]
+        },
+        tree: {
+          tagName: "div",
+          attributes: {
+            part: "frame"
+          },
+          children: [
+            {
+              tagName: "div",
+              attributes: {
+                part: "header-slot",
+                role: "none"
+              },
+              $switch: {
+                $ref: "#/state/headerState"
+              },
+              cases: {
+                shown: {
+                  tagName: "div",
+                  attributes: {
+                    part: "project-header"
+                  },
+                  children: [
+                    {
+                      tagName: "span",
+                      attributes: {
+                        part: "project-name",
+                        title: "${state.projectName}"
+                      },
+                      textContent: "${state.projectName}"
+                    }
+                  ]
+                }
+              }
+            },
+            {
+              tagName: "div",
+              attributes: {
+                part: "toolbar"
+              },
+              children: [
+                {
+                  tagName: "jx-action-group",
+                  attributes: {
+                    part: "toolbar-actions"
+                  },
+                  $props: {
+                    compact: true,
+                    label: "File tree actions"
+                  },
+                  children: [
+                    {
+                      tagName: "jx-action-button",
+                      attributes: {
+                        part: "new-file"
+                      },
+                      $props: {
+                        size: "sm",
+                        icon: "plus",
+                        label: "New File",
+                        hint: "New File"
+                      },
+                      onclick: {
+                        $prototype: "Function",
+                        body: [
+                          {
+                            operator: "call",
+                            target: {
+                              $ref: "#/state/newFile"
+                            },
+                            value: []
+                          }
+                        ]
+                      }
+                    },
+                    {
+                      tagName: "jx-action-button",
+                      attributes: {
+                        part: "refresh"
+                      },
+                      $props: {
+                        size: "sm",
+                        icon: "arrows-clockwise",
+                        label: "Refresh",
+                        hint: "Refresh"
+                      },
+                      onclick: {
+                        $prototype: "Function",
+                        body: [
+                          {
+                            operator: "call",
+                            target: {
+                              $ref: "#/state/refresh"
+                            },
+                            value: []
+                          }
+                        ],
+                        description: "The rules go with the listings. Refresh is what an author reaches for after editing a `.gitignore` by hand, and a tree that came back still hiding by the old rules would read as the button not having worked."
+                      }
+                    },
+                    {
+                      tagName: "jx-action-button",
+                      attributes: {
+                        part: "show-ignored"
+                      },
+                      $props: {
+                        size: "sm",
+                        icon: {
+                          $ref: "#/state/ignoredIcon"
+                        },
+                        label: {
+                          $ref: "#/state/ignoredLabel"
+                        },
+                        hint: {
+                          $ref: "#/state/ignoredLabel"
+                        },
+                        selected: {
+                          $ref: "#/state/ignoredSelected"
+                        }
+                      },
+                      onclick: {
+                        $prototype: "Function",
+                        body: [
+                          {
+                            operator: "call",
+                            target: {
+                              $ref: "#/state/toggleIgnored"
+                            },
+                            value: []
+                          }
+                        ],
+                        description: "A repaint and nothing else: the ignored entries were never dropped from the cached listings, only from the rows built out of them."
+                      }
+                    }
+                  ]
+                },
+                {
+                  tagName: "jx-textfield",
+                  attributes: {
+                    part: "search"
+                  },
+                  $props: {
+                    label: "Filter files",
+                    placeholder: "Filter files…",
+                    size: "sm",
+                    value: {
+                      $ref: "#/state/query"
+                    }
+                  },
+                  oninput: {
+                    $prototype: "Function",
+                    body: [
+                      {
+                        operator: "call",
+                        target: {
+                          $ref: "#/state/search"
+                        },
+                        value: [
+                          {
+                            $ref: "event#/target/value"
+                          }
+                        ]
+                      }
+                    ],
+                    description: "The query matches a file's NAME and nothing else. A directory is kept whatever it says, because hiding the folder a match sits in would leave the match with nowhere to be drawn."
+                  }
+                }
+              ]
+            },
+            {
+              $description: 'The `role="tree"`, and everything that used to be spelled out under it. The element writes the role, the name, the roving tab stop and every row\'s `aria-level` / `aria-posinset` / `aria-setsize`, and it owns the whole ARIA keyboard: the arrows walk the drawn rows without wrapping, `Home` and `End` reach the ends of the MODEL by way of the pads, `ArrowRight` opens a directory and steps into an open one, `ArrowLeft` closes one and otherwise steps out to its parent, `Enter` activates and a printable character is typeahead. Every chord it does not own — cut, copy, paste, delete, rename — passes straight through to the flow, which is the WCAG 2.5.7 obligation this tree carries because dragging a file is the other way to move it. What reaches this document is five events, and each of them is a decision `files.ts` already owned.',
+              tagName: "jx-tree",
+              attributes: {
+                part: "tree",
+                label: "Project files",
+                current: "${state.currentPath}",
+                padtop: "${state.padTop}",
+                padbottom: "${state.padBottom}",
+                "data-drop": "${state.rootDrop || null}"
+              },
+              onselect: {
+                $prototype: "Function",
+                body: [
+                  {
+                    operator: "call",
+                    target: {
+                      $ref: "#/state/select"
+                    },
+                    value: [
+                      {
+                        $ref: "event#/detail/value"
+                      }
+                    ]
+                  }
+                ],
+                description: "The reader meant that row. This tree is single-select, so the element resolves every modifier to `replace` before it gets here and the detail's `mode` and `anchor` are answers to a question this tree does not ask. There is no `change` handler beside it on purpose: the element OWNS the caret and keeps it across every repaint that does not change `current`, so a second copy of it in the flow would be a variable that only ever went stale."
+              },
+              onactivate: {
+                $prototype: "Function",
+                body: [
+                  {
+                    operator: "call",
+                    target: {
+                      $ref: "#/state/activate"
+                    },
+                    value: [
+                      {
+                        $ref: "event#/detail"
+                      }
+                    ]
+                  }
+                ],
+                description: "`Enter` or a double click. The same verb a single click reaches, by the same name."
+              },
+              onexpand: {
+                $prototype: "Function",
+                body: [
+                  {
+                    operator: "call",
+                    target: {
+                      $ref: "#/state/expand"
+                    },
+                    value: [
+                      {
+                        $ref: "event#/detail/value"
+                      },
+                      {
+                        $ref: "event#/detail/expanded"
+                      }
+                    ]
+                  }
+                ],
+                description: "`ArrowRight`, `ArrowLeft` or the twisty, with ONE dispatcher between them: the detail says the state the row should be PUT INTO, so the flow never has to work out which way a toggle was going."
+              },
+              onmove: {
+                $prototype: "Function",
+                body: [
+                  {
+                    operator: "call",
+                    target: {
+                      $ref: "#/state/move"
+                    },
+                    value: [
+                      {
+                        $ref: "event#/detail/from"
+                      },
+                      {
+                        $ref: "event#/detail/key"
+                      }
+                    ]
+                  }
+                ],
+                description: "The caret has to reach a row the window did not draw. The element knows only that the pad on that side is not zero; where the row is in the model, and how far to scroll to bring it into view, is the flow's — which is why this is an event and not a `scrollIntoView`."
+              },
+              ontypeahead: {
+                $prototype: "Function",
+                body: [
+                  {
+                    operator: "call",
+                    target: {
+                      $ref: "#/state/typeahead"
+                    },
+                    value: [
+                      {
+                        $ref: "event#/detail/from"
+                      },
+                      {
+                        $ref: "event#/detail/char"
+                      }
+                    ]
+                  }
+                ],
+                description: "A printable character, on a windowed tree. The same hand-off as `onmove` and for a sharper reason: a move off the end of the slice announces itself, and a letter never does — the element's own search over the drawn rows always answers, and over a `node_modules` of ten thousand entries the answer is whichever of the eleven painted rows happened to start with that letter. So the element dispatches EVERY such character and the flow answers it over the model."
+              },
+              children: [
+                {
+                  $prototype: "Array",
+                  items: {
+                    $ref: "#/state/rows"
+                  },
+                  key: {
+                    $ref: "$map/item/key"
+                  },
+                  map: {
+                    tagName: "div",
+                    attributes: {
+                      part: "row-slot",
+                      role: "none"
+                    },
+                    style: {
+                      display: "contents"
+                    },
+                    $switch: {
+                      $ref: "$map/item/kind"
+                    },
+                    cases: {
+                      item: {
+                        tagName: "jx-tree-item",
+                        attributes: {
+                          part: "row",
+                          value: "${$map.item.path}",
+                          label: "${$map.item.name}",
+                          level: "${$map.item.level}",
+                          posinset: "${$map.item.posInSet}",
+                          setsize: "${$map.item.setSize}",
+                          expanded: "${$map.item.ariaExpanded}",
+                          selected: "${state.selectedPath === $map.item.path ? 'true' : 'false'}",
+                          "data-type": "${$map.item.type}",
+                          "data-dragging": "${state.dragPath === $map.item.path ? '' : null}",
+                          "data-drop": "${state.dropPath === $map.item.path ? '' : null}"
+                        },
+                        onclick: {
+                          $prototype: "Function",
+                          body: [
+                            {
+                              operator: "call",
+                              target: {
+                                $ref: "#/state/activate"
+                              },
+                              value: [
+                                {
+                                  $ref: "$map/item/path"
+                                }
+                              ]
+                            }
+                          ],
+                          description: "A single click OPENS the row, which is this tree's own answer and not the element's. `jx-tree` answers a click with `change` and `select`, exactly as it answers an arrow key, and a tree that opened on `select` would open every file the reader arrowed past. So the opening verb is bound here, where a click is a click; what a click MEANS — unfold this directory, take a tab for that file — stays the flow's, and Enter reaches the same verb through `activate`. It does NOT stop the event, which is the correction: the tree's delegated click is what moves the caret and the selection onto the row, so a `stopPropagation` here would leave a reader who clicked a folder with the tab stop still on whatever they had open last. The twisty stops its own click, so opening a directory from the chevron does not also activate the row."
+                        },
+                        oncontextmenu: {
+                          $prototype: "Function",
+                          body: [
+                            {
+                              preventDefault: true
+                            },
+                            {
+                              stopPropagation: true
+                            },
+                            {
+                              operator: "call",
+                              target: {
+                                $ref: "#/state/contextMenu"
+                              },
+                              value: [
+                                {
+                                  $ref: "$map/item/path"
+                                },
+                                {
+                                  $ref: "event#/clientX"
+                                },
+                                {
+                                  $ref: "event#/clientY"
+                                }
+                              ]
+                            }
+                          ]
+                        },
+                        children: [
+                          {
+                            tagName: "jx-icon",
+                            attributes: {
+                              slot: "icon",
+                              part: "row-icon",
+                              "aria-hidden": "true"
+                            },
+                            $props: {
+                              name: {
+                                $ref: "$map/item/icon"
+                              }
+                            }
+                          },
+                          {
+                            tagName: "div",
+                            attributes: {
+                              slot: "status",
+                              part: "locale-slot",
+                              role: "none"
+                            },
+                            $switch: {
+                              $ref: "$map/item/localeState"
+                            },
+                            cases: {
+                              shown: {
+                                tagName: "span",
+                                attributes: {
+                                  part: "locale"
+                                },
+                                textContent: "${$map.item.locale}"
+                              }
+                            }
+                          }
+                        ]
+                      },
+                      loading: {
+                        $description: "A directory whose listing has not arrived yet. Deliberately not a `jx-tree-item`: there is no file there to select, open, rename or drag, and a row the caret could land on that answers to none of the verbs the caret offers is a stop in the walk with nothing behind it.",
+                        tagName: "div",
+                        attributes: {
+                          part: "loading-row",
+                          role: "none",
+                          "data-loading": "true",
+                          style: "--depth:${$map.item.depth}"
+                        },
+                        textContent: "Loading…"
+                      }
+                    }
+                  }
+                }
+              ]
+            }
+          ]
+        }
+      }
+    }
+  ]
+};
+
+// src/surfaces/files-panel.ts
+registerSurface("files-panel", files_panel_default);
+function project(scope, values) {
+  scope.view = values.view;
+  scope.headerState = values.headerState;
+  scope.projectName = values.projectName;
+  scope.query = values.query;
+  scope.ignoredLabel = values.ignoredLabel;
+  scope.ignoredIcon = values.ignoredIcon;
+  scope.ignoredSelected = values.ignoredSelected;
+  scope.padTop = values.padTop;
+  scope.padBottom = values.padBottom;
+  scope.rows = values.rows;
+  scope.selectedPath = values.selectedPath;
+  scope.dragPath = values.dragPath;
+  scope.dropPath = values.dropPath;
+  scope.rootDrop = values.rootDrop;
+  scope.currentPath = values.currentPath;
+}
+function emptyFilesPanelValues() {
+  return {
+    currentPath: "",
+    dragPath: "",
+    dropPath: "",
+    headerState: "hidden",
+    ignoredIcon: "eye-slash",
+    ignoredLabel: "Show ignored files",
+    ignoredSelected: false,
+    padBottom: 0,
+    padTop: 0,
+    projectName: "",
+    query: "",
+    rootDrop: "",
+    rows: [],
+    selectedPath: "",
+    view: "none"
+  };
+}
+function partOf(def) {
+  const part = typeof def === "string" ? undefined : def.attributes?.["part"];
+  return typeof part === "string" ? part : "";
+}
+function mappedRow(state) {
+  const map = state?.["$map"];
+  const item = map?.item;
+  return typeof item?.path === "string" ? item : null;
+}
+function mountFilesPanelSurface(container, values, actions) {
+  const scope = reactive({
+    ...emptyFilesPanelValues(),
+    ...actions
+  });
+  project(scope, values);
+  let mounted = null;
+  let disposed = false;
+  const ready = mountSurface("files-panel", scope, container, {
+    onNodeCreated: (element, _path, def, state) => {
+      if (disposed || !(element instanceof HTMLElement)) {
+        return;
+      }
+      const part = partOf(def);
+      if (part === "tree") {
+        actions.treeHost(element);
+        return;
+      }
+      if (part !== "row") {
+        return;
+      }
+      const row = mappedRow(state);
+      if (row) {
+        actions.rowHost(element, row.path, row.type);
+      }
+    }
+  }).then((surface) => {
+    if (disposed) {
+      surface.dispose();
+      return;
+    }
+    mounted = surface;
+  });
+  return {
+    connected: () => !disposed && (mounted === null || mounted.root.parentNode === container),
+    dispose() {
+      disposed = true;
+      mounted?.dispose();
+      mounted = null;
+    },
+    ready,
+    update: (next) => {
+      project(scope, next);
+    }
+  };
+}
+
+// src/files/files.ts
+async function loadDirectory2(dirPath) {
+  if (!projectState) {
+    return;
+  }
+  try {
+    const platform = getPlatform2();
+    const [entries] = await Promise.all([
+      platform.listDirectory(dirPath),
+      ensureIgnoreLayers(dirPath)
+    ]);
+    projectState.dirs.set(dirPath, entries);
+  } catch {
+    projectState.dirs.set(dirPath, []);
+  }
+}
+function showIgnoredFiles() {
+  return readStoredSetting(SETTINGS.showIgnoredFiles) === "true";
+}
+function setShowIgnoredFiles(show) {
+  setSetting(SETTINGS.showIgnoredFiles, show ? "true" : "");
+}
+async function loadProject2() {
+  try {
+    const platform = getPlatform2();
+    const result = await platform.probeRootProject();
+    if (!result) {
+      return;
+    }
+    const { meta, info } = result;
+    refreshFormats2();
+    loadFormats2();
+    refreshExtensionUi2(platform);
+    resetIgnoreCache();
+    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) {
+      setWorkspaceProject2(meta.root || ".", info.projectConfig || null);
+    }
+    if (info.isSiteProject) {
+      addRecentProject(requireProjectState().name, meta.root);
+      await autoSyncProjectOnOpen();
+      if (await ensureDependenciesInstalled()) {
+        refreshFormats2();
+        await loadFormats2();
+        refreshExtensionUi2(platform);
+      }
+      await loadDirectory2(".");
+      await loadComponentRegistry2();
+      await openLastSessionOrHome2();
+      maybePromptJxsuiteUpdate(meta.root);
+    }
+  } catch {}
+}
+async function openProject2({
+  renderLeftPanel
+}) {
+  try {
+    const platform = getPlatform2();
+    const result = await platform.openProject();
+    if (!result) {
+      return false;
+    }
+    const { config, handle } = result;
+    replaceAllTabs2({
+      document: { children: [], tagName: "div" },
+      id: "initial"
+    });
+    disarmPreviewOverlay();
+    refreshFormats2();
+    loadFormats2();
+    refreshExtensionUi2(platform);
+    resetIgnoreCache();
+    setProjectState({
+      ...projectState,
+      dirs: new Map,
+      expanded: new Set,
+      isSiteProject: true,
+      name: config.name || handle.name,
+      projectConfig: config,
+      projectRoot: handle.root,
+      searchQuery: "",
+      selectedPath: null
+    });
+    setWorkspaceProject2(handle.root, config);
+    await autoSyncProjectOnOpen();
+    if (await ensureDependenciesInstalled()) {
+      refreshFormats2();
+      await loadFormats2();
+      refreshExtensionUi2(platform);
+    }
+    await loadDirectory2(".");
+    await loadComponentRegistry2();
+    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 loadDirectory2(e.path || e.name);
+      }
+    }
+    requireProjectState().projectDirs = foundDirs;
+    cleanupGitPanel2();
+    resetProjectShell();
+    setActivityTab("files");
+    addRecentProject(requireProjectState().name, requireProjectState().projectRoot);
+    renderLeftPanel();
+    await openLastSessionOrHome2();
+    maybePromptJxsuiteUpdate(requireProjectState().projectRoot);
+    return true;
+  } catch (error) {
+    notify2.error("Could not open the project.", {
+      detail: errorMessage2(error),
+      source: "Open Project"
+    });
+    return false;
+  }
+}
+async function initProjectRepo2(root) {
+  const platform = getPlatform2();
+  if (platform.createDestination !== "path") {
+    return false;
+  }
+  try {
+    await platform.activate(root);
+    const status = await platform.gitStatus();
+    if (status.isRepo) {
+      return false;
+    }
+    await platform.gitInit();
+    notify2.success("Initialized a git repository for this project.");
+    return true;
+  } catch (error) {
+    notify2.warn("Could not initialize a git repository — the project itself was written.", {
+      detail: errorMessage2(error),
+      source: "Source Control"
+    });
+    return false;
+  }
+}
+async function findHomePage2() {
+  await loadFormats2();
+  const exts = [...documentExtensions2("page"), ".json"];
+  let entries;
+  try {
+    entries = await getPlatform2().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 findHomePage2();
+  if (home) {
+    await openFileInTab2(home);
+  }
+}
+async function openLastSessionOrHome2() {
+  const session = persistedSession(workspace2.projectRoot);
+  markSessionRestored(workspace2.projectRoot);
+  if (session) {
+    const opened = await restoreSession(session, {
+      ensureSecondPane: () => {
+        receivingPane2();
+      },
+      openFile: (path, paneId) => openFileInTab2(path, { focus: false, paneId })
+    });
+    if (opened > 0) {
+      return true;
+    }
+  }
+  await openHomePage();
+  return false;
+}
+function fileIconName(name, type, expanded) {
+  if (type === "directory") {
+    return expanded ? "folder-open" : "folder";
+  }
+  const ext = name.split(".").pop()?.toLowerCase();
+  switch (ext) {
+    case "css":
+    case "js":
+    case "json":
+    case "ts": {
+      return "file-code";
+    }
+    case "md": {
+      return "file-text";
+    }
+    default: {
+      return ext !== undefined && isImage(ext) ? "image" : "file";
+    }
+  }
+}
+function renderFilesTemplate2() {
+  return nothing2;
+}
+function registerFileTreeDnD2(_ctx) {}
+var FILE_ROW_HEIGHT = 24;
+var _fileRows = [];
+var _fileList = null;
+var _fileRowEls = new Map;
+var _fileWatch = null;
+var _filesRerender = null;
+function fileRowHeight() {
+  for (const el of _fileRowEls.values()) {
+    if (el.isConnected && el.offsetHeight > 0) {
+      return el.offsetHeight;
+    }
+  }
+  return FILE_ROW_HEIGHT;
+}
+function sweepRowElements() {
+  for (const [path, el] of _fileRowEls) {
+    if (!el.isConnected) {
+      _fileRowEls.delete(path);
+      releaseRowDnD(el);
+    }
+  }
+}
+function fileRowElement(path) {
+  const el = _fileRowEls.get(path);
+  return el?.isConnected === true ? el : null;
+}
+function fileRowAt(path) {
+  return _fileRows.find((row) => !row.loading && row.path === path);
+}
+function collectFileRows(dirPath, depth, rows, i18n) {
+  const entries = requireProjectState().dirs.get(dirPath);
+  if (!entries) {
+    loadDirectory2(dirPath).then(() => repaintFiles());
+    rows.push({
+      depth,
+      expanded: false,
+      key: `loading:${dirPath}`,
+      loading: true,
+      name: "Loading…",
+      path: dirPath,
+      posInSet: 1,
+      setSize: 1,
+      type: "file"
+    });
+    return;
+  }
+  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 visible = showIgnoredFiles() ? sorted : sorted.filter((e) => !isIgnoredEntry(dirPath, e.path, e.type === "directory"));
+  const query = requireProjectState().searchQuery.toLowerCase();
+  const filtered = query ? visible.filter((e) => e.type === "directory" || e.name.toLowerCase().includes(query)) : visible;
+  for (const [index, entry] of filtered.entries()) {
+    const isDir = entry.type === "directory";
+    const isExpanded = isDir && requireProjectState().expanded.has(entry.path);
+    rows.push({
+      depth,
+      expanded: isExpanded,
+      key: entry.path,
+      loading: false,
+      name: entry.name,
+      path: entry.path,
+      locale: localeOfPath(entry.path, i18n) ?? undefined,
+      posInSet: index + 1,
+      setSize: filtered.length,
+      type: entry.type
+    });
+    if (isExpanded) {
+      collectFileRows(entry.path, depth + 1, rows, i18n);
+    }
+  }
+}
+function fileIndexOfPath(path) {
+  return path === undefined ? -1 : _fileRows.findIndex((row) => !row.loading && row.path === path);
+}
+function fileStep(index, step) {
+  for (let i = index + step;i >= 0 && i < _fileRows.length; i += step) {
+    if (!_fileRows[i].loading) {
+      return i;
+    }
+  }
+  return -1;
+}
+function fileParentIndex(index) {
+  const row = _fileRows[index];
+  if (!row) {
+    return -1;
+  }
+  for (let i = index - 1;i >= 0; i--) {
+    const above = _fileRows[i];
+    if (!above.loading && above.depth < row.depth) {
+      return i;
+    }
+  }
+  return -1;
+}
+function fileWindowChanged() {
+  if (_fileList?.isConnected !== true || _dragPath !== "") {
+    return;
+  }
+  queueMicrotask(repaintFiles);
+}
+function adoptFileTree() {
+  const tree = _fileList;
+  if (tree === null) {
+    return;
+  }
+  _fileWatch = watchListWindow(_fileWatch, tree, {
+    count: () => _fileRows.length,
+    onChange: fileWindowChanged,
+    rowHeight: fileRowHeight
+  });
+}
+function fileRowView(row) {
+  const level = String(row.depth + 1);
+  if (row.loading) {
+    return {
+      ariaExpanded: "",
+      depth: String(row.depth),
+      icon: "",
+      key: row.key,
+      kind: "loading",
+      level,
+      locale: "",
+      localeState: "hidden",
+      name: row.name,
+      path: row.path,
+      posInSet: "",
+      setSize: "",
+      type: row.type
+    };
+  }
+  const isDir = row.type === "directory";
+  return {
+    ariaExpanded: isDir ? String(row.expanded) : "",
+    depth: String(row.depth),
+    icon: fileIconName(row.path, row.type, row.expanded),
+    key: row.key,
+    kind: "item",
+    level,
+    locale: row.locale === undefined ? "" : localeLabel(row.locale),
+    localeState: row.locale === undefined ? "hidden" : "shown",
+    name: row.name,
+    path: row.path,
+    posInSet: String(row.posInSet),
+    setSize: String(row.setSize),
+    type: row.type
+  };
+}
+function filesPanelValues() {
+  sweepRowElements();
+  if (!projectState) {
+    _fileRows = [];
+    const values = { ...emptyFilesPanelValues(), view: "none" };
+    _lastValues = values;
+    return values;
+  }
+  if (!projectState.isSiteProject && projectState.projectRoot === ".") {
+    _fileRows = [];
+    const values = { ...emptyFilesPanelValues(), view: "welcome" };
+    _lastValues = values;
+    return values;
+  }
+  const state = requireProjectState();
+  _fileRows = [];
+  const { i18n } = resolveI18n(state.projectConfig ?? {});
+  collectFileRows(".", 0, _fileRows, i18n);
+  const range = listWindow(_fileList, { count: _fileRows.length, rowHeight: fileRowHeight() });
+  const drawn = _fileRows.slice(range.start, range.end);
+  const caret = (state.selectedPath !== null && fileRowAt(state.selectedPath) ? state.selectedPath : "") || drawn.find((row) => !row.loading)?.path || "";
+  const showingIgnored = showIgnoredFiles();
+  const values = {
+    currentPath: caret,
+    dragPath: _dragPath,
+    dropPath: _dropPath,
+    headerState: state.isSiteProject ? "shown" : "hidden",
+    ignoredIcon: showingIgnored ? "eye" : "eye-slash",
+    ignoredLabel: showingIgnored ? "Hide ignored files" : "Show ignored files",
+    ignoredSelected: showingIgnored,
+    padBottom: range.padBottom,
+    padTop: range.padTop,
+    projectName: state.projectConfig?.name || state.name,
+    query: state.searchQuery,
+    rootDrop: _rootDrop,
+    rows: drawn.map((row) => fileRowView(row)),
+    selectedPath: state.selectedPath ?? "",
+    view: "tree"
+  };
+  _lastValues = values;
+  return values;
+}
+function syncFilesDragState() {
+  if (!_standingFiles || !_lastValues) {
+    return;
+  }
+  _lastValues = {
+    ..._lastValues,
+    dragPath: _dragPath,
+    dropPath: _dropPath,
+    rootDrop: _rootDrop
+  };
+  _standingFiles.handle.update(_lastValues);
+}
+function repaintFiles() {
+  _filesRerender?.();
+}
+async function refreshFileTree() {
+  const state = requireProjectState();
+  state.dirs.clear();
+  resetIgnoreCache();
+  await loadDirectory2(".");
+  for (const dir of state.expanded) {
+    await loadDirectory2(dir);
+  }
+  repaintFiles();
+}
+function activateFileRow(path) {
+  const row = fileRowAt(path);
+  if (!row) {
+    return;
+  }
+  if (row.type === "directory") {
+    toggleTreeDirectory(path).then(() => repaintFiles());
+    return;
+  }
+  openFileInTab2(path);
+}
+function expandFileRow(path, expanded) {
+  const state = requireProjectState();
+  if (fileRowAt(path)?.type !== "directory" || state.expanded.has(path) === expanded) {
+    return;
+  }
+  if (!expanded) {
+    state.expanded.delete(path);
+    repaintFiles();
+    return;
+  }
+  toggleTreeDirectory(path).then(() => repaintFiles());
+}
+function selectFileRow(path) {
+  if (!projectState || requireProjectState().selectedPath === path) {
+    return;
+  }
+  requireProjectState().selectedPath = path;
+  repaintFiles();
+}
+function moveFileCaret(from, key) {
+  const index = fileIndexOfPath(from);
+  let target;
+  switch (key) {
+    case "Home": {
+      target = fileStep(-1, 1);
+      break;
+    }
+    case "End": {
+      target = fileStep(_fileRows.length, -1);
+      break;
+    }
+    case "ArrowUp": {
+      target = fileStep(index, -1);
+      break;
+    }
+    case "ArrowLeft": {
+      target = fileParentIndex(index);
+      break;
+    }
+    case "ArrowDown":
+    case "ArrowRight": {
+      target = fileStep(index, 1);
+      break;
+    }
+    default: {
+      return;
+    }
+  }
+  focusFileRow(target);
+}
+function typeaheadFileCaret(from, char) {
+  const start = fileIndexOfPath(from);
+  const total = _fileRows.length;
+  for (let step = 1;step <= total; step++) {
+    const at = (start + step + total) % total;
+    const row = _fileRows[at];
+    if (row && !row.loading && row.name.trim().toLowerCase().startsWith(char)) {
+      focusFileRow(at);
+      return;
+    }
+  }
+}
+function focusFileRow(index) {
+  const row = _fileRows[index];
+  if (!row) {
+    return;
+  }
+  selectFileRow(row.path);
+  if (fileRowElement(row.path)) {
+    return;
+  }
+  revealListRow(_fileList, index, fileRowHeight());
+  repaintFiles();
+}
+async function toggleTreeDirectory(path) {
+  const state = requireProjectState();
+  if (state.expanded.has(path)) {
+    state.expanded.delete(path);
+    return;
+  }
+  state.expanded.add(path);
+  if (!state.dirs.has(path)) {
+    await loadDirectory2(path);
+  }
+}
+var _rowDnd = new Map;
+var _treeDnd = null;
+var _dragPath = "";
+var _overRow = "";
+var _dropPath = "";
+var _overRoot = false;
+var _rootDrop = "";
+function isFileDrag(e) {
+  return [...e.dataTransfer?.types ?? []].includes("Files");
+}
+function registerFileDropTarget(element, dir, setActive) {
+  const onDragOver = (e) => {
+    if (!isFileDrag(e)) {
+      return;
+    }
+    e.preventDefault();
+    e.stopPropagation();
+    if (e.dataTransfer) {
+      e.dataTransfer.dropEffect = "copy";
+    }
+    setActive(true);
+  };
+  const onDragLeave = () => setActive(false);
+  const onDrop = (e) => {
+    setActive(false);
+    const files = e.dataTransfer?.files;
+    if (!files?.length) {
+      return;
+    }
+    e.preventDefault();
+    e.stopPropagation();
+    uploadFilesToDir(files, dir, repaintFiles);
+  };
+  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);
+  };
+}
+function canMoveInto(srcPath, targetDir) {
+  const src = srcPath.replaceAll("\\", "/");
+  const dir = targetDir.replaceAll("\\", "/");
+  if (!src || src === dir) {
+    return false;
+  }
+  if (src.startsWith(`${dir}/`) || dir.startsWith(`${src}/`)) {
+    return false;
+  }
+  return parentDir(src) !== dir;
+}
+function acceptsDrop(srcPath, targetPath, targetType) {
+  return targetType === "directory" && typeof srcPath === "string" && canMoveInto(srcPath, targetPath);
+}
+function setRowUnderDrag(row, accepted) {
+  const dropPath = accepted ? row : "";
+  if (_overRow === row && _dropPath === dropPath) {
+    return;
+  }
+  _overRow = row;
+  _dropPath = dropPath;
+  syncRootDrop();
+}
+function setRootUnderDrag(active) {
+  if (_overRoot === active) {
+    return;
+  }
+  _overRoot = active;
+  syncRootDrop();
+}
+function syncRootDrop() {
+  _rootDrop = _overRoot && _overRow === "" ? "true" : "";
+  syncFilesDragState();
+}
+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 = uploadAccept();
+  input.addEventListener("change", () => {
+    if (input.files?.length) {
+      uploadFilesToDir(input.files, dir, renderLeftPanel);
+    }
+  });
+  input.click();
+}
+function adoptFileRow(element, path, type) {
+  releaseRowDnD(element);
+  _fileRowEls.set(path, element);
+  const cleanups = [
+    draggable2({
+      element,
+      getInitialData() {
+        return { entryType: type, path, type: "file-tree" };
+      },
+      onDragStart() {
+        _dragPath = path;
+        syncFilesDragState();
+      },
+      onDrop() {
+        _dragPath = "";
+        setRowUnderDrag("", false);
+        syncFilesDragState();
+      }
+    }),
+    registerFileDropTarget(element, type === "directory" ? path : parentDir(path), (active) => {
+      setRowUnderDrag(active ? path : "", active);
+    }),
+    dropTargetForElements2({
+      canDrop({ source }) {
+        return source.data.type === "file-tree";
+      },
+      element,
+      getData({ source }) {
+        return acceptsDrop(source.data.path, path, type) ? { targetDir: path, type: "file-tree-target" } : { type: "file-tree-refused" };
+      },
+      onDrag({ source }) {
+        setRowUnderDrag(path, acceptsDrop(source.data.path, path, type));
+      },
+      onDragEnter({ source }) {
+        setRowUnderDrag(path, acceptsDrop(source.data.path, path, type));
+      },
+      onDragLeave() {
+        setRowUnderDrag("", false);
+      },
+      onDrop() {
+        setRowUnderDrag("", false);
+      }
+    })
+  ];
+  _rowDnd.set(element, combine(...cleanups));
+}
+function releaseRowDnD(element) {
+  const cleanup = _rowDnd.get(element);
+  if (cleanup) {
+    cleanup();
+    _rowDnd.delete(element);
+  }
+}
+function adoptFileTreeElement(element) {
+  if (_treeDnd?.element === element) {
+    return;
+  }
+  releaseFileTreeDnD();
+  _fileList = element;
+  const rootCleanup = dropTargetForElements2({
+    canDrop({ source }) {
+      return source.data.type === "file-tree" && canMoveInto(source.data.path, ".");
+    },
+    element,
+    getData() {
+      return { targetDir: ".", type: "file-tree-target" };
+    },
+    onDragEnter() {
+      setRootUnderDrag(true);
+    },
+    onDragLeave() {
+      setRootUnderDrag(false);
+    },
+    onDrop() {
+      setRootUnderDrag(false);
+    }
+  });
+  const monitorCleanup = monitorForElements2({
+    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;
+      if (!canMoveInto(srcPath, targetDirPath)) {
+        return;
+      }
+      const fileName = srcPath.split("/").pop();
+      const newPath = targetDirPath === "." ? fileName : `${targetDirPath}/${fileName}`;
+      moveFileEntry(srcPath, newPath, repaintFiles);
+    }
+  });
+  _treeDnd = {
+    cleanup: combine(rootCleanup, monitorCleanup, registerFileDropTarget(element, ".", setRootUnderDrag)),
+    element
+  };
+  adoptFileTree();
+}
+function releaseFileTreeDnD() {
+  _treeDnd?.cleanup();
+  _treeDnd = null;
+  for (const cleanup of _rowDnd.values()) {
+    cleanup();
+  }
+  _rowDnd.clear();
+  _fileWatch?.window.destroy();
+  _fileWatch = null;
+  _fileList = null;
+  _dragPath = "";
+  _overRow = "";
+  _dropPath = "";
+  _overRoot = false;
+  _rootDrop = "";
+}
+async function moveFileEntry(oldPath, newPath, renderLeftPanel) {
+  const platform = getPlatform2();
+  markLocalMutation2(oldPath, newPath);
+  try {
+    const report = await platform.renameFile(oldPath, newPath);
+    invalidateUsages2();
+    for (const [id] of workspace2.tabs.entries()) {
+      if (id === oldPath) {
+        renameTab2(oldPath, newPath, newPath);
+      } else if (id.startsWith(`${oldPath}/`)) {
+        const newTabPath = newPath + id.slice(oldPath.length);
+        renameTab2(id, newTabPath, newTabPath);
+      }
+    }
+    const oldParent = parentDir(oldPath);
+    const newParent = parentDir(newPath);
+    await loadDirectory2(oldParent);
+    if (newParent !== oldParent) {
+      await loadDirectory2(newParent);
+    }
+    if (newParent !== ".") {
+      requireProjectState().expanded.add(newParent);
+    }
+    reloadRewrittenTabs(report, newPath);
+    renderLeftPanel();
+    notifyMoveOutcome2(`Moved to ${newPath}`, report, newPath);
+  } catch (error) {
+    notify2.error(`Could not move ${oldPath}.`, {
+      detail: errorMessage2(error),
+      path: oldPath,
+      source: "Files"
+    });
+  }
+}
+function parentDir(path) {
+  const normalized = path.replaceAll("\\", "/");
+  const lastSlash = normalized.lastIndexOf("/");
+  return lastSlash === -1 ? "." : normalized.slice(0, lastSlash);
+}
+var _fileMenu = null;
+function dismissFileContextMenu() {
+  _fileMenu?.close();
+  _fileMenu = null;
+}
+function fileRowFacts(entry) {
+  const facts = {};
+  if (entry.type === "directory") {
+    const collection = collectionForDirectory(entry.path);
+    if (collection?.isSourceRoot === true && !collection.fileBacked) {
+      facts.name = collection.name;
+    }
+    return facts;
+  }
+  if (collectionOfPath(entry.path)) {
+    facts.path = entry.path;
+  }
+  if (convertTargets(entry.path).length > 0) {
+    facts.source = entry.path;
+  }
+  return facts;
+}
+function treeMenuRow(id, title, run, extra = {}) {
+  return { destructive: false, disabled: false, dividerAbove: false, id, run, title, ...extra };
+}
+function placedFileRows(entry) {
+  const registry = activeRegistry();
+  if (!registry) {
+    return [];
+  }
+  const facts = fileRowFacts(entry);
+  const rows = [];
+  for (const command of registry.forPlacement("context/file")) {
+    const schema = command.args;
+    if (!(schema?.required ?? []).every((key) => (key in facts))) {
+      continue;
+    }
+    const args = {};
+    for (const key of Object.keys(schema?.properties ?? {})) {
+      if (key in facts) {
+        args[key] = facts[key];
+      }
+    }
+    const reason = registry.disabledReason(command.id);
+    rows.push(reason === undefined ? treeMenuRow(command.id, command.title, () => {
+      runReported(registry, command.id, args, "Files");
+    }) : {
+      destructive: false,
+      disabled: true,
+      dividerAbove: false,
+      id: command.id,
+      requires: reason,
+      title: command.title
+    });
+  }
+  return rows;
+}
+function fileMenuRows(entry) {
+  const isDir = entry.type === "directory";
+  const rows = [];
+  if (isDir) {
+    rows.push(treeMenuRow("files.newFile", "New File…", () => {
+      createNewFile(entry.path, repaintFiles);
+    }), treeMenuRow("files.upload", "Upload Files…", () => {
+      pickAndUploadTo(entry.path, repaintFiles);
+    }));
+    if (entry.path === "pages" || entry.path.endsWith("/pages")) {
+      rows.push(treeMenuRow("files.pagesGrid", "Edit Pages in Grid", () => {
+        openPagesGrid();
+      }));
+    }
+  } else {
+    rows.push(treeMenuRow("files.open", "Open", () => {
+      openFileInTab2(entry.path);
+    }));
+  }
+  rows.push(...placedFileRows(entry), treeMenuRow("files.rename", "Rename…", () => {
+    renameFile(entry, repaintFiles);
+  }, { dividerAbove: true }), treeMenuRow("files.delete", "Delete", () => {
+    deleteFile(entry, repaintFiles);
+  }, { destructive: true }));
+  return rows;
+}
+function showFileContextMenu(path, x, y) {
+  const row = fileRowAt(path);
+  if (!row) {
+    return;
+  }
+  dismissFileContextMenu();
+  const opener = fileRowElement(path);
+  _fileMenu = openMenu2({
+    label: "File actions",
+    onClosed: (handle) => {
+      if (_fileMenu === handle) {
+        _fileMenu = null;
+      }
+    },
+    opener,
+    origin: { x, y },
+    region: "files",
+    rows: fileMenuRows({ name: row.name, path: row.path, type: row.type })
+  });
+}
+var BLANK_DOCUMENT = JSON.stringify({ children: [{ children: [], tagName: "p" }], tagName: "div" }, null, 2);
+var OTHER_FORMAT = "__other__";
+function slugify(input) {
+  return input.trim().toLowerCase().replaceAll(/\s+/g, "-").replaceAll(/[^a-z\d-]/g, "");
+}
+function extensionOfName(name) {
+  const dot = name.lastIndexOf(".");
+  return dot > 0 ? name.slice(dot) : "";
+}
+function formatRowsFor(choice) {
+  const rows = choice.kind === "locked" ? [
+    {
+      ext: choice.ext,
+      label: `${formatByExtension2(choice.ext)?.name ?? choice.ext} (${choice.ext})`
+    }
+  ] : creationFormats(choice.docKind);
+  return [
+    ...rows.map((row) => ({ label: row.label, value: row.ext })),
+    { dividerBefore: true, label: "Other…", value: OTHER_FORMAT }
+  ];
+}
+function initialPickFor(choice, rows, suggested) {
+  const stated = choice.kind === "choose" ? choice.defaultExt : choice.ext;
+  if (stated !== undefined && rows.some((row) => row.value === stated)) {
+    return stated;
+  }
+  const fromPrefill = extensionOfName(suggested);
+  if (fromPrefill !== "" && rows.some((row) => row.value === fromPrefill)) {
+    return fromPrefill;
+  }
+  return rows[0]?.value ?? OTHER_FORMAT;
+}
+async function createFileIn2(request) {
+  const { dir, format: choice, source = "Files" } = request;
+  await loadFormats2();
+  let taken = new Set;
+  try {
+    const listing = await getPlatform2().listDirectory(dir);
+    taken = new Set(listing.map((entry) => entry.name.toLowerCase()));
+  } catch {}
+  const picker = choice !== undefined && choice.kind !== "fixed" ? choice : null;
+  const rows = picker === null ? null : formatRowsFor(picker);
+  const initialPick = picker === null || rows === null ? "" : initialPickFor(picker, rows, request.suggestedName ?? "");
+  const fileNameFor = (input, picked) => {
+    const trimmed = input.trim();
+    if (choice === undefined || picked === OTHER_FORMAT) {
+      return trimmed;
+    }
+    if (choice.kind === "fixed") {
+      const slug = slugify(trimmed);
+      return slug === "" ? "" : `${slug}${choice.ext}`;
+    }
+    return trimmed.toLowerCase().endsWith(picked.toLowerCase()) ? trimmed : `${trimmed}${picked}`;
+  };
+  const known = knownDocumentExtensions();
+  const validate = (value, picked) => {
+    const trimmed = value.trim();
+    if (!trimmed) {
+      return choice?.kind === "fixed" ? "Enter a name." : "Enter a file name.";
+    }
+    if (choice?.kind === "fixed" && slugify(trimmed) === "") {
+      return "Enter at least one letter or number.";
+    }
+    const normalized = trimmed.replaceAll("\\", "/");
+    if (normalized.startsWith("/") || normalized.endsWith("/")) {
+      return "Enter a name, not a path that starts or ends with a slash.";
+    }
+    if (normalized.split("/").includes("..")) {
+      return "A name cannot step outside the destination folder.";
+    }
+    if (normalized.includes("/") && choice !== undefined && picked !== OTHER_FORMAT) {
+      return `Pick Other… to create a file in a subfolder of ${dir === "." ? "the project root" : dir}.`;
+    }
+    const typedExt = extensionOfName(normalized);
+    if (picked !== "" && picked !== OTHER_FORMAT && typedExt !== "" && typedExt.toLowerCase() !== picked.toLowerCase() && known.has(typedExt.toLowerCase())) {
+      const label = rows?.find((row) => row.value === picked)?.label ?? picked;
+      return `You picked ${label}; this name ends in ${typedExt}.`;
+    }
+    if (choice?.kind === "locked" && picked === OTHER_FORMAT) {
+      const foreign = typedExt !== "" && typedExt.toLowerCase() !== choice.ext.toLowerCase();
+      if (foreign && known.has(typedExt.toLowerCase())) {
+        return choice.because;
+      }
+    }
+    const candidate = fileNameFor(value, picked);
+    return taken.has(candidate.toLowerCase()) ? `${candidate} already exists in ${dir}/.` : "";
+  };
+  let picked = initialPick;
+  const entered = await showPromptDialog2(request.title ?? "New File", {
+    ...rows === null ? {} : {
+      choice: {
+        initial: initialPick,
+        label: "Format",
+        onChange: (next) => {
+          picked = next;
+        },
+        options: () => rows
+      }
+    },
+    confirmLabel: "Create",
+    message: dir === "." ? "Creating in the project root." : `Creating in ${dir}/`,
+    ...request.suggestedName === undefined ? {} : { placeholder: request.suggestedName },
+    select: rows === null ? "stem" : "all",
+    validate,
+    value: request.suggestedName ?? "untitled.json"
+  });
+  if (!entered) {
+    return null;
+  }
+  const fileName = fileNameFor(entered, picked);
+  const path = dir === "." ? fileName : `${dir}/${fileName}`;
+  markLocalMutation2(path);
+  const format = formatForPath2(fileName);
+  const suppliedBody = typeof request.content === "function" ? await request.content(extensionOfName(fileName), fileName) : request.content;
+  const chosenAsDocument = choice !== undefined && picked !== OTHER_FORMAT;
+  const content = suppliedBody ?? format?.studio?.newFileTemplate ?? (format ? "" : fileName.toLowerCase().endsWith(".json") ? chosenAsDocument ? BLANK_DOCUMENT : `{}
+` : "");
+  try {
+    await getPlatform2().writeFile(path, content);
+    await loadDirectory2(dir);
+    notify2.success(`Created ${path}`);
+    return path;
+  } catch (error) {
+    notify2.error(`Could not create ${path}.`, {
+      detail: errorMessage2(error),
+      path,
+      source
+    });
+    return null;
+  }
+}
+async function createNewFile(dirPath, renderLeftPanel) {
+  await loadFormats2();
+  const collection = collectionForDirectory(dirPath);
+  if (collection?.unresolvedFormat != null) {
+    notify2.error(`New files in ${dirPath}/ cannot be constrained to the collection's format.`, {
+      detail: `The "${collection.name}" content type declares format "${collection.unresolvedFormat}", ` + "which no installed extension provides. Install the extension that supplies it, or correct " + "the name in Project Settings › Content Types.",
+      path: dirPath,
+      source: "Files"
+    });
+  }
+  const constrained = collection?.ext != null && collection.unresolvedFormat === null;
+  const seedable = constrained && collection.isSourceRoot && collection.def.schema !== undefined;
+  let created;
+  if (seedable) {
+    const { createEntry } = await (__preload("234hjnqw"), import("./entry-commands-234hjnqw.js"));
+    created = await createEntry(collection.name, { dir: dirPath });
+  } else {
+    created = await createFileIn2({
+      dir: dirPath,
+      format: constrained && collection.ext !== null ? {
+        because: `${collection.name} entries are ${collection.ext} files, so a document of another format here would not be one.`,
+        ext: collection.ext,
+        kind: "locked"
+      } : { defaultExt: ".json", kind: "choose" },
+      suggestedName: "untitled"
+    });
+  }
+  if (created !== null) {
+    renderLeftPanel();
+  }
+}
+async function showRenameFileDialog(currentName, path) {
+  const message = await renamePromptMessage2(path);
+  return showPromptDialog2("Rename", {
+    confirmLabel: "Rename",
+    ...message === undefined ? {} : { message },
+    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 notifyMoveOutcome2(headline, report, path) {
+  const stuck = report.errors ?? [];
+  if (stuck.length === 0) {
+    notify2.success(headline);
+    return;
+  }
+  const files = stuck.length === 1 ? "1 file" : `${stuck.length} files`;
+  notify2.warn(`${headline} — references in ${files} could not be updated`, {
+    detail: stuck.map((e) => `${e.path}: ${e.error}`).join(`
+`),
+    path,
+    source: "Files"
+  });
+}
+function reloadRewrittenTabs(report, skipPath) {
+  for (const f of report.references?.files ?? []) {
+    if (f.path !== skipPath && workspace2.tabs.has(f.path)) {
+      reloadFileInTab2(f.path);
+    }
+  }
+}
+function parentDirOf(path) {
+  const normalized = path.replaceAll("\\", "/");
+  return normalized.includes("/") ? normalized.slice(0, normalized.lastIndexOf("/")) : ".";
+}
+async function settleRename2(from, to, report) {
+  invalidateUsages2();
+  const fromDir = parentDirOf(from);
+  const toDir = parentDirOf(to);
+  await loadDirectory2(fromDir);
+  if (toDir !== fromDir) {
+    await loadDirectory2(toDir);
+  }
+  if (requireProjectState().selectedPath === from) {
+    requireProjectState().selectedPath = to;
+  }
+  reloadRewrittenTabs(report, to);
+}
+async function renameFile(entry, renderLeftPanel) {
+  const newName = await showRenameFileDialog(entry.name, entry.path);
+  if (!newName || newName === entry.name) {
+    return;
+  }
+  const parentDirPath = parentDirOf(entry.path);
+  const newPath = parentDirPath === "." ? newName : `${parentDirPath}/${newName}`;
+  markLocalMutation2(entry.path, newPath);
+  try {
+    const platform = getPlatform2();
+    const report = await platform.renameFile(entry.path, newPath);
+    if (workspace2.tabs.has(entry.path)) {
+      renameTab2(entry.path, newPath, newPath);
+    }
+    await settleRename2(entry.path, newPath, report);
+    renderLeftPanel();
+    notifyMoveOutcome2(renameStatus(newName, report), report, newPath);
+  } catch (error) {
+    notify2.error(`Could not rename ${entry.name}.`, {
+      detail: errorMessage2(error),
+      path: entry.path,
+      source: "Files"
+    });
+  }
+}
+async function deleteFile(entry, renderLeftPanel) {
+  const confirmed = await confirmFileDelete2(entry);
+  if (!confirmed) {
+    return;
+  }
+  try {
+    const platform = getPlatform2();
+    markLocalMutation2(entry.path);
+    await platform.deleteFile(entry.path);
+    invalidateUsages2();
+    const delPath = entry.path.replaceAll("\\", "/");
+    const parentDirPath = delPath.includes("/") ? delPath.slice(0, delPath.lastIndexOf("/")) : ".";
+    await loadDirectory2(parentDirPath);
+    if (requireProjectState().selectedPath === entry.path) {
+      requireProjectState().selectedPath = null;
+    }
+    renderLeftPanel();
+    notify2.success(`Deleted ${entry.name}`);
+  } catch (error) {
+    notify2.error(`Could not delete ${entry.name}.`, {
+      detail: errorMessage2(error),
+      path: entry.path,
+      source: "Files"
+    });
+  }
+}
+function revealOpenTab(tabId, opts) {
+  const wanted = opts.paneId;
+  const holder = paneOfTab2(tabId);
+  if (wanted !== undefined && holder && holder.id !== wanted) {
+    if (holder.activeTabId === tabId) {
+      return;
+    }
+    moveTabToPane2(tabId, wanted);
+  }
+  activateTab2(tabId, { focus: opts.focus !== false });
+}
+async function openFileInTab2(path, opts = {}) {
+  const follows = opts.focus !== false;
+  for (const [id, tab] of workspace2.tabs.entries()) {
+    if (tab.documentPath === path) {
+      revealOpenTab(id, opts);
+      if (follows) {
+        requireProjectState().selectedPath = path;
+      }
+      return;
+    }
+  }
+  if (isViewableMedia(path)) {
+    openMediaTab(path);
+    if (follows) {
+      requireProjectState().selectedPath = path;
+    }
+    trackRecentFile({
+      name: path.split("/").pop() || path,
+      path,
+      root: requireProjectState().projectRoot
+    });
+    return;
+  }
+  if (path.toLowerCase().endsWith(".csv")) {
+    try {
+      await openCsvGridTab(path);
+      requireProjectState().selectedPath = path;
+      trackRecentFile({
+        name: path.split("/").pop() || path,
+        path,
+        root: requireProjectState().projectRoot
+      });
+    } catch (error) {
+      notify2.error(`Could not open ${path}.`, {
+        detail: errorMessage2(error),
+        path,
+        source: "Open File"
+      });
+    }
+    return;
+  }
+  const platform = getPlatform2();
+  try {
+    const content = await platform.readFile(path);
+    if (!content) {
+      await loadFormats2();
+      if (!formatForPath2(path) && !path.toLowerCase().endsWith(".json")) {
+        throw noFormatError2(path);
+      }
+      return;
+    }
+    await loadFormats2();
+    let document2;
+    let frontmatter;
+    let layout = null;
+    const format = formatForPath2(path);
+    if (format) {
+      const result = await parseSourceForPath2(path, content);
+      ({ document: document2 } = result);
+      ({ frontmatter } = result);
+    } else if (path.endsWith(".json")) {
+      ({ document: document2, layout } = parseJsonDocument(content));
+    } else {
+      throw noFormatError2(path);
+    }
+    const id = path;
+    openTab2({
+      id,
+      documentPath: path,
+      document: document2,
+      ...frontmatter != null && { frontmatter },
+      layout,
+      sourceFormat: format?.name ?? null,
+      ...opts.paneId !== undefined && { paneId: opts.paneId },
+      ...opts.preview === true && { preview: true },
+      ...opts.focus === false && { focus: false }
+    });
+    if (follows) {
+      requireProjectState().selectedPath = path;
+    }
+    trackRecentFile({
+      name: path.split("/").pop() || path,
+      path,
+      root: requireProjectState().projectRoot
+    });
+  } catch (error) {
+    notify2.error(`Could not open ${path}.`, {
+      detail: errorMessage2(error),
+      path,
+      source: "Open File"
+    });
+  }
+}
+async function openFileInPane2(paneId, path) {
+  await openFileInTab2(path, { focus: false, paneId, preview: true });
+}
+function reloadCleanTab2(path) {
+  if (isCollabPath(path)) {
+    return;
+  }
+  for (const [, tab] of workspace2.tabs.entries()) {
+    if (tab.documentPath === path && !tab.doc.dirty) {
+      reloadFileInTab2(path);
+      return;
+    }
+  }
+}
+async function reloadFileInTab2(path) {
+  for (const [, tab] of workspace2.tabs.entries()) {
+    if (tab.documentPath === path) {
+      const platform = getPlatform2();
+      try {
+        const content = await platform.readFile(path);
+        if (!content) {
+          return;
+        }
+        await loadFormats2();
+        if (formatForPath2(path)) {
+          const { document: document2, frontmatter } = await parseSourceForPath2(path, content);
+          tab.doc.document = document2;
+          tab.doc.content.frontmatter = frontmatter;
+        } else if (path.endsWith(".json")) {
+          const parsed = parseJsonDocument(content);
+          tab.doc.document = parsed.document;
+          tab.doc.layout = parsed.layout;
+        }
+        tab.doc.dirty = false;
+      } catch (error) {
+        notify2.error(`Could not reload ${path} after it changed on disk.`, {
+          detail: errorMessage2(error),
+          key: `reload:${path}`,
+          path,
+          source: "Files"
+        });
+      }
+      return;
+    }
+  }
+}
+function registerFilesPanel2() {
+  registerPanel({
+    id: "files",
+    title: "Files",
+    level: "project",
+    dock: "navigator",
+    icon: "folder",
+    render: () => nothing2,
+    afterRender: (ctx, host) => {
+      mountFilesPanel(host, ctx.rerender);
+    }
+  });
+}
+var FILE_ACTIONS = {
+  activate: activateFileRow,
+  contextMenu: showFileContextMenu,
+  expand: expandFileRow,
+  move: moveFileCaret,
+  newFile: () => {
+    createNewFile(".", repaintFiles);
+  },
+  openProject: () => {
+    runActiveReported("project.open", undefined, "Files");
+  },
+  refresh: () => {
+    refreshFileTree();
+  },
+  rowHost: adoptFileRow,
+  search: (value) => {
+    requireProjectState().searchQuery = value;
+    repaintFiles();
+  },
+  select: selectFileRow,
+  toggleIgnored: () => {
+    setShowIgnoredFiles(!showIgnoredFiles());
+    repaintFiles();
+  },
+  treeHost: adoptFileTreeElement,
+  typeahead: typeaheadFileCaret
+};
+var _standingFiles = null;
+var _lastValues = null;
+function mountFilesPanel(host, rerender) {
+  const container = host.querySelector(".panel-content") ?? host;
+  _filesRerender = rerender;
+  if (_standingFiles && (_standingFiles.host !== container || !_standingFiles.handle.connected())) {
+    unmountFilesPanel();
+  }
+  const values = filesPanelValues();
+  if (_standingFiles) {
+    _standingFiles.handle.update(values);
+  } else {
+    const handle = mountFilesPanelSurface(container, values, FILE_ACTIONS);
+    _standingFiles = { handle, host: container };
+    handle.ready.then(adoptFileTree);
+  }
+  queueMicrotask(adoptFileTree);
+}
+function unmountFilesPanel() {
+  dismissFileContextMenu();
+  _standingFiles?.handle.dispose();
+  _standingFiles = null;
+  _lastValues = null;
+  releaseFileTreeDnD();
+  _fileRowEls.clear();
+  _fileRows = [];
+}
+
+export { ensureDependenciesInstalled, convertTargets, convertTargetExtensions, hydrateRecentProjects, getRecentProjects, addRecentProject, removeRecentProject, clearRecentProjects, getRecentFiles, trackRecentFile, loadDirectory2, loadProject2, openProject2, initProjectRepo2, findHomePage2, openLastSessionOrHome2, renderFilesTemplate2, registerFileTreeDnD2, createFileIn2, notifyMoveOutcome2, settleRename2, openFileInTab2, openFileInPane2, reloadCleanTab2, reloadFileInTab2, registerFilesPanel2 };
+
+//# debugId=E1EE7183DAEAEF7C64756E2164756E21
+//# sourceMappingURL=studio-b0k5tqgp.js.map