@hienlh/ppm 0.18.9 → 0.18.11

package/src/web/stores/panel-utils.ts

@@ -29,6 +29,42 @@ export const DOCK_PANEL_ID = "__dock__";
  */
 export const DOCK_ALLOWED_TAB_TYPES = new Set<TabType>(["terminal", "system-monitor"]);
 
+// ---------------------------------------------------------------------------
+// Floating-window panels
+// ---------------------------------------------------------------------------
+
+/**
+ * Prefix of the reserved panel IDs that host tabs detached into a floating window.
+ * Like the dock, such a panel lives in the `panels` map but is intentionally excluded
+ * from `grid`, so all grid math (MAX_ROWS, split, column count) ignores it. The
+ * window id is the suffix, which is what ties the panel to its window.
+ */
+export const WINDOW_PANEL_PREFIX = "__win__:";
+
+/** Panel ID hosting the tabs of the floating window `windowId`. */
+export function windowPanelId(windowId: string): string {
+  return `${WINDOW_PANEL_PREFIX}${windowId}`;
+}
+
+export function isWindowPanelId(panelId: string): boolean {
+  return panelId.startsWith(WINDOW_PANEL_PREFIX);
+}
+
+/** The window a panel belongs to, or null when it is not a window panel. */
+export function windowIdFromPanelId(panelId: string): string | null {
+  return isWindowPanelId(panelId) ? panelId.slice(WINDOW_PANEL_PREFIX.length) || null : null;
+}
+
+/** Create the off-grid panel for a floating window, with an empty tab list. */
+export function createWindowPanel(windowId: string): Panel {
+  return {
+    id: windowPanelId(windowId),
+    tabs: [],
+    activeTabId: null,
+    tabHistory: [],
+  };
+}
+
 /** Visible/height state for the dock — stored per-project via projectDock map. */
 export interface DockState {
   visible: boolean;

package/src/web/stores/window-panel-actions.ts

@@ -0,0 +1,211 @@
+/**
+ * Action factories for tabs that live in a floating window, for usePanelStore.
+ *
+ * Extracted to keep panel-store.ts near its size budget, mirroring dock-actions.ts.
+ * This module is the ONLY writer of `__win__:` panels, which is what keeps the
+ * invariant cheap to check: a window panel exists in the `panels` map and never in
+ * `grid`, so no grid math (MAX_ROWS, split, column count) can ever see one.
+ *
+ * Second invariant, enforced after every move: `focusedPanelId` is never a window
+ * panel. `moveTab` focuses its target unconditionally, and `resolvePanel()` sends the
+ * next `openTab()` with no explicit panel to the focused one — leaving focus on the
+ * window would silently open new tabs inside it.
+ */
+import type { StoreApi } from "zustand";
+import type { Panel } from "./panel-utils";
+import {
+  createWindowPanel,
+  isWindowPanelId,
+  windowIdFromPanelId,
+  windowPanelId,
+} from "./panel-utils";
+import { persistDock } from "./dock-actions";
+import { loadWindowPanels, saveWindowPanels } from "./window-panel-persistence";
+import { useWindowStore } from "@/components/floating-window/window-store";
+import { MAX_WINDOWS } from "@/components/floating-window/window-geometry";
+import type { PanelStore } from "./panel-store";
+
+type Set = StoreApi<PanelStore>["setState"];
+type Get = StoreApi<PanelStore>["getState"];
+
+/** Tab types that never detach — the monitor already owns a window kind of its own. */
+const NON_POPPABLE_TAB_TYPES = new Set(["system-monitor"]);
+
+/**
+ * A grid panel to hold focus: the preferred one when it is still in the grid, else the
+ * first grid panel. Returns null only for an empty grid (nothing can be focused).
+ */
+function gridFocusTarget(grid: string[][], preferred?: string | null): string | null {
+  const flat = grid.flat();
+  if (preferred && flat.includes(preferred)) return preferred;
+  return flat[0] ?? null;
+}
+
+/**
+ * Persist both halves of a window-panel mutation: the global window-panel blob and the
+ * active project's layout (the other side of a move is a grid panel). persistDock writes
+ * the whole PanelLayout — grid panels, focus and dock — not just the dock.
+ */
+export function persistWindowPanelChange(get: Get): void {
+  saveWindowPanels(get().panels);
+  persistDock(get);
+}
+
+/**
+ * Keep a floating window and its panel in lockstep after a tab left the panel: an empty
+ * tab-host window has no way back to a tab, so it closes with its panel.
+ *
+ * Every way a tab can leave — closed, moved to the grid or the dock, dragged out — ends
+ * here, so the panel and the window are created and destroyed by the same two functions.
+ * Both halves are idempotent: a panel already dropped by the caller and a window already
+ * closed are both no-ops.
+ */
+export function syncWindowPanel(set: Set, get: Get, panelId: string): void {
+  if (get().panels[panelId]?.tabs.length) {
+    saveWindowPanels(get().panels);
+    return;
+  }
+  set((s) => {
+    const { [panelId]: _dropped, ...rest } = s.panels;
+    return { panels: rest };
+  });
+  saveWindowPanels(get().panels);
+  const windowId = windowIdFromPanelId(panelId);
+  if (windowId) useWindowStore.getState().close(windowId);
+}
+
+/**
+ * Merge the persisted window panels into the flat panels map, once per session.
+ *
+ * They are global, so this runs on the first project load and never again — a later
+ * switch must not resurrect a panel the user has since re-docked. Live panels win the
+ * merge; a stale persisted twin can only be older than what is in memory.
+ */
+let windowPanelsHydrated = false;
+
+export function hydrateWindowPanels(set: Set, get: Get): void {
+  if (windowPanelsHydrated) return;
+  windowPanelsHydrated = true;
+  const loaded = loadWindowPanels();
+  if (Object.keys(loaded).length === 0) return;
+  set({ panels: { ...loaded, ...get().panels } });
+}
+
+/**
+ * Detach a tab into a new floating window. Returns the window id, or null when the
+ * request is rejected — in which case nothing is mutated and the caller reports it.
+ */
+export function makePopOutTab(set: Set, get: Get) {
+  return function popOutTab(tabId: string, fromPanelId: string): string | null {
+    // The window layer is desktop-only; on mobile a detached tab would be invisible.
+    if (get().isMobile()) return null;
+
+    const from = get().panels[fromPanelId];
+    const tab = from?.tabs.find((t) => t.id === tabId);
+    if (!tab || NON_POPPABLE_TAB_TYPES.has(tab.type)) return null;
+
+    // Pre-check the cap: at the cap `open()` focuses the oldest window and returns ITS
+    // id, which would attach this tab to an unrelated window.
+    const windowStore = useWindowStore.getState();
+    if (Object.keys(windowStore.windows).length >= MAX_WINDOWS) return null;
+
+    const windowId = windowStore.open("tab-host", { originPanelId: fromPanelId, title: tab.title });
+    const panelId = windowPanelId(windowId);
+    set((s) => ({ panels: { ...s.panels, [panelId]: createWindowPanel(windowId) } }));
+
+    get().moveTab(tabId, fromPanelId, panelId);
+
+    const focus = gridFocusTarget(get().grid, fromPanelId);
+    if (focus) set({ focusedPanelId: focus });
+    persistWindowPanelChange(get);
+    return windowId;
+  };
+}
+
+/**
+ * Send every tab of a window's panel back to the grid and drop the panel.
+ *
+ * Called from the window body's layout-effect cleanup, so it covers every close path
+ * (titlebar ×, keyboard close, a programmatic `close()`), and is a no-op once the panel
+ * is gone — closing an emptied window re-enters here and must not resurrect anything.
+ */
+export function makeRedockFromWindow(set: Set, get: Get) {
+  return function redockFromWindow(windowId: string, originPanelId?: string | null): void {
+    const panelId = windowPanelId(windowId);
+    const panel = get().panels[panelId];
+    if (!panel) return;
+
+    const target = redockTarget(get(), originPanelId);
+    if (target) {
+      for (const tab of [...panel.tabs]) get().moveTab(tab.id, panelId, target);
+    }
+
+    set((s) => {
+      const { [panelId]: _dropped, ...rest } = s.panels;
+      // moveTab focused the target; re-assert it here so the resolved target wins even
+      // when the last moveTab picked a different one (or none ran at all).
+      const focus = gridFocusTarget(s.grid, target ?? s.focusedPanelId);
+      return focus ? { panels: rest, focusedPanelId: focus } : { panels: rest };
+    });
+    persistWindowPanelChange(get);
+
+    // The body can unmount without the window closing: the whole desktop window layer is
+    // dropped below the `md` breakpoint, which re-docks the tabs but would leave the
+    // window entry in `ppm-windows` — restored empty and unfillable on the way back, and
+    // burning one of MAX_WINDOWS on every reload. `close()` is a no-op when the window is
+    // already gone (the ×/keyboard paths), and re-entry here returns early: the panel is
+    // deleted above.
+    useWindowStore.getState().close(windowId);
+  };
+}
+
+/**
+ * Where a detached tab goes home to: its origin panel while that still exists, else the
+ * focused panel when it is a grid panel, else the first grid panel. The origin may be the
+ * dock (a terminal parked there before it was detached) but never another window.
+ */
+function redockTarget(state: PanelStore, originPanelId?: string | null): string | null {
+  if (originPanelId && state.panels[originPanelId] && !isWindowPanelId(originPanelId)) {
+    return originPanelId;
+  }
+  return gridFocusTarget(state.grid, state.focusedPanelId);
+}
+
+/**
+ * Drop a project's tabs from every window panel, returning the panels map to commit and
+ * the windows whose panel is now empty. Used when a project is reloaded: its grid panels
+ * are discarded, and a window still showing one of its tabs would outlive the project.
+ */
+export function stripProjectFromWindowPanels(
+  panels: Record<string, Panel>,
+  projectName: string,
+): { panels: Record<string, Panel>; windowIdsToClose: string[] } {
+  const next: Record<string, Panel> = { ...panels };
+  const windowIdsToClose: string[] = [];
+
+  for (const [id, panel] of Object.entries(panels)) {
+    if (!isWindowPanelId(id)) continue;
+    const tabs = panel.tabs.filter((t) => t.projectId !== projectName);
+    if (tabs.length === panel.tabs.length) continue;
+
+    const windowId = windowIdFromPanelId(id);
+    if (tabs.length === 0) {
+      delete next[id];
+      if (windowId) windowIdsToClose.push(windowId);
+      continue;
+    }
+    const ids = new Set(tabs.map((t) => t.id));
+    const tabHistory = panel.tabHistory.filter((h) => ids.has(h));
+    next[id] = {
+      ...panel,
+      tabs,
+      tabHistory,
+      activeTabId:
+        panel.activeTabId && ids.has(panel.activeTabId)
+          ? panel.activeTabId
+          : (tabHistory[tabHistory.length - 1] ?? tabs[tabs.length - 1]!.id),
+    };
+  }
+
+  return { panels: next, windowIdsToClose };
+}

package/src/web/stores/window-panel-persistence.ts

@@ -0,0 +1,115 @@
+/**
+ * localStorage persistence for the off-grid panels that host detached tabs.
+ *
+ * Deliberately its own global key instead of a field inside `PanelLayout`: floating
+ * windows are global (one `ppm-windows` blob for the whole app) while a PanelLayout is
+ * per project. Folding a global panel into a per-project blob is what forced the
+ * merge/union machinery the dock needs on every project switch. Consequence, accepted:
+ * window panels are not synced to the server workspace — the same limitation the window
+ * geometry already has.
+ */
+import type { Panel } from "./panel-utils";
+import { isWindowPanelId } from "./panel-utils";
+import type { Tab, TabType } from "./tab-store";
+
+const STORAGE_KEY = "ppm-window-panels";
+
+/**
+ * Tab types a persisted window panel may bring back. Written as an exhaustive record so
+ * adding a TabType is a compile error here rather than a silent gap. `system-monitor` is
+ * false because it can never be popped out; everything else a crafted blob names is
+ * rejected, so it cannot mount an arbitrary component in the privileged window slot.
+ */
+const POPPABLE_TAB_TYPES: Record<TabType, boolean> = {
+  terminal: true,
+  chat: true,
+  editor: true,
+  database: true,
+  sqlite: true,
+  postgres: true,
+  "git-diff": true,
+  settings: true,
+  extension: true,
+  "extension-webview": true,
+  "conflict-editor": true,
+  "system-monitor": false,
+  "git-log": true,
+  "ai-resource": true,
+  group: true,
+};
+
+export function isPoppableTabType(type: unknown): type is TabType {
+  return typeof type === "string" && POPPABLE_TAB_TYPES[type as TabType] === true;
+}
+
+function isValidTab(value: unknown): value is Tab {
+  if (!value || typeof value !== "object") return false;
+  const t = value as Record<string, unknown>;
+  return typeof t.id === "string" && !!t.id && typeof t.title === "string" && isPoppableTabType(t.type);
+}
+
+/** Keep only the window panels out of the full panels map, dropping empty ones. */
+function selectWindowPanels(panels: Record<string, Panel>): Record<string, Panel> {
+  const out: Record<string, Panel> = {};
+  for (const [id, panel] of Object.entries(panels)) {
+    if (!isWindowPanelId(id) || panel.tabs.length === 0) continue;
+    out[id] = panel;
+  }
+  return out;
+}
+
+export function saveWindowPanels(panels: Record<string, Panel>): void {
+  try {
+    const windowPanels = selectWindowPanels(panels);
+    if (Object.keys(windowPanels).length === 0) localStorage.removeItem(STORAGE_KEY);
+    else localStorage.setItem(STORAGE_KEY, JSON.stringify(windowPanels));
+  } catch {
+    /* quota exceeded or storage disabled — never block a tab move over persistence */
+  }
+}
+
+/** Read persisted window panels, dropping anything malformed or not allowed in a window. */
+export function loadWindowPanels(): Record<string, Panel> {
+  let raw: string | null = null;
+  try {
+    raw = localStorage.getItem(STORAGE_KEY);
+  } catch {
+    return {};
+  }
+  if (!raw) return {};
+
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return {};
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
+
+  const out: Record<string, Panel> = {};
+  for (const [id, value] of Object.entries(parsed as Record<string, unknown>)) {
+    if (!isWindowPanelId(id) || !value || typeof value !== "object") continue;
+    const panel = value as Record<string, unknown>;
+    if (!Array.isArray(panel.tabs)) continue;
+    const tabs = panel.tabs.filter(isValidTab);
+    if (tabs.length === 0) continue;
+    const ids = new Set(tabs.map((t) => t.id));
+    const tabHistory = Array.isArray(panel.tabHistory)
+      ? panel.tabHistory.filter((h): h is string => typeof h === "string" && ids.has(h))
+      : [];
+    const activeTabId =
+      typeof panel.activeTabId === "string" && ids.has(panel.activeTabId)
+        ? panel.activeTabId
+        : (tabHistory[tabHistory.length - 1] ?? tabs[tabs.length - 1]!.id);
+    out[id] = { id, tabs, activeTabId, tabHistory };
+  }
+  return out;
+}
+
+export function clearWindowPanels(): void {
+  try {
+    localStorage.removeItem(STORAGE_KEY);
+  } catch {
+    /* storage disabled */
+  }
+}

package/src/web/stores/window-panel-reconcile.ts

@@ -0,0 +1,97 @@
+/**
+ * Pure reconciliation between the off-grid window panels and the windows that are
+ * actually alive.
+ *
+ * The two halves are persisted separately (windows are global geometry, panels hold live
+ * tabs), so a reload can land on either side alone: a panel whose window blob was dropped
+ * would hide its tabs with no way to reach them, and a window whose panel is gone would
+ * float empty. Mobile is the same case by construction — the window layer renders
+ * nothing there, so no window is live and every detached tab comes back to the grid.
+ */
+import type { Panel } from "./panel-utils";
+import { isWindowPanelId, windowIdFromPanelId, windowPanelId } from "./panel-utils";
+import type { Tab } from "./tab-store";
+
+export interface ReconcileInput {
+  panels: Record<string, Panel>;
+  grid: string[][];
+  focusedPanelId: string;
+  /** Ids of the tab-host windows currently in the window store. */
+  liveWindowIds: readonly string[];
+}
+
+export interface ReconcileResult {
+  panels: Record<string, Panel>;
+  focusedPanelId: string;
+  /** Tab-host windows with no panel behind them — the caller closes these. */
+  windowIdsToClose: string[];
+  /** True when `panels`/`focusedPanelId` differ from the input and must be committed. */
+  changed: boolean;
+}
+
+/**
+ * Identity of one reconcile run, for the caller's once-per-run guard.
+ *
+ * The viewport class belongs in the key, not just the project: crossing the `md`
+ * breakpoint unmounts or remounts the entire window layer, which is precisely the split
+ * this reconciles. Keying on the project alone lets the first desktop run suppress the
+ * mobile repair that must follow it (and the reverse on the way back).
+ */
+export function reconcileRunKey(project: string, isMobile: boolean): string {
+  return `${project}|${isMobile}`;
+}
+
+/** Append tabs to a panel without disturbing which tab the user was last looking at. */
+function appendTabs(target: Panel, tabs: Tab[]): Panel {
+  const known = new Set(target.tabs.map((t) => t.id));
+  const incoming = tabs.filter((t) => !known.has(t.id));
+  if (incoming.length === 0) return target;
+  const merged = [...target.tabs, ...incoming];
+  return {
+    ...target,
+    tabs: merged,
+    tabHistory: [...target.tabHistory, ...incoming.map((t) => t.id)],
+    activeTabId: target.activeTabId ?? merged[merged.length - 1]!.id,
+  };
+}
+
+export function reconcileTabHostWindows(input: ReconcileInput): ReconcileResult {
+  const { grid, liveWindowIds } = input;
+  const live = new Set(liveWindowIds);
+  const flat = grid.flat();
+
+  const panels = { ...input.panels };
+  let focusedPanelId = input.focusedPanelId;
+  let changed = false;
+
+  // Panels whose window is gone: move the tabs back into the grid and drop the panel.
+  // With no grid panel to receive them the panel is left untouched — losing the tabs
+  // would be worse than a panel that reconciles on the next load.
+  const target = flat.includes(focusedPanelId) ? focusedPanelId : flat[0];
+  for (const [panelId, panel] of Object.entries(input.panels)) {
+    if (!isWindowPanelId(panelId)) continue;
+    const windowId = windowIdFromPanelId(panelId);
+    if (windowId && live.has(windowId)) continue;
+    if (!target) continue;
+    const receiver = panels[target];
+    if (!receiver) continue;
+    panels[target] = appendTabs(receiver, panel.tabs);
+    delete panels[panelId];
+    changed = true;
+  }
+
+  // Windows with no panel: nothing can ever render in them.
+  const windowIdsToClose = liveWindowIds.filter((id) => !panels[windowPanelId(id)]);
+
+  // Focus must sit on a grid panel, or the next tab opened with no explicit panel lands
+  // off-grid (inside a window, or nowhere at all once its panel is deleted).
+  if (!flat.includes(focusedPanelId)) {
+    const fallback = flat[0];
+    if (fallback) {
+      focusedPanelId = fallback;
+      changed = true;
+    }
+  }
+
+  return { panels, focusedPanelId, windowIdsToClose, changed };
+}

package/src/web/styles/globals.css

@@ -74,13 +74,15 @@
 /*
  * Default token values (Aurora Dark). Present before JS runs so the first
  * paint is correct; apply-theme overrides these on <html> at runtime.
+ * Surfaces stay opaque here for the same reason they are in the theme itself:
+ * a translucent panel lets content bleed through dropdowns and sheets.
  */
 :root {
   --bg: radial-gradient(120% 120% at 0% 0%, #0e1626 0%, #0a0e17 55%, #080b12 100%);
   --bg-solid: #0a0e17;
-  --rail: rgba(255, 255, 255, 0.04);
-  --panel: rgba(255, 255, 255, 0.04);
-  --panel-2: rgba(20, 28, 46, 0.85);
+  --rail: #141820;
+  --panel: #141820;
+  --panel-2: #141c2e;
   --border: rgba(255, 255, 255, 0.12);
   --border-soft: rgba(255, 255, 255, 0.06);
   --text: #eaeefb;

package/src/web/theme/builtin/aurora.ts

@@ -51,16 +51,19 @@ export const auroraLight: PpmTheme = {
   mode: "light",
   swatch: ["#f3f7ff", "#2f6bff", "#7c4dff"],
   syntax: { shikiTheme: "github-light" },
+  // Surfaces are opaque on purpose: translucent panels let underlying content
+  // bleed through dropdowns, sheets and stacked windows and hurt legibility.
+  // Values are the old glass tints pre-blended over bgSolid.
   mobileOverrides: {
-    panel: "rgba(255,255,255,0.82)",
-    panel2: "rgba(255,255,255,0.96)",
+    panel: "#ffffff",
+    panel2: "#ffffff",
   },
   tokens: {
     bg: "radial-gradient(120% 120% at 0% 0%, #f3f7ff 0%, #eef2fb 55%, #e8edf7 100%)",
     bgSolid: "#f3f7ff",
-    rail: "rgba(255,255,255,0.62)",
-    panel: "rgba(255,255,255,0.62)",
-    panel2: "rgba(255,255,255,0.94)",
+    rail: "#fafcff",
+    panel: "#fafcff",
+    panel2: "#ffffff",
     border: "rgba(20,30,60,0.12)",
     borderSoft: "rgba(20,30,60,0.07)",
     text: "#0f1a33",

package/dist/web/assets/ai-resource-editor-DFCuNe-P.js

@@ -1 +0,0 @@
-import{o as e}from"./rolldown-runtime-FhOqtrmT.js";import{S as t,x as n}from"./vendor-markdown-Ls5AcU91.js";import"./vendor-ui-CaeeFO0B.js";import{t as r}from"./save-C4z1p51e.js";import{s as i}from"./api-client-BSB14J4w.js";import"./vendor-mermaid-DrwG0NYt.js";import"./settings-store-C20lqh0G.js";import{n as a}from"./utils-DoY4yTP-.js";import{$n as o,A as s,M as c,N as l,On as u,Qn as d,j as f,k as p,kn as m,s as h}from"./index-CerSxGdf.js";import{t as g}from"./use-monaco-theme-CGucu3fb.js";var _=e(t(),1),v=n();function y({metadata:e}){let t=e?.filePath,n=e?.name,a=e?.resourceType??`skill`,y=e?.scope??`user`,x=e?.readOnly===!0,S=e?.shadowed===!0,C=e?.shadowedBy,w=e?.project??``,[T,E]=(0,_.useState)(``),[D,O]=(0,_.useState)(``),[k,A]=(0,_.useState)(!0),[j,M]=(0,_.useState)(null),[N,P]=(0,_.useState)(!1),F=g(),I=(0,_.useRef)(``),L=T!==D;(0,_.useEffect)(()=>{let e=!1;return A(!0),M(null),c(t,w).then(t=>{e||(E(t.content),O(t.content),I.current=t.content)}).catch(t=>{e||M(t.message)}).finally(()=>{e||A(!1)}),()=>{e=!0}},[t,w]);let R=(0,_.useCallback)(async()=>{if(x||N)return;let e=I.current;if(e!==D){P(!0);try{await l(t,e,w),O(e),E(e),i.success(`Saved`),f.getState().reload()}catch(e){i.error(e.message)}finally{P(!1)}}},[t,w,D,x,N]);(0,_.useEffect)(()=>{let e=e=>{(e.ctrlKey||e.metaKey)&&e.key.toLowerCase()===`s`&&(e.preventDefault(),R())};return window.addEventListener(`keydown`,e),()=>window.removeEventListener(`keydown`,e)},[R]);let z=s[a];return(0,v.jsxs)(`div`,{className:`flex h-full flex-col`,children:[(0,v.jsxs)(`div`,{className:`flex items-center gap-2 border-b border-border px-3 py-2 shrink-0`,children:[(0,v.jsx)(z,{className:`size-4 text-text-subtle`}),(0,v.jsx)(`span`,{className:`text-sm font-semibold`,children:n}),(0,v.jsx)(p,{scope:y}),L&&!x&&(0,v.jsx)(`span`,{className:`size-1.5 rounded-full bg-primary`,title:`Unsaved changes`}),(0,v.jsx)(`div`,{className:`flex-1`}),(0,v.jsxs)(`span`,{className:`hidden sm:block text-[11px] text-text-subtle`,children:[a,` · markdown`]}),!x&&(0,v.jsxs)(v.Fragment,{children:[(0,v.jsxs)(`button`,{onClick:()=>E(D),disabled:!L||N,className:`flex items-center gap-1 rounded px-2 py-1 text-xs text-text-secondary hover:bg-surface-elevated disabled:opacity-40`,children:[(0,v.jsx)(u,{className:`size-3.5`}),` Revert`]}),(0,v.jsxs)(`button`,{onClick:()=>void R(),disabled:!L||N,className:`flex items-center gap-1 rounded bg-primary px-2.5 py-1 text-xs font-medium text-primary-foreground hover:bg-primary/90 disabled:opacity-40`,children:[N?(0,v.jsx)(o,{className:`size-3.5 animate-spin`}):(0,v.jsx)(r,{className:`size-3.5`}),` Save`]})]})]}),x&&(0,v.jsx)(b,{icon:d,tone:`muted`,children:`Bundled resource — read-only. Duplicate it (from the AI Resources panel) to make an editable copy.`}),S&&C&&(0,v.jsxs)(b,{icon:m,tone:`warn`,children:[`This `,a,` is overridden by another “`,C.name,`” from a higher-priority source (`,C.source,`). It is currently inactive.`]}),(0,v.jsx)(`div`,{className:`min-h-0 flex-1`,children:k?(0,v.jsx)(`div`,{className:`flex h-full items-center justify-center`,children:(0,v.jsx)(o,{className:`size-5 animate-spin text-primary`})}):j?(0,v.jsx)(`div`,{className:`p-6 text-center text-sm text-destructive`,children:j}):(0,v.jsx)(h,{height:`100%`,language:`markdown`,theme:F,value:T,onChange:e=>{let t=e??``;I.current=t,E(t)},options:{readOnly:x,minimap:{enabled:!1},fontSize:13,wordWrap:`on`,scrollBeyondLastLine:!1,lineNumbers:`on`}})})]})}function b({icon:e,tone:t,children:n}){return(0,v.jsxs)(`div`,{className:a(`flex items-start gap-2 px-3 py-2 text-[12px] shrink-0 border-b border-border`,t===`warn`?`bg-amber-500/10 text-amber-300`:`bg-surface-elevated text-text-secondary`),children:[(0,v.jsx)(e,{className:`mt-0.5 size-3.5 shrink-0`}),(0,v.jsx)(`span`,{children:n})]})}export{y as AiResourceEditor};

package/dist/web/assets/api-client-CzABTreM.js

@@ -1 +0,0 @@
-import"./vendor-markdown-Ls5AcU91.js";import"./vendor-ui-CaeeFO0B.js";import{i as e,n as t}from"./api-client-BSB14J4w.js";export{t as api,e as projectUrl};

package/dist/web/assets/api-settings-nblja3Rk.js

@@ -1 +0,0 @@
-import"./vendor-markdown-Ls5AcU91.js";import"./vendor-ui-CaeeFO0B.js";import"./api-client-BSB14J4w.js";import{v as e}from"./api-settings-kQHV6pYZ.js";export{e as updateDeviceName};

package/dist/web/assets/architecture-PBZL5I3N-C7ra20CE.js

@@ -1 +0,0 @@
-import{K as e}from"./vendor-mermaid-DrwG0NYt.js";export{e as createArchitectureServices};