@jxsuite/studio 4.0.0 → 5.0.0

package/dist/chunks/studio-5rt7sqa0.js

@@ -0,0 +1,1168 @@
+import {
+  getPlatform2
+} from "./studio-6nzaktvy.js";
+import {
+  flattenTree,
+  nodeLabel,
+  projectState
+} from "./studio-6ewqv390.js";
+import {
+  loadFormats2,
+  formatByExtension2,
+  documentExtensions2
+} from "./studio-79y5sz51.js";
+import {
+  activeTab2
+} from "./studio-az3zd49t.js";
+import {
+  registerSurface,
+  mountSurface,
+  getLayerSlot2
+} from "./studio-erdatzvp.js";
+import {
+  activeRegistry
+} from "./studio-5jy81t3s.js";
+import {
+  reactive
+} from "./studio-p1dw8wfw.js";
+import {
+  getRecentProjects,
+  getRecentFiles,
+  trackRecentFile,
+  openFileInTab2
+} from "./studio-18avnhjp.js";
+// src/surfaces/palette.json
+var palette_default = {
+  $schema: "https://jxsuite.com/schema/v1",
+  $id: "StudioPalette",
+  $description: 'The command palette: a `role="combobox"` field over the kit\'s `jx-listbox`, whose rows are `jx-option`s the host projects. `rows` is the ranked set for the current mode and query; `activeId` is the highlight, and it is ONE string — the id the field points `aria-activedescendant` at and the id the listbox is handed as `active`, so a key moves the caret without the rows reconciling and no row re-decides its own flag. The FIELD is not a `jx-combobox`: this one carries a mode chip inside its box, its Enter runs a command rather than committing a value, and its panel is a centred scrim rather than a popover under a control. Every gesture calls back into panels/quick-search.ts, which owns the modes, the ranking, the recents and what a row does.',
+  tagName: "div",
+  attributes: {
+    part: "palette"
+  },
+  style: {
+    display: "contents",
+    '& [part="overlay"]': {
+      position: "fixed",
+      inset: "0",
+      zIndex: "1000",
+      display: "flex",
+      justifyContent: "center",
+      paddingTop: "60px",
+      background: "rgba(0, 0, 0, 0.4)"
+    },
+    '& [part="panel"]': {
+      width: "560px",
+      maxWidth: "calc(100vw - 32px)",
+      maxHeight: "420px",
+      display: "flex",
+      flexDirection: "column",
+      alignSelf: "flex-start",
+      background: "var(--jx-bg-overlay)",
+      border: "1px solid var(--jx-border)",
+      borderRadius: "var(--jx-radius-md)",
+      boxShadow: "var(--jx-shadow-dialog)",
+      color: "var(--jx-fg)",
+      fontFamily: "var(--jx-font-sans)",
+      overflow: "hidden"
+    },
+    '& [part="input-row"]': {
+      display: "flex",
+      alignItems: "center",
+      gap: "var(--jx-space-3)",
+      paddingLeft: "var(--jx-space-4)",
+      background: "var(--jx-bg-input)",
+      borderBottom: "1px solid var(--jx-border)"
+    },
+    '& [part="chip-slot"], & [part="empty-slot"], & [part="section-slot"], & [part="trailing-slot"]': {
+      display: "contents"
+    },
+    '& [part="chip"]': {
+      display: "inline-flex",
+      alignItems: "center",
+      gap: "var(--jx-space-1)",
+      flexShrink: "0",
+      padding: "2px var(--jx-space-1) 2px var(--jx-space-3)",
+      borderRadius: "var(--jx-radius-sm)",
+      background: "var(--jx-accent-solid)",
+      color: "var(--jx-accent-fg)",
+      fontSize: "var(--jx-text-sm)"
+    },
+    '& [part="chip-remove"] > [part="control"]': {
+      color: "inherit",
+      opacity: "0.8",
+      ":hover": {
+        opacity: "1",
+        background: "transparent"
+      }
+    },
+    '& [part="input"]': {
+      flex: "1",
+      minWidth: "0",
+      padding: "var(--jx-space-4) var(--jx-space-5) var(--jx-space-4) var(--jx-space-1)",
+      font: "inherit",
+      fontSize: "var(--jx-text-lg)",
+      border: "none",
+      outline: "none",
+      background: "none",
+      color: "var(--jx-fg)",
+      "::placeholder": {
+        color: "var(--jx-fg-muted)"
+      },
+      ":focus-visible": {
+        outline: "var(--jx-focus-ring)",
+        outlineOffset: "-2px"
+      }
+    },
+    '& [part="results"]': {
+      $description: "The list is the kit's: a `jx-listbox` of `jx-option`, so the highlight is ONE id — `active`, the same string the field points `aria-activedescendant` at — and the listbox's sidecar is the single writer of every row's `selected`. What this surface still decides is density. The kit's row pads itself by `--jx-space-3`; the other half of the 16px optical margin the panel has always had sits here, on the list, so the heading, the rows and the empty sentence line up on one edge instead of each naming it.",
+      flex: "1",
+      paddingInline: "var(--jx-space-3)"
+    },
+    '& [part="option"] [part="label"]': {
+      fontWeight: "500"
+    },
+    '& [part="option"] [part="description"]': {
+      $description: "A `jx-select` row's note is a category at the END of the row, so the kit pushes it there with an auto margin. A palette row's note is a CONTINUATION of its name — the file's directory, the command's category — and the far edge belongs to the chord, which is how this surface teaches the keyboard it replaced. So the auto margin moves to the end slot.",
+      marginInlineStart: "0"
+    },
+    '& [part="option"] [part="end"]': {
+      marginInlineStart: "auto"
+    },
+    '& [part="option"][aria-disabled="true"]': {
+      $description: "An unavailable command is greyed with its `requires` sentence as the subtitle, and that sentence is the reason the row is on screen at all. The kit fades the whole row to 0.45, which would take a muted grey below any readable contrast — so the row keeps its ink and only the name and the glyph dim.",
+      opacity: "1"
+    },
+    '& [part="option"][aria-disabled="true"] [part="label"], & [part="option"][aria-disabled="true"] [part="icon"]': {
+      opacity: "0.45"
+    },
+    '& [part="chord"]': {
+      flexShrink: "0",
+      fontFamily: "inherit",
+      fontSize: "var(--jx-text-xs)",
+      color: "var(--jx-fg-muted)",
+      border: "1px solid var(--jx-border)",
+      borderRadius: "var(--jx-radius-sm)",
+      padding: "0 5px"
+    },
+    '& [part="option"][aria-selected="true"] [part="chord"]': {
+      color: "inherit",
+      borderColor: "currentColor"
+    },
+    '& [part="badge"]': {
+      fontSize: "var(--jx-text-xs)",
+      padding: "1px var(--jx-space-2)",
+      borderRadius: "var(--jx-radius-sm)",
+      background: "var(--jx-border)",
+      color: "var(--jx-fg-dim)"
+    },
+    '& [part="hint"]': {
+      padding: "var(--jx-space-2) var(--jx-space-5)",
+      borderTop: "1px solid var(--jx-border)",
+      color: "var(--jx-fg-muted)",
+      fontSize: "var(--jx-text-xs)"
+    },
+    '& [part="hint"] kbd': {
+      fontFamily: "inherit",
+      color: "var(--jx-fg-dim)"
+    }
+  },
+  $switch: {
+    $ref: "#/state/open"
+  },
+  cases: {
+    true: {
+      tagName: "div",
+      attributes: {
+        part: "overlay"
+      },
+      onclick: {
+        $prototype: "Function",
+        body: [
+          {
+            operator: "call",
+            target: {
+              $ref: "#/state/close"
+            },
+            value: []
+          }
+        ]
+      },
+      children: [
+        {
+          tagName: "div",
+          attributes: {
+            part: "panel"
+          },
+          onclick: {
+            $prototype: "Function",
+            body: [
+              {
+                stopPropagation: true
+              }
+            ]
+          },
+          children: [
+            {
+              tagName: "div",
+              attributes: {
+                part: "input-row"
+              },
+              children: [
+                {
+                  tagName: "span",
+                  attributes: {
+                    part: "chip-slot",
+                    role: "none"
+                  },
+                  $switch: {
+                    $ref: "#/state/hasChip"
+                  },
+                  cases: {
+                    true: {
+                      tagName: "span",
+                      attributes: {
+                        part: "chip"
+                      },
+                      children: [
+                        {
+                          tagName: "span",
+                          attributes: {
+                            part: "chip-label"
+                          },
+                          textContent: "${state.chipLabel}"
+                        },
+                        {
+                          tagName: "jx-action-button",
+                          $props: {
+                            label: "Clear mode",
+                            hint: "Clear mode (Backspace)",
+                            icon: "x",
+                            size: "sm"
+                          },
+                          attributes: {
+                            part: "chip-remove"
+                          },
+                          onclick: {
+                            $prototype: "Function",
+                            body: [
+                              {
+                                operator: "call",
+                                target: {
+                                  $ref: "#/state/clearMode"
+                                },
+                                value: []
+                              }
+                            ]
+                          }
+                        }
+                      ]
+                    }
+                  }
+                },
+                {
+                  tagName: "input",
+                  attributes: {
+                    part: "input",
+                    type: "text",
+                    role: "combobox",
+                    "aria-controls": "quick-search-listbox",
+                    "aria-expanded": "${state.expanded ? 'true' : 'false'}",
+                    "aria-activedescendant": "${state.activeId || null}",
+                    "aria-autocomplete": "list",
+                    "aria-label": "${state.placeholder}",
+                    placeholder: "${state.placeholder}"
+                  },
+                  value: {
+                    $ref: "#/state/query"
+                  },
+                  oninput: {
+                    $prototype: "Function",
+                    body: [
+                      {
+                        operator: "call",
+                        target: {
+                          $ref: "#/state/input"
+                        },
+                        value: [
+                          {
+                            $ref: "event#/target/value"
+                          }
+                        ]
+                      }
+                    ]
+                  },
+                  onkeydown: {
+                    $prototype: "Function",
+                    body: [
+                      {
+                        $switch: {
+                          $ref: "event#/key"
+                        },
+                        cases: {
+                          ArrowDown: [
+                            {
+                              preventDefault: true
+                            },
+                            {
+                              operator: "call",
+                              target: {
+                                $ref: "#/state/move"
+                              },
+                              value: [1]
+                            }
+                          ],
+                          ArrowUp: [
+                            {
+                              preventDefault: true
+                            },
+                            {
+                              operator: "call",
+                              target: {
+                                $ref: "#/state/move"
+                              },
+                              value: [-1]
+                            }
+                          ],
+                          Enter: [
+                            {
+                              preventDefault: true
+                            },
+                            {
+                              operator: "call",
+                              target: {
+                                $ref: "#/state/activate"
+                              },
+                              value: []
+                            }
+                          ],
+                          Escape: [
+                            {
+                              preventDefault: true
+                            },
+                            {
+                              operator: "call",
+                              target: {
+                                $ref: "#/state/close"
+                              },
+                              value: []
+                            }
+                          ],
+                          Backspace: [
+                            {
+                              $switch: {
+                                $ref: "#/state/canClearMode"
+                              },
+                              cases: {
+                                true: [
+                                  {
+                                    preventDefault: true
+                                  },
+                                  {
+                                    operator: "call",
+                                    target: {
+                                      $ref: "#/state/clearMode"
+                                    },
+                                    value: []
+                                  }
+                                ]
+                              }
+                            }
+                          ]
+                        }
+                      }
+                    ]
+                  }
+                }
+              ]
+            },
+            {
+              tagName: "jx-listbox",
+              attributes: {
+                part: "results",
+                id: "quick-search-listbox"
+              },
+              $props: {
+                label: "Results",
+                active: "${state.activeId}"
+              },
+              onselect: {
+                $prototype: "Function",
+                body: [
+                  {
+                    operator: "call",
+                    target: {
+                      $ref: "#/state/activateRow"
+                    },
+                    value: [
+                      {
+                        $ref: "event#/detail"
+                      }
+                    ]
+                  }
+                ],
+                description: "One handler for every row, because a row's `select` bubbles. The detail is the row's `value`, which is the index it occupies in `rows` — the same number a hover names, and the number the id is built from."
+              },
+              children: [
+                {
+                  tagName: "div",
+                  attributes: {
+                    part: "empty-slot",
+                    role: "none"
+                  },
+                  $switch: {
+                    $ref: "#/state/isEmpty"
+                  },
+                  cases: {
+                    true: {
+                      tagName: "div",
+                      attributes: {
+                        part: "empty"
+                      },
+                      textContent: "${state.emptyHint}"
+                    }
+                  }
+                },
+                {
+                  tagName: "div",
+                  attributes: {
+                    part: "section-slot",
+                    role: "none"
+                  },
+                  $switch: {
+                    $ref: "#/state/showSection"
+                  },
+                  cases: {
+                    true: {
+                      tagName: "div",
+                      attributes: {
+                        part: "group-heading"
+                      },
+                      textContent: "${state.sectionLabel}"
+                    }
+                  }
+                },
+                {
+                  $prototype: "Array",
+                  items: {
+                    $ref: "#/state/rows"
+                  },
+                  key: {
+                    $ref: "$map/item/key"
+                  },
+                  map: {
+                    tagName: "jx-option",
+                    attributes: {
+                      part: "option",
+                      id: "quick-search-option-${$map.index}",
+                      "data-kind": "${$map.item.kind}"
+                    },
+                    $props: {
+                      value: "${$map.index}",
+                      label: {
+                        $ref: "$map/item/name"
+                      },
+                      description: {
+                        $ref: "$map/item/detail"
+                      },
+                      disabled: {
+                        $ref: "$map/item/disabled"
+                      }
+                    },
+                    onmouseenter: {
+                      $prototype: "Function",
+                      body: [
+                        {
+                          operator: "call",
+                          target: {
+                            $ref: "#/state/hover"
+                          },
+                          value: [
+                            {
+                              $ref: "$map/index"
+                            }
+                          ]
+                        }
+                      ]
+                    },
+                    children: [
+                      {
+                        tagName: "jx-icon",
+                        attributes: {
+                          slot: "icon"
+                        },
+                        $props: {
+                          name: {
+                            $ref: "$map/item/icon"
+                          }
+                        }
+                      },
+                      {
+                        tagName: "span",
+                        attributes: {
+                          slot: "end",
+                          part: "trailing-slot"
+                        },
+                        $switch: {
+                          $ref: "$map/item/trailing"
+                        },
+                        cases: {
+                          chord: {
+                            tagName: "kbd",
+                            attributes: {
+                              part: "chord"
+                            },
+                            textContent: "${$map.item.chord}"
+                          },
+                          recent: {
+                            tagName: "span",
+                            attributes: {
+                              part: "badge"
+                            },
+                            textContent: "recent"
+                          }
+                        }
+                      }
+                    ]
+                  }
+                }
+              ]
+            },
+            {
+              tagName: "div",
+              attributes: {
+                part: "hint"
+              },
+              children: [
+                {
+                  tagName: "kbd",
+                  textContent: "↑↓"
+                },
+                " move · ",
+                {
+                  tagName: "kbd",
+                  textContent: "↵"
+                },
+                " run · ",
+                {
+                  tagName: "kbd",
+                  textContent: "?"
+                },
+                " modes · ",
+                {
+                  tagName: "kbd",
+                  textContent: ">"
+                },
+                " commands · ",
+                {
+                  tagName: "kbd",
+                  textContent: "@"
+                },
+                " elements"
+              ]
+            }
+          ]
+        }
+      ]
+    }
+  }
+};
+
+// src/panels/quick-search.ts
+var PALETTE_MODES = [
+  {
+    mode: "files",
+    prefix: "",
+    chip: "Files",
+    placeholder: "Go to a file…",
+    description: "Open a file by any part of its path — pgblog finds pages/blog/index.md."
+  },
+  {
+    mode: "commands",
+    prefix: ">",
+    chip: "Commands",
+    placeholder: "Run a command…",
+    description: "Run anything Studio can do, with its keyboard shortcut printed beside it."
+  },
+  {
+    mode: "nodes",
+    prefix: "@",
+    chip: "Symbols",
+    placeholder: "Go to an element in this document…",
+    description: "Select an element in the open document by its Outline name."
+  },
+  {
+    mode: "projects",
+    prefix: "",
+    chip: "Recent Projects",
+    placeholder: "Open a recent project…",
+    description: "Reopen a project you have had open before."
+  },
+  {
+    mode: "picker",
+    prefix: "?",
+    chip: "Modes",
+    placeholder: "Type ? for modes, > for commands, @ for elements…",
+    description: "List these modes."
+  }
+];
+var MODE_SPEC = new Map(PALETTE_MODES.map((spec) => [spec.mode, spec]));
+var PREFIXED_MODES = PALETTE_MODES.filter((spec) => spec.prefix !== "");
+function modeSpec(mode) {
+  return MODE_SPEC.get(mode) ?? PALETTE_MODES[0];
+}
+function resolvePaletteMode(requested, raw, projectOpen) {
+  const prefixed = PREFIXED_MODES.find((spec) => raw.startsWith(spec.prefix));
+  if (prefixed) {
+    return resolvePaletteMode(prefixed.mode, raw.slice(1), projectOpen);
+  }
+  let mode = requested;
+  if (mode === "picker" && raw.trim() !== "") {
+    mode = "files";
+  }
+  if (mode === "files" && !projectOpen) {
+    mode = "projects";
+  }
+  return { mode, query: raw };
+}
+var BOUNDARY = new Set(["/", "-", "_", ".", " "]);
+function fuzzyScore(text, query) {
+  if (query === "") {
+    return 0;
+  }
+  const haystack = text.toLowerCase();
+  const needle = query.toLowerCase();
+  const basenameStart = haystack.lastIndexOf("/") + 1;
+  let score = 0;
+  let cursor = 0;
+  let previousIndex = -2;
+  for (const char of needle) {
+    const index = haystack.indexOf(char, cursor);
+    if (index === -1) {
+      return null;
+    }
+    if (index === previousIndex + 1) {
+      score += 8;
+    }
+    if (index === 0 || BOUNDARY.has(haystack[index - 1] ?? "")) {
+      score += 6;
+    }
+    if (index >= basenameStart) {
+      score += 4;
+    }
+    previousIndex = index;
+    cursor = index + 1;
+  }
+  return score - previousIndex * 0.01 - haystack.length * 0.001;
+}
+function rankBy(items, query, key) {
+  const scored = [];
+  for (const [index, item] of items.entries()) {
+    const score = fuzzyScore(key(item), query);
+    if (score !== null) {
+      scored.push({ index, item, score });
+    }
+  }
+  return scored.toSorted((a, b) => b.score - a.score || a.index - b.index).map((entry) => entry.item);
+}
+function paletteArgs(command) {
+  const schema = command.args;
+  const properties = schema?.properties;
+  if (!schema || !properties) {
+    return { kind: "none" };
+  }
+  const names = Object.keys(properties);
+  if (names.length !== 1) {
+    return { kind: "unsupported" };
+  }
+  const name = names[0];
+  const property = properties[name];
+  if (property.enum) {
+    return {
+      kind: "choice",
+      name,
+      choices: property.enum.map((value) => ({ label: String(value), value }))
+    };
+  }
+  if (property.type === "boolean") {
+    return {
+      kind: "choice",
+      name,
+      choices: [
+        { label: "on", value: true },
+        { label: "off", value: false }
+      ]
+    };
+  }
+  return { kind: "unsupported" };
+}
+function optionId(index) {
+  return `quick-search-option-${index}`;
+}
+var RECENT_COMMANDS_KEY = "jx-studio-recent-commands";
+var RECENT_COMMANDS_MAX = 6;
+function getRecentCommands() {
+  try {
+    const raw = JSON.parse(localStorage.getItem(RECENT_COMMANDS_KEY) || "[]");
+    return Array.isArray(raw) ? raw.filter((id) => typeof id === "string") : [];
+  } catch {
+    return [];
+  }
+}
+function trackRecentCommand(id) {
+  const next = [id, ...getRecentCommands().filter((known) => known !== id)].slice(0, RECENT_COMMANDS_MAX);
+  try {
+    localStorage.setItem(RECENT_COMMANDS_KEY, JSON.stringify(next));
+  } catch {}
+}
+var _ctx = null;
+var _open = false;
+var _requested = "picker";
+var _query = "";
+var _selectedIndex = 0;
+var _files = null;
+var _loading = false;
+var _pending = null;
+function getContainer() {
+  return getLayerSlot2("popover", "quick-search");
+}
+function initQuickSearch2(ctx) {
+  _ctx = ctx ?? null;
+}
+function openQuickSearch2(mode = "files") {
+  _open = true;
+  _requested = mode;
+  _query = "";
+  _selectedIndex = 0;
+  _pending = null;
+  _files = null;
+  renderOverlay();
+  focusInput();
+  ensureFiles();
+}
+function closeQuickSearch() {
+  _open = false;
+  _pending = null;
+  renderOverlay();
+}
+function scopeRoot() {
+  return projectState ? projectState.projectRoot ?? null : null;
+}
+function hasProject() {
+  return projectState != null;
+}
+function current() {
+  return resolvePaletteMode(_requested, _query, hasProject());
+}
+function dirPart(path) {
+  const parts = path.split("/");
+  parts.pop();
+  return parts.length > 0 ? parts.join("/") : "";
+}
+function shortenPath(path) {
+  if (path.startsWith("/home/")) {
+    return `~/${path.split("/").slice(3).join("/")}`;
+  }
+  return path;
+}
+async function ensureFiles() {
+  if (!_open || _files !== null || _loading || !hasProject()) {
+    return;
+  }
+  _loading = true;
+  renderOverlay();
+  try {
+    await loadFormats2();
+    const hits = await getPlatform2().searchFiles("", documentExtensions2());
+    _files = hits.map((hit) => ({
+      kind: "file",
+      path: hit.path,
+      name: hit.name ?? hit.path.split("/").pop() ?? "",
+      detail: dirPart(hit.path),
+      recent: false
+    }));
+  } catch {
+    _files = [];
+  }
+  _loading = false;
+  renderOverlay();
+}
+function fileRows(query) {
+  if (query.trim() === "") {
+    return getRecentFiles(scopeRoot() ?? undefined).map((file) => ({
+      kind: "file",
+      path: file.path,
+      name: file.name,
+      detail: dirPart(file.path),
+      recent: true
+    }));
+  }
+  return rankBy(_files ?? [], query.trim(), (row) => row.path);
+}
+function projectRows(query) {
+  const rows = getRecentProjects().map((project) => ({
+    kind: "project",
+    root: project.root,
+    name: project.name,
+    detail: shortenPath(project.root)
+  }));
+  return rankBy(rows, query.trim(), (row) => `${row.name}/${row.root}`);
+}
+function commandRows(registry, query) {
+  const recents = getRecentCommands();
+  const rows = [];
+  for (const command of registry.visible()) {
+    if (paletteArgs(command).kind === "unsupported") {
+      continue;
+    }
+    if (!(command.menus ?? ["palette"]).includes("palette")) {
+      continue;
+    }
+    rows.push({
+      kind: "command",
+      id: command.id,
+      name: `${command.category}: ${command.title}`,
+      detail: registry.disabledReason(command.id) ?? "",
+      chord: registry.keymap.formatBinding(command.id) ?? "",
+      enabled: registry.isEnabled(command.id),
+      recent: recents.includes(command.id)
+    });
+  }
+  const ranked = rankBy(rows, query.trim(), (row) => row.name);
+  if (query.trim() !== "") {
+    return ranked;
+  }
+  const pinned = recents.map((id) => ranked.find((row) => row.id === id)).filter((row) => row !== undefined);
+  return [...pinned, ...ranked.filter((row) => !pinned.includes(row))];
+}
+function nodeRows(query) {
+  const tab = activeTab2.value;
+  if (!tab) {
+    return [];
+  }
+  const rows = flattenTree(tab.doc.document).map((row) => ({
+    kind: "node",
+    path: row.path,
+    name: row.nodeType === "text" ? String(row.node).slice(0, 60) : nodeLabel(row.node),
+    detail: row.nodeType
+  }));
+  return rankBy(rows, query.trim(), (row) => row.name);
+}
+function modeRows() {
+  return PALETTE_MODES.filter((spec) => spec.mode !== "picker").map((spec) => ({
+    kind: "mode",
+    mode: spec.mode,
+    name: spec.chip,
+    detail: spec.description,
+    chord: spec.prefix
+  }));
+}
+function argRows(query) {
+  const pending = _pending;
+  const rows = pending.choices.map((choice) => ({
+    kind: "arg",
+    commandId: pending.command.id,
+    argName: pending.name,
+    value: choice.value,
+    name: choice.label,
+    detail: `${pending.command.title} → ${pending.name}`
+  }));
+  return rankBy(rows, query.trim(), (row) => row.name);
+}
+function currentRows() {
+  const { mode, query } = current();
+  if (_pending) {
+    return { rows: argRows(query), showingRecent: false };
+  }
+  switch (mode) {
+    case "commands": {
+      const registry = activeRegistry();
+      return {
+        rows: registry ? commandRows(registry, query) : [],
+        showingRecent: query.trim() === ""
+      };
+    }
+    case "nodes": {
+      return { rows: nodeRows(query), showingRecent: false };
+    }
+    case "projects": {
+      return { rows: projectRows(query), showingRecent: query.trim() === "" };
+    }
+    case "picker": {
+      return { rows: modeRows(), showingRecent: false };
+    }
+    default: {
+      return { rows: fileRows(query), showingRecent: query.trim() === "" };
+    }
+  }
+}
+function onInput(raw) {
+  const prefixed = PREFIXED_MODES.find((spec) => raw.startsWith(spec.prefix));
+  if (prefixed) {
+    _requested = prefixed.mode;
+    _query = raw.slice(1);
+  } else {
+    _query = raw;
+  }
+  _selectedIndex = 0;
+  if (raw !== _query) {
+    scope().query = raw;
+  }
+  renderOverlay();
+  ensureFiles();
+}
+function clearMode() {
+  _requested = "picker";
+  _pending = null;
+  _selectedIndex = 0;
+  renderOverlay();
+}
+function enterMode(mode) {
+  _requested = mode;
+  _query = "";
+  _selectedIndex = 0;
+  renderOverlay();
+  ensureFiles();
+}
+function runCommand(command, args) {
+  const registry = activeRegistry();
+  if (!registry) {
+    return;
+  }
+  trackRecentCommand(command.id);
+  closeQuickSearch();
+  const report = (error) => {
+    console.error(`palette: command "${command.id}" failed`, error);
+  };
+  try {
+    Promise.resolve(registry.run(command.id, args)).catch(report);
+  } catch (error) {
+    report(error);
+  }
+}
+function selectRow(row) {
+  switch (row.kind) {
+    case "project": {
+      closeQuickSearch();
+      _ctx?.openRecentProject(row.root);
+      return;
+    }
+    case "file": {
+      closeQuickSearch();
+      trackRecentFile({ name: row.name, path: row.path, root: scopeRoot() ?? "" });
+      openFileInTab2(row.path);
+      return;
+    }
+    case "mode": {
+      enterMode(row.mode);
+      return;
+    }
+    case "node": {
+      const registry = activeRegistry();
+      closeQuickSearch();
+      registry?.run("selection.set", { path: row.path });
+      return;
+    }
+    case "arg": {
+      runCommand(_pending.command, { [row.argName]: row.value });
+      return;
+    }
+    default: {
+      selectCommandRow(row);
+    }
+  }
+}
+function selectCommandRow(row) {
+  const registry = activeRegistry();
+  const command = registry?.get(row.id);
+  if (!registry || !command || !row.enabled) {
+    return;
+  }
+  const args = paletteArgs(command);
+  if (args.kind === "choice") {
+    _pending = { choices: args.choices, command, name: args.name };
+    _query = "";
+    _selectedIndex = 0;
+    renderOverlay();
+    return;
+  }
+  runCommand(command);
+}
+function fileIcon(name) {
+  const ext = name.split(".").pop()?.toLowerCase();
+  if (ext === "json") {
+    return "file-code";
+  }
+  if (ext && formatByExtension2(ext)) {
+    return "file-text";
+  }
+  return "file";
+}
+function rowIcon(row) {
+  switch (row.kind) {
+    case "project": {
+      return "folder-open";
+    }
+    case "file": {
+      return fileIcon(row.name);
+    }
+    case "command": {
+      return "play";
+    }
+    case "node": {
+      return "stack";
+    }
+    default: {
+      return "caret-right";
+    }
+  }
+}
+function rowTrailing(row, showingRecent) {
+  if ((row.kind === "command" || row.kind === "mode") && row.chord) {
+    return "chord";
+  }
+  if (row.kind === "command" && row.recent) {
+    return "recent";
+  }
+  return showingRecent ? "recent" : "none";
+}
+function rowKey(row) {
+  switch (row.kind) {
+    case "project": {
+      return `project:${row.root}`;
+    }
+    case "file": {
+      return `file:${row.path}`;
+    }
+    case "command": {
+      return `command:${row.id}`;
+    }
+    case "node": {
+      return `node:${row.path.join("/")}`;
+    }
+    case "mode": {
+      return `mode:${row.mode}`;
+    }
+    default: {
+      return `arg:${row.value}`;
+    }
+  }
+}
+function emptyHint(mode, query) {
+  if (_loading) {
+    return "Reading the project's files…";
+  }
+  if (query.trim() !== "") {
+    return "No results";
+  }
+  switch (mode) {
+    case "projects": {
+      return "No recent projects — open one to get started";
+    }
+    case "nodes": {
+      return "Open a document to jump to its elements";
+    }
+    case "commands": {
+      return "Type to find any command in Studio";
+    }
+    default: {
+      return modeSpec(mode).placeholder;
+    }
+  }
+}
+registerSurface("palette", palette_default);
+var _scope = null;
+var _mount = null;
+var _rows = [];
+function scope() {
+  _scope ??= reactive({
+    activate: () => {
+      const row = _rows[_selectedIndex];
+      if (row) {
+        selectRow(row);
+      }
+    },
+    activateRow: (value) => {
+      const row = _rows[Number(value)];
+      if (row) {
+        selectRow(row);
+      }
+    },
+    activeId: "",
+    canClearMode: false,
+    chipLabel: "",
+    clearMode,
+    close: closeQuickSearch,
+    emptyHint: "",
+    expanded: false,
+    hasChip: false,
+    hover: (index) => {
+      _selectedIndex = index;
+      scope().activeId = optionId(index);
+    },
+    input: onInput,
+    isEmpty: true,
+    move: (delta) => {
+      if (_rows.length === 0) {
+        return;
+      }
+      _selectedIndex = Math.max(0, Math.min(_selectedIndex + delta, _rows.length - 1));
+      scope().activeId = optionId(_selectedIndex);
+    },
+    open: false,
+    placeholder: "",
+    query: "",
+    rows: [],
+    sectionLabel: "",
+    showSection: false
+  });
+  return _scope;
+}
+function focusInput() {
+  setTimeout(() => {
+    if (_open) {
+      getContainer().querySelector('[part="input"]')?.focus();
+    }
+  }, 0);
+}
+function renderOverlay() {
+  const state = scope();
+  if (!_mount) {
+    _mount = mountSurface("palette", state, getContainer());
+  }
+  state.open = _open;
+  if (!_open) {
+    _rows = [];
+    return;
+  }
+  const { mode, query } = current();
+  const { rows, showingRecent } = currentRows();
+  const spec = modeSpec(mode);
+  _rows = rows;
+  state.placeholder = _pending ? `Choose a ${_pending.name}…` : spec.placeholder;
+  state.hasChip = _pending !== null || mode !== "picker";
+  state.chipLabel = _pending ? _pending.command.title : spec.chip;
+  state.query = _query;
+  state.canClearMode = _query === "" && (_pending !== null || _requested !== "picker");
+  state.rows = rows.map((row) => ({
+    chord: (row.kind === "command" || row.kind === "mode") && row.chord ? row.chord : "",
+    detail: row.detail,
+    disabled: row.kind === "command" && !row.enabled,
+    icon: rowIcon(row),
+    key: rowKey(row),
+    kind: row.kind,
+    name: row.name,
+    trailing: rowTrailing(row, showingRecent)
+  }));
+  state.expanded = rows.length > 0;
+  state.activeId = rows.length > 0 ? optionId(_selectedIndex) : "";
+  state.isEmpty = rows.length === 0;
+  state.emptyHint = emptyHint(mode, query);
+  state.showSection = showingRecent && rows.length > 0;
+  state.sectionLabel = _pending ? `${_pending.command.title} — ${_pending.name}` : mode === "projects" ? "Recent projects" : mode === "commands" ? "Recently used" : "Recently opened";
+}
+
+export { initQuickSearch2, openQuickSearch2 };
+
+//# debugId=46E99F715645799364756E2164756E21
+//# sourceMappingURL=studio-5rt7sqa0.js.map