@jxsuite/studio 3.0.0 → 4.0.0

package/dist/chunks/studio-hbtp0eh1.js

@@ -0,0 +1,1315 @@
+import {
+  errorMessage
+} from "./studio-9n4mrmnb.js";
+import {
+  PRIMARY_PANE,
+  PROJECT_CONFIG_PATH,
+  SECONDARY_PANE,
+  argsSchema,
+  booleanArg,
+  booleanProperty,
+  createTab,
+  disposeTab,
+  enumArg,
+  enumProperty,
+  focusPane,
+  isWellFormedLocale,
+  resolveI18n,
+  setWorkspaceProject,
+  stringArg,
+  stringProperty,
+  transactDoc,
+  workspace
+} from "./studio-2zkz8evn.js";
+import {
+  SETTINGS,
+  readStoredSetting,
+  setSetting
+} from "./studio-92ab2jqe.js";
+import {
+  effect,
+  effectScope,
+  notify,
+  pinClock,
+  reactive,
+  toRaw
+} from "./studio-xrapxwwc.js";
+import {
+  projectState,
+  requireProjectState,
+  setProjectState
+} from "./studio-p4ngc046.js";
+import {
+  loadedMonaco
+} from "./studio-eenfkt4e.js";
+import {
+  getPlatform
+} from "./studio-9ab8gqsm.js";
+import {
+  __require
+} from "./studio-a0tswy0w.js";
+
+// src/workspace/session.ts
+var PANE_IDS = new Set([PRIMARY_PANE, SECONDARY_PANE]);
+var SCHEMES = new Set(["auto", "light", "dark"]);
+function uiOf(tab) {
+  const { ui } = tab.session;
+  return {
+    activeMedia: ui.activeMedia,
+    canvasMode: ui.canvasMode,
+    editZoom: ui.editZoom,
+    preview: ui.preview,
+    previewColorScheme: ui.previewColorScheme,
+    previewLocale: ui.previewLocale,
+    showLayout: ui.showLayout,
+    zoom: ui.zoom
+  };
+}
+function captureSession() {
+  const ui = {};
+  const panes = [];
+  for (const pane of workspace.panes) {
+    if (pane.derived) {
+      continue;
+    }
+    const files = [];
+    for (const tabId of pane.tabOrder) {
+      const tab = workspace.tabs.get(tabId);
+      if (!tab?.documentPath) {
+        continue;
+      }
+      files.push(tab.documentPath);
+      ui[tab.documentPath] = uiOf(tab);
+    }
+    if (files.length === 0) {
+      continue;
+    }
+    const activeTab = pane.activeTabId ? workspace.tabs.get(pane.activeTabId) : null;
+    panes.push({
+      activeFile: activeTab?.documentPath ?? null,
+      files,
+      id: pane.id
+    });
+  }
+  return { focusedPane: workspace.activePaneId, panes, ui };
+}
+function readTabUi(value) {
+  if (typeof value !== "object" || value === null) {
+    return {};
+  }
+  const raw = value;
+  const out = {};
+  if (typeof raw.canvasMode === "string") {
+    out.canvasMode = raw.canvasMode;
+  }
+  if (typeof raw.preview === "boolean") {
+    out.preview = raw.preview;
+  }
+  if (typeof raw.zoom === "number" && Number.isFinite(raw.zoom)) {
+    out.zoom = raw.zoom;
+  }
+  if (typeof raw.editZoom === "number" && Number.isFinite(raw.editZoom)) {
+    out.editZoom = raw.editZoom;
+  }
+  if (raw.activeMedia === null || typeof raw.activeMedia === "string") {
+    out.activeMedia = raw.activeMedia;
+  }
+  if (typeof raw.previewColorScheme === "string" && SCHEMES.has(raw.previewColorScheme)) {
+    out.previewColorScheme = raw.previewColorScheme;
+  }
+  if (raw.previewLocale === null || isWellFormedLocale(raw.previewLocale)) {
+    out.previewLocale = raw.previewLocale;
+  }
+  if (typeof raw.showLayout === "boolean") {
+    out.showLayout = raw.showLayout;
+  }
+  return out;
+}
+function readSession(value) {
+  if (typeof value !== "object" || value === null) {
+    return null;
+  }
+  const raw = value;
+  if (!Array.isArray(raw.panes)) {
+    return null;
+  }
+  const panes = [];
+  for (const entry of raw.panes) {
+    if (typeof entry !== "object" || entry === null) {
+      continue;
+    }
+    const pane = entry;
+    if (typeof pane.id !== "string" || !PANE_IDS.has(pane.id)) {
+      continue;
+    }
+    const files = Array.isArray(pane.files) ? pane.files.filter((file) => typeof file === "string" && file !== "") : [];
+    if (files.length === 0) {
+      continue;
+    }
+    panes.push({
+      activeFile: typeof pane.activeFile === "string" && files.includes(pane.activeFile) ? pane.activeFile : null,
+      files,
+      id: pane.id
+    });
+  }
+  if (panes.length === 0) {
+    return null;
+  }
+  const ui = {};
+  if (typeof raw.ui === "object" && raw.ui !== null) {
+    for (const [path, entry] of Object.entries(raw.ui)) {
+      ui[path] = readTabUi(entry);
+    }
+  }
+  return {
+    focusedPane: typeof raw.focusedPane === "string" && PANE_IDS.has(raw.focusedPane) ? raw.focusedPane : PRIMARY_PANE,
+    panes,
+    ui
+  };
+}
+async function restoreSession(session, deps) {
+  let opened = 0;
+  if (session.panes.some((pane) => pane.id === SECONDARY_PANE)) {
+    deps.ensureSecondPane();
+  }
+  for (const pane of session.panes) {
+    for (const file of pane.files) {
+      try {
+        await deps.openFile(file, pane.id);
+      } catch {}
+      if ([...workspace.tabs.values()].some((tab) => tab.documentPath === file)) {
+        opened += 1;
+      }
+    }
+  }
+  if (opened === 0) {
+    return 0;
+  }
+  for (const tab of workspace.tabs.values()) {
+    const stored = tab.documentPath ? session.ui[tab.documentPath] : undefined;
+    if (!stored) {
+      continue;
+    }
+    const { ui } = tab.session;
+    if (stored.canvasMode && tab.capabilities.modes.includes(stored.canvasMode)) {
+      ui.canvasMode = stored.canvasMode;
+    }
+    if (stored.preview !== undefined) {
+      ui.preview = stored.preview;
+    }
+    if (stored.zoom !== undefined) {
+      ui.zoom = stored.zoom;
+    }
+    if (stored.editZoom !== undefined) {
+      ui.editZoom = stored.editZoom;
+    }
+    if (stored.activeMedia !== undefined) {
+      ui.activeMedia = stored.activeMedia;
+    }
+    if (stored.previewColorScheme !== undefined) {
+      ui.previewColorScheme = stored.previewColorScheme;
+    }
+    if (stored.previewLocale !== undefined) {
+      ui.previewLocale = stored.previewLocale;
+    }
+    if (stored.showLayout !== undefined) {
+      ui.showLayout = stored.showLayout;
+    }
+  }
+  for (const stored of session.panes) {
+    const pane = workspace.panes.find((p) => p.id === stored.id);
+    if (!pane || !stored.activeFile) {
+      continue;
+    }
+    const match = pane.tabOrder.find((tabId) => workspace.tabs.get(tabId)?.documentPath === stored.activeFile);
+    if (match) {
+      pane.activeTabId = match;
+    }
+  }
+  if (workspace.panes.some((pane) => pane.id === session.focusedPane)) {
+    focusPane(session.focusedPane);
+  }
+  return opened;
+}
+
+// src/services/profile.ts
+var STARTUP_PROFILES = {
+  default: {
+    description: "Resume whatever was persisted — layout, recents, settings, chat history.",
+    id: "default",
+    reset: "none"
+  },
+  fresh: {
+    description: "A first-run app: no layout, no recents, no settings, no history.",
+    id: "fresh",
+    reset: "app-state"
+  }
+};
+var DEFAULT_PROFILE_ID = "default";
+var OWNED_KEY_PATTERN = /^jx[-._:]/;
+function isStudioStorageKey(key) {
+  return OWNED_KEY_PATTERN.test(key);
+}
+function clearStudioStorage() {
+  const store = globalThis.localStorage;
+  if (!store) {
+    return [];
+  }
+  const doomed = [];
+  try {
+    for (let i = 0;i < store.length; i++) {
+      const key = store.key(i);
+      if (key && isStudioStorageKey(key)) {
+        doomed.push(key);
+      }
+    }
+    for (const key of doomed) {
+      store.removeItem(key);
+    }
+  } catch {}
+  return doomed;
+}
+function applyProfile(id) {
+  const profile = STARTUP_PROFILES[id];
+  if (!profile) {
+    throw new RangeError(`unknown startup profile "${id}"; declared: ${Object.keys(STARTUP_PROFILES).join(", ")}`);
+  }
+  if (profile.reset === "app-state") {
+    clearStudioStorage();
+  }
+  return profile;
+}
+var _startup = null;
+function applyStartupProfile(search) {
+  if (_startup) {
+    return _startup;
+  }
+  const query = new URLSearchParams(search ?? globalThis.location?.search ?? "");
+  const profile = applyProfile(query.get("profile") ?? DEFAULT_PROFILE_ID);
+  const clockParam = query.get("clock");
+  _startup = { clock: clockParam === null ? null : pinClock(clockParam), profile };
+  return _startup;
+}
+
+// src/shell.ts
+var NAVIGATOR_PANEL_IDS = [
+  "files",
+  "search",
+  "git",
+  "i18n",
+  "layers",
+  "page",
+  "data",
+  "packages",
+  "insert"
+];
+var RENAMED_PANEL_IDS = {
+  blocks: "insert",
+  head: "page",
+  imports: "packages",
+  state: "data"
+};
+var DEFAULT_PANEL_ID = "layers";
+function isNavigatorPanelId(value) {
+  return typeof value === "string" && NAVIGATOR_PANEL_IDS.includes(value);
+}
+function requireNavigatorPanelId(value, source) {
+  if (!isNavigatorPanelId(value)) {
+    throw new Error(`${source}: "${value}" is not a declared Navigator panel id.`);
+  }
+  return value;
+}
+function migratePanelId(stored) {
+  if (typeof stored !== "string") {
+    return null;
+  }
+  const renamed = RENAMED_PANEL_IDS[stored];
+  if (renamed) {
+    return renamed;
+  }
+  return isNavigatorPanelId(stored) ? stored : null;
+}
+var INSPECTOR_TAB_IDS = ["properties", "style", "events", "assistant"];
+var DEFAULT_INSPECTOR_TAB = "properties";
+function isInspectorTabId(value) {
+  return typeof value === "string" && INSPECTOR_TAB_IDS.includes(value);
+}
+var BOTTOM_TAB_IDS = ["problems", "logic", "activity"];
+var DEFAULT_BOTTOM_TAB = "problems";
+function isBottomTabId(value) {
+  return typeof value === "string" && BOTTOM_TAB_IDS.includes(value);
+}
+var CHROME_THEMES = ["light", "dark"];
+var DOCK_STORAGE_KEY = "jx-studio-panel-widths";
+var PROJECT_STORAGE_PREFIX = "jx-studio-project::";
+var DEFAULT_THEME = "dark";
+function isChromeTheme(value) {
+  return typeof value === "string" && CHROME_THEMES.includes(value);
+}
+function readPersistedTheme() {
+  const stored = readStoredSetting(SETTINGS.theme);
+  return isChromeTheme(stored) ? stored : DEFAULT_THEME;
+}
+var DOCK_IDS = ["left", "right", "bottom"];
+var DOCK_DEFAULTS = {
+  bottom: { collapsed: true, size: 220 },
+  left: { collapsed: false, size: 240 },
+  right: { collapsed: false, size: 280 }
+};
+var DOCK_DEFAULT_SIZES = {
+  bottom: DOCK_DEFAULTS.bottom.size,
+  left: DOCK_DEFAULTS.left.size,
+  right: DOCK_DEFAULTS.right.size
+};
+var DOCK_CSS_VAR = {
+  bottom: "--dock-h-bottom",
+  left: "--panel-w-left",
+  right: "--panel-w-right"
+};
+var DOCK_CLASS = {
+  bottom: "bottom-collapsed",
+  left: "left-collapsed",
+  right: "right-collapsed"
+};
+var DEFAULT_PANE_SPLIT = 0.5;
+function clampPaneSplit(value) {
+  return typeof value === "number" && value >= 0.2 && value <= 0.8 ? value : DEFAULT_PANE_SPLIT;
+}
+function setPaneSplit(value) {
+  shell.paneSplit = Math.min(0.8, Math.max(0.2, value));
+}
+function readPersistedDocks() {
+  try {
+    return JSON.parse(localStorage.getItem(DOCK_STORAGE_KEY) || "{}");
+  } catch {
+    return {};
+  }
+}
+function freshGit() {
+  return {
+    branches: null,
+    commitMessage: "",
+    diffState: null,
+    error: null,
+    lastUpdated: null,
+    loading: false,
+    logEntries: null,
+    status: null,
+    subTab: "changes"
+  };
+}
+function freshStylebook() {
+  return { customizedOnly: false, filter: "", selection: null, tab: "elements" };
+}
+function builtInLayouts() {
+  return [
+    {
+      bottomTab: "problems",
+      docks: {
+        bottom: { collapsed: true, size: 220 },
+        left: { collapsed: false, size: 240 },
+        right: { collapsed: true, size: 280 }
+      },
+      id: "write",
+      inspectorTab: "properties",
+      name: "Write",
+      navigatorPanel: "files"
+    },
+    {
+      bottomTab: "problems",
+      docks: {
+        bottom: { collapsed: true, size: 220 },
+        left: { collapsed: false, size: 240 },
+        right: { collapsed: false, size: 320 }
+      },
+      id: "design",
+      inspectorTab: "style",
+      name: "Design",
+      navigatorPanel: "layers"
+    },
+    {
+      bottomTab: "logic",
+      docks: {
+        bottom: { collapsed: true, size: 260 },
+        left: { collapsed: false, size: 280 },
+        right: { collapsed: false, size: 300 }
+      },
+      id: "build",
+      inspectorTab: "events",
+      name: "Build",
+      navigatorPanel: "data"
+    },
+    {
+      bottomTab: "activity",
+      docks: {
+        bottom: { collapsed: false, size: 240 },
+        left: { collapsed: false, size: 300 },
+        right: { collapsed: true, size: 280 }
+      },
+      id: "ship",
+      inspectorTab: "properties",
+      name: "Ship",
+      navigatorPanel: "git"
+    }
+  ];
+}
+var DEFAULT_LAYOUT_ID = "design";
+function createShellState() {
+  const saved = readPersistedDocks();
+  const docks = {};
+  for (const id of DOCK_IDS) {
+    const width = saved[id];
+    const collapsed = saved[`${id}Collapsed`];
+    docks[id] = {
+      collapsed: typeof collapsed === "boolean" ? collapsed : DOCK_DEFAULTS[id].collapsed,
+      size: typeof width === "number" && width > 0 ? width : DOCK_DEFAULTS[id].size
+    };
+  }
+  return {
+    bottomTab: isBottomTabId(saved.bottomTab) ? saved.bottomTab : DEFAULT_BOTTOM_TAB,
+    docks,
+    focusRegion: "pane",
+    paneSplit: clampPaneSplit(saved.paneSplit),
+    git: freshGit(),
+    layout: DEFAULT_LAYOUT_ID,
+    layoutSelection: null,
+    layouts: builtInLayouts(),
+    leftTab: migratePanelId(saved.leftTab) ?? DEFAULT_PANEL_ID,
+    settingsTab: "stylebook",
+    stylebook: freshStylebook(),
+    theme: readPersistedTheme()
+  };
+}
+applyStartupProfile();
+var shell = reactive(createShellState());
+function persistDocks() {
+  try {
+    localStorage.setItem(DOCK_STORAGE_KEY, JSON.stringify({
+      bottom: shell.docks.bottom.size,
+      bottomCollapsed: shell.docks.bottom.collapsed,
+      bottomTab: shell.bottomTab,
+      left: shell.docks.left.size,
+      leftCollapsed: shell.docks.left.collapsed,
+      leftTab: shell.leftTab,
+      paneSplit: shell.paneSplit,
+      right: shell.docks.right.size,
+      rightCollapsed: shell.docks.right.collapsed
+    }));
+  } catch {}
+}
+var _layoutRoot;
+function isLayoutPreset(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const preset = value;
+  return typeof preset.id === "string" && preset.id !== "" && typeof preset.name === "string" && isNavigatorPanelId(preset.navigatorPanel) && isInspectorTabId(preset.inspectorTab) && isBottomTabId(preset.bottomTab) && DOCK_IDS.every((dock) => typeof preset.docks?.[dock]?.size === "number");
+}
+function rawPersistedProject(root) {
+  if (!root) {
+    return {};
+  }
+  try {
+    return JSON.parse(localStorage.getItem(`${PROJECT_STORAGE_PREFIX}${root}`) || "{}");
+  } catch {
+    return {};
+  }
+}
+function readPersistedProject(root) {
+  const fresh = { activeLayout: null, layouts: builtInLayouts() };
+  if (!root) {
+    return fresh;
+  }
+  const parsed = rawPersistedProject(root);
+  const layouts = Array.isArray(parsed.layouts) ? parsed.layouts.filter(isLayoutPreset) : [];
+  if (layouts.length === 0) {
+    return fresh;
+  }
+  return {
+    activeLayout: typeof parsed.activeLayout === "string" ? parsed.activeLayout : null,
+    layouts
+  };
+}
+function persistedSession(root) {
+  return readSession(rawPersistedProject(root).session);
+}
+var _sessionRoot = null;
+function markSessionRestored(root) {
+  _sessionRoot = root;
+}
+function flushSession() {
+  persistProjectShell();
+}
+function persistProjectShell() {
+  const root = workspace.projectRoot;
+  if (!root) {
+    return;
+  }
+  try {
+    localStorage.setItem(`${PROJECT_STORAGE_PREFIX}${root}`, JSON.stringify({
+      activeLayout: shell.layout,
+      layouts: shell.layouts,
+      session: root === _sessionRoot ? captureSession() : rawPersistedProject(root).session
+    }));
+  } catch {}
+}
+function syncProjectLayouts(root) {
+  if (root === _layoutRoot) {
+    return;
+  }
+  _layoutRoot = root;
+  const { activeLayout, layouts } = readPersistedProject(root);
+  shell.layouts = layouts;
+  const has = (id) => id !== null && layouts.some((preset) => preset.id === id);
+  shell.layout = has(activeLayout) ? activeLayout : has(shell.layout) ? shell.layout : has(DEFAULT_LAYOUT_ID) ? DEFAULT_LAYOUT_ID : layouts[0]?.id ?? DEFAULT_LAYOUT_ID;
+}
+function layoutById(id) {
+  return shell.layouts.find((preset) => preset.id === id);
+}
+function layoutIdFor(name) {
+  const slug = name.trim().toLowerCase().replaceAll(/[^a-z0-9]+/g, "-").replaceAll(/^-|-$/g, "");
+  return slug || "layout";
+}
+function applyLayout(id, deps) {
+  const preset = layoutById(id);
+  if (!preset) {
+    throw new RangeError(`no layout named "${id}" — this project has: ${shell.layouts.map((p) => p.id).join(", ")}`);
+  }
+  shell.layout = preset.id;
+  shell.leftTab = preset.navigatorPanel;
+  shell.bottomTab = preset.bottomTab;
+  for (const dock of DOCK_IDS) {
+    shell.docks[dock].collapsed = preset.docks[dock].collapsed;
+    shell.docks[dock].size = preset.docks[dock].size;
+  }
+  deps.setInspectorTab(preset.inspectorTab);
+  persistDocks();
+  persistProjectShell();
+}
+function saveLayout(name, deps) {
+  const trimmed = name.trim();
+  const id = layoutIdFor(trimmed);
+  const docks = {};
+  for (const dock of DOCK_IDS) {
+    docks[dock] = { collapsed: shell.docks[dock].collapsed, size: shell.docks[dock].size };
+  }
+  const preset = {
+    bottomTab: isBottomTabId(shell.bottomTab) ? shell.bottomTab : DEFAULT_BOTTOM_TAB,
+    docks,
+    id,
+    inspectorTab: deps.inspectorTab(),
+    name: trimmed || id,
+    navigatorPanel: migratePanelId(shell.leftTab) ?? DEFAULT_PANEL_ID
+  };
+  const existing = shell.layouts.findIndex((entry) => entry.id === id);
+  if (existing === -1) {
+    shell.layouts.push(preset);
+  } else {
+    shell.layouts.splice(existing, 1, preset);
+  }
+  shell.layout = id;
+  persistProjectShell();
+  return preset;
+}
+function renameLayout(id, name) {
+  const preset = layoutById(id);
+  const trimmed = name.trim();
+  if (!preset || !trimmed) {
+    return;
+  }
+  preset.name = trimmed;
+  persistProjectShell();
+}
+function deleteLayout(id) {
+  if (shell.layouts.length < 2) {
+    return;
+  }
+  const index = shell.layouts.findIndex((preset) => preset.id === id);
+  if (index === -1) {
+    return;
+  }
+  shell.layouts.splice(index, 1);
+  if (shell.layout === id) {
+    shell.layout = shell.layouts[0].id;
+  }
+  persistProjectShell();
+}
+function resetLayout(deps) {
+  applyLayout(shell.layout, deps);
+}
+function monacoTheme(theme = shell.theme) {
+  return theme === "light" ? "vs" : "vs-dark";
+}
+function applyChromeTheme() {
+  document.querySelector("sp-theme")?.setAttribute("color", shell.theme);
+  document.documentElement.dataset.theme = shell.theme;
+  loadedMonaco()?.editor.setTheme(monacoTheme());
+}
+function applyDockLayout() {
+  const root = document.documentElement;
+  for (const id of DOCK_IDS) {
+    root.style.setProperty(DOCK_CSS_VAR[id], `${shell.docks[id].size}px`);
+  }
+  const app = document.querySelector("#app");
+  if (!app) {
+    return;
+  }
+  for (const id of DOCK_IDS) {
+    app.classList.toggle(DOCK_CLASS[id], shell.docks[id].collapsed);
+  }
+}
+var _scope = null;
+var _surfaces = [];
+function registerShellSurface(surface) {
+  if (!_surfaces.includes(surface)) {
+    _surfaces.push(surface);
+  }
+}
+function mountShell() {
+  if (_scope) {
+    return;
+  }
+  for (const surface of _surfaces) {
+    surface.mount();
+  }
+  _scope = effectScope();
+  _scope.run(() => {
+    effect(() => {
+      applyDockLayout();
+    });
+    effect(() => {
+      applyChromeTheme();
+    });
+    effect(() => {
+      syncProjectLayouts(workspace.projectRoot);
+    });
+    effect(() => {
+      const root = workspace.projectRoot;
+      workspace.activePaneId;
+      for (const pane of workspace.panes) {
+        pane.id;
+        pane.activeTabId;
+        pane.tabOrder.join("\x00");
+      }
+      if (root) {
+        persistProjectShell();
+      }
+    });
+  });
+}
+function setDockCollapsed(dock, collapsed) {
+  if (shell.docks[dock].collapsed === collapsed) {
+    persistDocks();
+    return;
+  }
+  shell.docks[dock].collapsed = collapsed;
+  persistDocks();
+}
+function toggleDock(dock) {
+  setDockCollapsed(dock, !shell.docks[dock].collapsed);
+}
+function setDockSize(dock, size) {
+  shell.docks[dock].size = size;
+}
+function setActivityTab(tab) {
+  shell.leftTab = tab;
+  setDockCollapsed("left", false);
+  persistDocks();
+}
+function setBottomTab(tab) {
+  shell.bottomTab = tab;
+  setDockCollapsed("bottom", false);
+  persistDocks();
+}
+function setChromeTheme(theme) {
+  if (shell.theme === theme) {
+    return;
+  }
+  shell.theme = theme;
+  setSetting(SETTINGS.theme, theme);
+}
+function toggleActivityTab(tab) {
+  if (tab === shell.leftTab && !shell.docks.left.collapsed) {
+    setDockCollapsed("left", true);
+    return;
+  }
+  setActivityTab(tab);
+}
+function setLayoutSelection(selection) {
+  shell.layoutSelection = selection;
+}
+function resetProjectShell() {
+  Object.assign(shell.git, freshGit());
+  Object.assign(shell.stylebook, freshStylebook());
+  shell.settingsTab = "stylebook";
+  shell.layoutSelection = null;
+  _sessionRoot = null;
+  _layoutRoot = undefined;
+}
+var projectOpen = (ctx) => ctx.project.open;
+function shellViewCommands(deps) {
+  return [
+    {
+      args: argsSchema({
+        tab: enumProperty(NAVIGATOR_PANEL_IDS, "Which Navigator panel to show.")
+      }),
+      category: "View",
+      id: "view.setActivity",
+      level: "application",
+      menus: ["commandbar/overflow", "palette"],
+      group: "4_docks",
+      requires: "an open project",
+      when: projectOpen,
+      aiTool: {
+        description: "Show one of the Navigator panels (Files, Search, Source Control, Languages, Outline, " + "Page, Data, Packages, Insert) and open the Navigator dock if it is closed. Languages is " + "the translation-parity grid, and it exists only in a project that declares two or more " + "locales. Problems is a Bottom dock tab — use show_bottom_tab for it.",
+        name: "show_navigator_panel"
+      },
+      run: (_ctx, args) => {
+        const tab = enumArg("view.setActivity", args, "tab", NAVIGATOR_PANEL_IDS);
+        if (deps.panelAvailable && !deps.panelAvailable(tab)) {
+          throw new RangeError(`command "view.setActivity" argument "tab": "${tab}" names a panel that is registered but not ` + `available right now, so showing it would persist a Navigator tab nothing can draw`);
+        }
+        setActivityTab(tab);
+      },
+      title: "Show Navigator Panel"
+    },
+    {
+      args: argsSchema({
+        tab: enumProperty(INSPECTOR_TAB_IDS, "Which Inspector tab to show.")
+      }),
+      category: "View",
+      id: "view.setRightTab",
+      level: "document",
+      menus: ["palette"],
+      group: "4_docks",
+      requires: "an open document",
+      when: (ctx) => ctx.document.open,
+      run: (_ctx, args) => {
+        deps.setInspectorTab(enumArg("view.setRightTab", args, "tab", INSPECTOR_TAB_IDS));
+      },
+      title: "Show Inspector Tab"
+    },
+    {
+      args: argsSchema({
+        open: booleanProperty("True to show the Navigator dock, false to collapse it.")
+      }),
+      category: "View",
+      id: "view.setNavigator",
+      level: "application",
+      menus: ["palette"],
+      group: "4_docks",
+      run: (_ctx, args) => {
+        setDockCollapsed("left", !booleanArg("view.setNavigator", args, "open"));
+      },
+      title: "Show Navigator Dock"
+    },
+    {
+      args: argsSchema({
+        open: booleanProperty("True to show the Inspector dock, false to collapse it.")
+      }),
+      category: "View",
+      id: "view.setRightPanel",
+      level: "application",
+      menus: ["palette"],
+      group: "4_docks",
+      run: (_ctx, args) => {
+        setDockCollapsed("right", !booleanArg("view.setRightPanel", args, "open"));
+      },
+      title: "Show Inspector Dock"
+    },
+    {
+      args: argsSchema({
+        open: booleanProperty("True to show the Bottom dock, false to collapse it.")
+      }),
+      category: "View",
+      id: "view.setBottomDock",
+      level: "application",
+      menus: ["palette"],
+      group: "4_docks",
+      run: (_ctx, args) => {
+        setDockCollapsed("bottom", !booleanArg("view.setBottomDock", args, "open"));
+      },
+      title: "Show Bottom Dock"
+    },
+    {
+      category: "View",
+      id: "view.toggleBottomDock",
+      keybinding: "mod+j",
+      level: "application",
+      menus: ["commandbar/overflow", "palette"],
+      group: "4_docks",
+      run: () => {
+        toggleDock("bottom");
+      },
+      title: "Toggle Bottom Dock"
+    },
+    {
+      args: argsSchema({
+        tab: enumProperty(BOTTOM_TAB_IDS, "Which Bottom dock tab to show.")
+      }),
+      category: "View",
+      id: "view.setBottomTab",
+      level: "application",
+      menus: ["palette"],
+      group: "4_docks",
+      aiTool: {
+        description: "Show one of the Bottom dock's tabs (Problems, Diff, Logic, Activity) and open the " + "Bottom dock if it is closed.",
+        name: "show_bottom_tab"
+      },
+      run: (_ctx, args) => {
+        const tab = enumArg("view.setBottomTab", args, "tab", BOTTOM_TAB_IDS);
+        if (deps.panelAvailable && !deps.panelAvailable(tab)) {
+          throw new RangeError(`command "view.setBottomTab" argument "tab": "${tab}" names a panel that is registered but not ` + `available right now, so showing it would persist a Bottom dock tab nothing can draw`);
+        }
+        setBottomTab(tab);
+      },
+      title: "Show Bottom Dock Tab"
+    },
+    {
+      args: argsSchema({
+        open: booleanProperty("True to show the Assistant tab, false to step off it.")
+      }),
+      category: "View",
+      id: "view.setAssistant",
+      level: "application",
+      menus: ["never"],
+      group: "4_docks",
+      run: (_ctx, args) => {
+        if (booleanArg("view.setAssistant", args, "open")) {
+          setDockCollapsed("right", false);
+          deps.setInspectorTab("assistant");
+          return;
+        }
+        if (deps.inspectorTab() === "assistant") {
+          deps.setInspectorTab(DEFAULT_INSPECTOR_TAB);
+        }
+      },
+      title: "Show Assistant"
+    },
+    {
+      args: argsSchema({
+        layout: stringProperty("The layout's id — one of this project's saved layouts.")
+      }),
+      category: "View",
+      id: "view.setLayout",
+      level: "application",
+      menus: ["palette"],
+      group: "4_layouts",
+      requires: "an open project",
+      when: projectOpen,
+      aiTool: {
+        description: "Adopt one of the project's named layouts (Write, Design, Build, Ship, or one the user " + "saved): its Navigator panel, its dock widths and visibility, and its Inspector tab.",
+        name: "set_layout"
+      },
+      run: (_ctx, args) => {
+        applyLayout(stringArg("view.setLayout", args, "layout"), deps);
+      },
+      title: "Switch Layout"
+    },
+    {
+      args: argsSchema({
+        name: stringProperty("What to call this arrangement. An existing name is overwritten.")
+      }),
+      category: "View",
+      id: "view.saveLayout",
+      level: "application",
+      menus: ["palette"],
+      group: "4_layouts",
+      requires: "an open project",
+      when: projectOpen,
+      run: (_ctx, args) => {
+        saveLayout(stringArg("view.saveLayout", args, "name"), deps);
+      },
+      title: "Save Layout"
+    },
+    {
+      args: argsSchema({
+        layout: stringProperty("The layout's id."),
+        name: stringProperty("Its new name. The id, and every reference to it, is unchanged.")
+      }),
+      category: "View",
+      id: "view.renameLayout",
+      level: "application",
+      menus: ["palette"],
+      group: "4_layouts",
+      requires: "an open project",
+      when: projectOpen,
+      run: (_ctx, args) => {
+        renameLayout(stringArg("view.renameLayout", args, "layout"), stringArg("view.renameLayout", args, "name"));
+      },
+      title: "Rename Layout"
+    },
+    {
+      args: argsSchema({
+        layout: stringProperty("The layout's id. The last remaining layout is kept.")
+      }),
+      category: "View",
+      id: "view.deleteLayout",
+      level: "application",
+      menus: ["palette"],
+      group: "4_layouts",
+      requires: "an open project",
+      when: projectOpen,
+      run: (_ctx, args) => {
+        deleteLayout(stringArg("view.deleteLayout", args, "layout"));
+      },
+      title: "Delete Layout"
+    },
+    {
+      category: "View",
+      id: "view.resetLayout",
+      level: "application",
+      menus: ["palette"],
+      group: "4_layouts",
+      requires: "an open project",
+      when: projectOpen,
+      run: () => {
+        resetLayout(deps);
+      },
+      title: "Reset Layout"
+    },
+    {
+      args: argsSchema({
+        color: enumProperty(CHROME_THEMES, "The Studio chrome's theme.")
+      }),
+      category: "View",
+      id: "view.setTheme",
+      level: "application",
+      menus: ["palette"],
+      group: "6_appearance",
+      run: (_ctx, args) => {
+        setChromeTheme(enumArg("view.setTheme", args, "color", CHROME_THEMES));
+      },
+      title: "Set Theme"
+    }
+  ];
+}
+function registerShellViewCommands(registry, deps) {
+  registry.registerAll(shellViewCommands(deps));
+}
+
+// src/tabs/project-config.ts
+function serializeProjectConfig(config) {
+  return JSON.stringify(config, null, 2);
+}
+var _bound = null;
+var _detached = null;
+var _committed = null;
+var _seeding = null;
+function openConfigTab() {
+  const tab = workspace.tabs.get(PROJECT_CONFIG_PATH);
+  return tab ? toRaw(tab) : null;
+}
+function unbind() {
+  if (_detached) {
+    disposeTab(_detached);
+    _detached = null;
+  }
+  _bound = null;
+  _committed = null;
+  _seeding = null;
+}
+function seedCommitted() {
+  _seeding ??= (async () => {
+    try {
+      const text = await getPlatform().readFile(PROJECT_CONFIG_PATH);
+      _committed = serializeProjectConfig(JSON.parse(text));
+    } catch {
+      _committed = null;
+    }
+  })();
+  return _seeding;
+}
+function syncProjectState(config) {
+  const state = requireProjectState();
+  if (state.projectConfig === config) {
+    return;
+  }
+  setProjectState({ ...state, projectConfig: config });
+  setWorkspaceProject(workspace.projectRoot, config);
+}
+function liveConfig() {
+  const config = requireProjectState()?.projectConfig;
+  return config ? toRaw(config) : null;
+}
+function replaceContents(target, source) {
+  for (const key of Object.keys(target)) {
+    if (!Object.hasOwn(source, key)) {
+      delete target[key];
+    }
+  }
+  Object.assign(target, source);
+}
+function bind(tab) {
+  _bound = tab;
+  tab.scope.run(() => {
+    effect(() => {
+      const doc = tab.doc.document;
+      if (_bound !== tab || !requireProjectState()) {
+        return;
+      }
+      syncProjectState(toRaw(doc));
+    });
+  });
+  return tab;
+}
+function projectConfigDocument() {
+  const state = requireProjectState();
+  const open = openConfigTab();
+  if (_bound && (_bound !== (open ?? _detached) || toRaw(_bound.doc.document) !== state.projectConfig)) {
+    unbind();
+  }
+  if (_bound) {
+    return _bound;
+  }
+  if (open) {
+    return bind(open);
+  }
+  _detached = createTab({
+    document: state.projectConfig ?? {},
+    documentPath: PROJECT_CONFIG_PATH,
+    id: PROJECT_CONFIG_PATH
+  });
+  return bind(_detached);
+}
+function extensionsKey(config) {
+  return JSON.stringify(config.extensions ?? null);
+}
+async function refreshExtensionSurfaces() {
+  const { loadFormats, refreshExtensionUi, refreshFormats } = await import("./format-host-tgcmfs4p.js");
+  refreshFormats();
+  loadFormats();
+  refreshExtensionUi(getPlatform());
+}
+async function commitProjectConfig(patch) {
+  const live = liveConfig();
+  const tab = projectConfigDocument();
+  await seedCommitted();
+  const current = toRaw(tab.doc.document);
+  const currentText = serializeProjectConfig(current);
+  const rival = live && live !== current && serializeProjectConfig(live) !== currentText ? live : null;
+  if (rival && tab.doc.dirty) {
+    const error = new Error(`${PROJECT_CONFIG_PATH} has unsaved changes in its editor tab`);
+    notify.error(`Could not save ${PROJECT_CONFIG_PATH} — the file is open with unsaved changes. Save or ` + `revert that tab, then make the settings change again.`, { key: `save:${PROJECT_CONFIG_PATH}`, path: PROJECT_CONFIG_PATH, source: "Settings" });
+    return { error, ok: false };
+  }
+  const base = rival ?? current;
+  const next = patch ? { ...base, ...patch } : base;
+  const text = serializeProjectConfig(next);
+  if (!rival && !tab.doc.dirty && text === _committed) {
+    return { ok: true };
+  }
+  const before = extensionsKey(current);
+  transactDoc(tab, (t) => {
+    const doc = t.doc.document;
+    if (rival) {
+      replaceContents(doc, rival);
+    }
+    for (const [key, value] of Object.entries(patch ?? {})) {
+      doc[key] = value;
+    }
+  });
+  const config = toRaw(tab.doc.document);
+  const output = serializeProjectConfig(config);
+  try {
+    await getPlatform().writeFile(PROJECT_CONFIG_PATH, output);
+  } catch (error) {
+    notify.error(`Could not save ${PROJECT_CONFIG_PATH} — ${errorMessage(error)}`, {
+      key: `save:${PROJECT_CONFIG_PATH}`,
+      path: PROJECT_CONFIG_PATH,
+      source: "Settings"
+    });
+    return { error, ok: false };
+  }
+  _committed = output;
+  tab.doc.dirty = false;
+  if (extensionsKey(config) !== before) {
+    await refreshExtensionSurfaces();
+  }
+  return { ok: true };
+}
+async function adoptProjectConfig(config) {
+  if (!requireProjectState()) {
+    setWorkspaceProject(workspace.projectRoot, config);
+    return;
+  }
+  const tab = projectConfigDocument();
+  transactDoc(tab, (t) => replaceContents(t.doc.document, config), { skipHistory: true });
+  tab.doc.dirty = false;
+  await seedCommitted();
+  _committed = serializeProjectConfig(config);
+}
+
+// src/site-context.ts
+function getEffectiveMedia(docMedia) {
+  const siteMedia = projectState?.projectConfig?.$media;
+  if (!siteMedia) {
+    return docMedia || {};
+  }
+  if (!docMedia) {
+    return { ...siteMedia };
+  }
+  return { ...siteMedia, ...docMedia };
+}
+function getEffectiveStyle(docStyle) {
+  const siteStyle = projectState?.projectConfig?.style;
+  if (!siteStyle) {
+    return docStyle || {};
+  }
+  if (!docStyle) {
+    return { ...siteStyle };
+  }
+  const merged = { ...siteStyle };
+  for (const [k, v] of Object.entries(docStyle)) {
+    merged[k] = typeof v === "object" && v !== null && typeof merged[k] === "object" && merged[k] !== null ? { ...merged[k], ...v } : v;
+  }
+  return merged;
+}
+function getEffectiveImports(docImports) {
+  const siteImports = projectState?.projectConfig?.imports;
+  if (!siteImports) {
+    return docImports || {};
+  }
+  if (!docImports) {
+    return { ...siteImports };
+  }
+  return { ...siteImports, ...docImports };
+}
+function getEffectiveElements(docElements) {
+  const siteElements = projectState?.projectConfig?.$elements;
+  if (!siteElements?.length) {
+    return docElements || [];
+  }
+  if (!docElements?.length) {
+    return [...siteElements];
+  }
+  const seen = new Set;
+  const merged = [];
+  for (const entry of [...siteElements, ...docElements]) {
+    const key = typeof entry === "string" ? entry : entry?.$ref;
+    if (key && !seen.has(key)) {
+      seen.add(key);
+      merged.push(entry);
+    }
+  }
+  return merged;
+}
+function getEffectiveHead(docHead) {
+  const siteHead = projectState?.projectConfig?.$head;
+  if (!siteHead?.length) {
+    return docHead || [];
+  }
+  if (!docHead?.length) {
+    return [...siteHead];
+  }
+  const seen = new Set;
+  const merged = [];
+  for (const entry of [...siteHead, ...docHead]) {
+    const key = String(entry?.attributes?.href || entry?.attributes?.src || "") || JSON.stringify(entry);
+    if (!seen.has(key)) {
+      seen.add(key);
+      merged.push(entry);
+    }
+  }
+  return merged;
+}
+function getEffectiveLocales() {
+  const config = projectState?.projectConfig;
+  return config ? resolveI18n(config).i18n : null;
+}
+var layoutCache = new Map;
+function invalidateLayoutCache() {
+  layoutCache.clear();
+}
+function getEffectiveLayoutPath(docLayout) {
+  if (docLayout === false) {
+    return null;
+  }
+  const defaultLayout = projectState?.projectConfig?.defaults?.layout;
+  return docLayout || defaultLayout || null;
+}
+async function resolveLayoutDoc(layoutPath) {
+  const normalized = layoutPath.replace(/^\.\//, "");
+  if (layoutCache.has(normalized)) {
+    return structuredClone(layoutCache.get(normalized));
+  }
+  try {
+    const platform = getPlatform();
+    const content = await platform.readFile(normalized);
+    const doc = JSON.parse(content);
+    layoutCache.set(normalized, doc);
+    return structuredClone(doc);
+  } catch {
+    return null;
+  }
+}
+function distributePageIntoLayout(layoutDoc, pageDoc) {
+  const pageChildren = pageDoc.children ?? [];
+  const children = Array.isArray(pageChildren) ? pageChildren : [];
+  const named = new Map;
+  const defaults = [];
+  for (const child of children) {
+    const slotName = typeof child === "object" ? child.attributes?.slot : undefined;
+    if (typeof child === "object" && typeof slotName === "string" && slotName) {
+      if (!named.has(slotName)) {
+        named.set(slotName, []);
+      }
+      named.get(slotName).push(child);
+    } else {
+      defaults.push(child);
+    }
+  }
+  fillSlots(layoutDoc, named, defaults);
+  if (pageDoc.state) {
+    layoutDoc.state = { ...layoutDoc.state, ...pageDoc.state };
+  }
+  if (pageDoc.$media) {
+    layoutDoc.$media = { ...layoutDoc.$media, ...pageDoc.$media };
+  }
+  if (pageDoc.style) {
+    layoutDoc.style = { ...layoutDoc.style, ...pageDoc.style };
+  }
+  if (pageDoc.attributes) {
+    layoutDoc.attributes = { ...layoutDoc.attributes, ...pageDoc.attributes };
+  }
+  return layoutDoc;
+}
+function fillSlots(node, named, defaults) {
+  if (!node || typeof node !== "object") {
+    return;
+  }
+  if (!Array.isArray(node.children)) {
+    return;
+  }
+  const newChildren = [];
+  for (const child of node.children) {
+    if (child && typeof child === "object" && child.tagName === "slot") {
+      const slotName = child.attributes?.name;
+      if (typeof slotName === "string" && slotName && named.has(slotName)) {
+        newChildren.push(...named.get(slotName));
+        named.delete(slotName);
+      } else if (!slotName && defaults.length > 0) {
+        newChildren.push(...defaults);
+      } else if (Array.isArray(child.children)) {
+        newChildren.push(...child.children);
+      }
+    } else {
+      if (typeof child !== "string") {
+        fillSlots(child, named, defaults);
+      }
+      newChildren.push(child);
+    }
+  }
+  node.children = newChildren;
+}
+async function updateSiteConfig(patch) {
+  const result = await commitProjectConfig(patch);
+  if (!result.ok) {
+    throw result.error;
+  }
+}
+
+export { serializeProjectConfig, commitProjectConfig, adoptProjectConfig, getEffectiveMedia, getEffectiveStyle, getEffectiveImports, getEffectiveElements, getEffectiveHead, getEffectiveLocales, invalidateLayoutCache, getEffectiveLayoutPath, resolveLayoutDoc, distributePageIntoLayout, updateSiteConfig, restoreSession, requireNavigatorPanelId, DEFAULT_INSPECTOR_TAB, isInspectorTabId, BOTTOM_TAB_IDS, DEFAULT_BOTTOM_TAB, isBottomTabId, CHROME_THEMES, DOCK_IDS, DOCK_DEFAULT_SIZES, setPaneSplit, shell, persistDocks, persistedSession, markSessionRestored, flushSession, monacoTheme, registerShellSurface, mountShell, setDockCollapsed, setDockSize, setActivityTab, setBottomTab, setChromeTheme, toggleActivityTab, setLayoutSelection, resetProjectShell, registerShellViewCommands };
+
+//# debugId=A24625062C5DB75E64756E2164756E21
+//# sourceMappingURL=studio-hbtp0eh1.js.map