sh3-core 0.11.4 → 0.11.6

package/dist/apps/lifecycle.test.js

@@ -5,7 +5,7 @@ import { launchApp, returnToHome, unregisterApp } from './lifecycle';
 import { registerApp } from './registry.svelte';
 import { registerShard } from '../shards/activate.svelte';
 import { presetManager } from '../overlays/presets';
-import { layoutStore } from '../layout/store.svelte';
+import { layoutStore, resetActivePresetToDefault } from '../layout/store.svelte';
 import LayoutRenderer from '../layout/LayoutRenderer.svelte';
 import { renderWithShell } from '../__test__/render';
 import { registerView } from '../shards/registry';
@@ -307,3 +307,213 @@ describe('installPackage evict-before-register (simulated via registerLoadedBund
         expect((_b = registeredShards.get('S')) === null || _b === void 0 ? void 0 : _b.manifest.version).toBe('1.0.1');
     });
 });
+// ---------------------------------------------------------------------------
+// Scenario C.1 — resetActivePresetToDefault rebuilds the active preset
+// ---------------------------------------------------------------------------
+describe('resetActivePresetToDefault — scenario C.1 happy path', () => {
+    beforeEach(resetFramework);
+    it('replaces the active preset tree with a fresh copy of initialLayout', async () => {
+        var _a;
+        registerApp(makeApp({
+            manifest: makeAppManifest({ id: 'reset-1' }),
+            initialLayout: [
+                {
+                    name: 'main',
+                    tree: makeTree(makeTabsNode([
+                        makeTabEntry({ slotId: 'a', label: 'A' }),
+                        makeTabEntry({ slotId: 'b', label: 'B' }),
+                    ])),
+                },
+            ],
+        }));
+        await launchApp('reset-1');
+        // Mutate the live tree: change activeTab and add a float.
+        const root = layoutStore.root;
+        expect(root === null || root === void 0 ? void 0 : root.type).toBe('tabs');
+        if ((root === null || root === void 0 ? void 0 : root.type) === 'tabs')
+            root.activeTab = 1;
+        layoutStore.tree.floats.push({
+            id: 'float-test',
+            content: makeSlotNode('floated'),
+            position: { x: 10, y: 10 },
+            size: { w: 100, h: 100 },
+        });
+        expect(layoutStore.tree.floats.length).toBe(1);
+        resetActivePresetToDefault();
+        const resetRoot = layoutStore.root;
+        expect(resetRoot === null || resetRoot === void 0 ? void 0 : resetRoot.type).toBe('tabs');
+        if ((resetRoot === null || resetRoot === void 0 ? void 0 : resetRoot.type) === 'tabs') {
+            expect((_a = resetRoot.activeTab) !== null && _a !== void 0 ? _a : 0).toBe(0);
+            expect(resetRoot.tabs.map((t) => t.slotId)).toEqual(['a', 'b']);
+        }
+        expect(layoutStore.tree.floats.length).toBe(0);
+    });
+});
+// ---------------------------------------------------------------------------
+// Scenario C.2 — reset falls back when active preset name no longer exists
+// ---------------------------------------------------------------------------
+describe('resetActivePresetToDefault — scenario C.2 missing-preset fallback', () => {
+    beforeEach(resetFramework);
+    it('falls back to canonical[0] and updates activePreset when the stored name is gone', async () => {
+        // Launch with two presets, switch to the second, then simulate the app
+        // dropping that preset by re-registering it with a different layout.
+        registerApp(makeApp({
+            manifest: makeAppManifest({ id: 'reset-2' }),
+            initialLayout: [
+                { name: 'first', tree: makeTree(makeSlotNode('x')) },
+                { name: 'second', tree: makeTree(makeSlotNode('y')) },
+            ],
+        }));
+        await launchApp('reset-2');
+        presetManager.switch('second');
+        expect(presetManager.active()).toBe('second');
+        // Replace the registry entry with a version that no longer declares
+        // 'second'. We mutate registeredApps directly because the public
+        // `unregisterApp` would also detach. This mimics the in-process
+        // version-update scenario for the reset code path.
+        const { registeredApps } = await import('./registry.svelte');
+        const existing = registeredApps.get('reset-2');
+        registeredApps.set('reset-2', Object.assign(Object.assign({}, existing), { initialLayout: [
+                { name: 'first', tree: makeTree(makeSlotNode('x')) },
+                // 'second' removed
+            ] }));
+        resetActivePresetToDefault();
+        expect(presetManager.active()).toBe('first');
+        // The previously-active 'second' preset is still in the blob (we
+        // don't garbage-collect dropped presets); only its name was vacated.
+        expect(layoutStore.root).toMatchObject({ type: 'slot', slotId: 'x' });
+    });
+});
+// ---------------------------------------------------------------------------
+// Scenario C.3 — reset throws when no app is attached
+// ---------------------------------------------------------------------------
+describe('resetActivePresetToDefault — scenario C.3 no app attached', () => {
+    beforeEach(resetFramework);
+    it('throws a useful error when called with no attached app', () => {
+        expect(() => resetActivePresetToDefault()).toThrow(/no app attached/);
+    });
+});
+// ---------------------------------------------------------------------------
+// Scenario C.4 — reset re-scopes slot-host refcount holds
+// ---------------------------------------------------------------------------
+describe('resetActivePresetToDefault — scenario C.4 slot-host hold accounting', () => {
+    beforeEach(resetFramework);
+    it('updates appEntry.heldSlotIds to match the rebuilt tree', async () => {
+        var _a, _b;
+        const { __inspectAppEntryHeldSlotIdsForTest } = await import('../layout/store.svelte');
+        registerApp(makeApp({
+            manifest: makeAppManifest({ id: 'reset-3' }),
+            initialLayout: [
+                {
+                    name: 'main',
+                    tree: makeTree(makeTabsNode([
+                        makeTabEntry({ slotId: 't-a', label: 'A' }),
+                        makeTabEntry({ slotId: 't-b', label: 'B' }),
+                    ])),
+                },
+            ],
+        }));
+        await launchApp('reset-3');
+        expect((_a = __inspectAppEntryHeldSlotIdsForTest()) === null || _a === void 0 ? void 0 : _a.slice().sort()).toEqual(['t-a', 't-b']);
+        // Mutate the live tree by replacing the docked node with a different
+        // single slot. After reset, the held set must return to the default
+        // pair, which proves the old single hold was released and the
+        // canonical pair was re-acquired.
+        layoutStore.tree.docked = makeSlotNode('mutated');
+        resetActivePresetToDefault();
+        expect((_b = __inspectAppEntryHeldSlotIdsForTest()) === null || _b === void 0 ? void 0 : _b.slice().sort()).toEqual(['t-a', 't-b']);
+    });
+});
+// ---------------------------------------------------------------------------
+// Scenario C.5 — sh3.app.reset-layout is registered with the right shape
+// ---------------------------------------------------------------------------
+describe('sh3coreShard — sh3.app.reset-layout registration', () => {
+    beforeEach(resetFramework);
+    it('exposes a "Reset Current Layout" action scoped to app, palette-only', async () => {
+        // Register and activate the sh3core pseudo-shard the same way bootstrap()
+        // would — tests don't run bootstrap, so the shard's actions wouldn't
+        // otherwise be present.
+        const { sh3coreShard } = await import('../sh3core-shard/sh3coreShard.svelte');
+        const { activateShard } = await import('../shards/activate.svelte');
+        const { addAutostartShard } = await import('../actions/state.svelte');
+        registerShard(sh3coreShard);
+        // Mirror what bootstrap() does: mark the framework shard as autostart so
+        // its 'app'-scope actions are treated as ambient inside any app.
+        addAutostartShard(sh3coreShard.manifest.id);
+        await activateShard(sh3coreShard.manifest.id);
+        registerApp(makeApp({
+            manifest: makeAppManifest({ id: 'reset-action-1' }),
+            initialLayout: [{ name: 'main', tree: makeTree(makeSlotNode('x')) }],
+        }));
+        await launchApp('reset-action-1');
+        const { shell } = await import('../shellRuntime.svelte');
+        const actions = shell.actions.listActive();
+        const reset = actions.find((a) => a.id === 'sh3.app.reset-layout');
+        expect(reset).toBeDefined();
+        expect(reset === null || reset === void 0 ? void 0 : reset.label).toBe('Reset Current Layout');
+        expect(reset === null || reset === void 0 ? void 0 : reset.paletteItem).toBe(true);
+        expect(reset === null || reset === void 0 ? void 0 : reset.contextItem).toBe(false);
+        expect(reset === null || reset === void 0 ? void 0 : reset.effectiveShortcut).toBeNull();
+    });
+    it('hides "app"-scope actions after returnToHome', async () => {
+        const { sh3coreShard } = await import('../sh3core-shard/sh3coreShard.svelte');
+        const { activateShard } = await import('../shards/activate.svelte');
+        const { addAutostartShard } = await import('../actions/state.svelte');
+        registerShard(sh3coreShard);
+        addAutostartShard(sh3coreShard.manifest.id);
+        await activateShard(sh3coreShard.manifest.id);
+        registerApp(makeApp({
+            manifest: makeAppManifest({ id: 'reset-action-2' }),
+            initialLayout: [{ name: 'main', tree: makeTree(makeSlotNode('x')) }],
+        }));
+        await launchApp('reset-action-2');
+        const { shell } = await import('../shellRuntime.svelte');
+        expect(shell.actions.listActive().some((a) => a.id === 'sh3.app.reset-layout')).toBe(true);
+        await returnToHome();
+        expect(shell.actions.listActive().some((a) => a.id === 'sh3.app.reset-layout')).toBe(false);
+    });
+});
+// ---------------------------------------------------------------------------
+// breadcrumbAppId — lingers across returnToHome (distinct from lastAppState)
+// ---------------------------------------------------------------------------
+describe('breadcrumbAppId', () => {
+    beforeEach(resetFramework);
+    it('starts null when no app has launched this session', async () => {
+        const { getBreadcrumbAppId } = await import('./registry.svelte');
+        expect(getBreadcrumbAppId()).toBeNull();
+    });
+    it('is set to the launched app id', async () => {
+        const { getBreadcrumbAppId } = await import('./registry.svelte');
+        registerShard(makeShard({ manifest: makeShardManifest({ id: 'shard-A' }) }));
+        registerApp(makeApp({
+            manifest: makeAppManifest({ id: 'app-bc1', requiredShards: ['shard-A'] }),
+        }));
+        await launchApp('app-bc1');
+        expect(getBreadcrumbAppId()).toBe('app-bc1');
+    });
+    it('lingers across returnToHome (does NOT clear like lastAppState)', async () => {
+        const { getBreadcrumbAppId } = await import('./registry.svelte');
+        const { readLastApp } = await import('./lifecycle');
+        registerShard(makeShard({ manifest: makeShardManifest({ id: 'shard-A' }) }));
+        registerApp(makeApp({
+            manifest: makeAppManifest({ id: 'app-bc2', requiredShards: ['shard-A'] }),
+        }));
+        await launchApp('app-bc2');
+        await returnToHome();
+        expect(getBreadcrumbAppId()).toBe('app-bc2');
+        expect(readLastApp()).toBeNull();
+    });
+    it('overwrites on a subsequent launch', async () => {
+        const { getBreadcrumbAppId } = await import('./registry.svelte');
+        registerShard(makeShard({ manifest: makeShardManifest({ id: 'shard-A' }) }));
+        registerApp(makeApp({
+            manifest: makeAppManifest({ id: 'app-bc3a', requiredShards: ['shard-A'] }),
+        }));
+        registerApp(makeApp({
+            manifest: makeAppManifest({ id: 'app-bc3b', requiredShards: ['shard-A'] }),
+        }));
+        await launchApp('app-bc3a');
+        await launchApp('app-bc3b');
+        expect(getBreadcrumbAppId()).toBe('app-bc3b');
+    });
+});

package/dist/apps/registry.svelte.d.ts

@@ -13,6 +13,22 @@ export declare const registeredApps: Map<string, App>;
 export declare const activeApp: {
     id: string | null;
 };
+/**
+ * Most recently launched app id this session. Distinct from
+ * `lastAppState` in `lifecycle.ts` (which is persisted to the user zone
+ * for boot, and cleared by `returnToHome`). The breadcrumb pointer
+ * survives `returnToHome` so the top-bar BrandSlot can render
+ * `SH3 > [App Name]` and let the user one-click back into the app.
+ *
+ * In-memory only — page reload resets it to null. No persistence.
+ */
+export declare const breadcrumbApp: {
+    id: string | null;
+};
+/** Read the breadcrumb app id. `null` when no app has launched this session. */
+export declare function getBreadcrumbAppId(): string | null;
+/** @internal — test helper; resets the breadcrumb to null. */
+export declare function __resetBreadcrumbForTest(): void;
 /**
  * Register (or re-register) an app with the framework.
  *
@@ -38,5 +54,5 @@ export declare function getActiveApp(): AppManifest | null;
  * activate hook. Not re-exported through `api.ts`.
  */
 export declare function getRegisteredApp(id: string): App | undefined;
-/** Test-only reset: clear registered apps and the active-app pointer. */
+/** Test-only reset: clear registered apps, active-app pointer, and breadcrumb. */
 export declare function __resetAppRegistryForTest(): void;

package/dist/apps/registry.svelte.js

@@ -20,6 +20,24 @@ export const registeredApps = $state(new Map());
  * most one active app at a time.
  */
 export const activeApp = $state({ id: null });
+/**
+ * Most recently launched app id this session. Distinct from
+ * `lastAppState` in `lifecycle.ts` (which is persisted to the user zone
+ * for boot, and cleared by `returnToHome`). The breadcrumb pointer
+ * survives `returnToHome` so the top-bar BrandSlot can render
+ * `SH3 > [App Name]` and let the user one-click back into the app.
+ *
+ * In-memory only — page reload resets it to null. No persistence.
+ */
+export const breadcrumbApp = $state({ id: null });
+/** Read the breadcrumb app id. `null` when no app has launched this session. */
+export function getBreadcrumbAppId() {
+    return breadcrumbApp.id;
+}
+/** @internal — test helper; resets the breadcrumb to null. */
+export function __resetBreadcrumbForTest() {
+    breadcrumbApp.id = null;
+}
 /**
  * Register (or re-register) an app with the framework.
  *
@@ -57,8 +75,9 @@ export function getActiveApp() {
 export function getRegisteredApp(id) {
     return registeredApps.get(id);
 }
-/** Test-only reset: clear registered apps and the active-app pointer. */
+/** Test-only reset: clear registered apps, active-app pointer, and breadcrumb. */
 export function __resetAppRegistryForTest() {
     registeredApps.clear();
     activeApp.id = null;
+    breadcrumbApp.id = null;
 }

package/dist/apps/types.d.ts

@@ -1,6 +1,28 @@
 import type { LayoutNode, LayoutTree, LayoutPreset } from '../layout/types';
 import type { ZoneSchema, ZoneManager } from '../state/types';
 import type { StateZones } from '../state/zones.svelte';
+/**
+ * One menu bar container ("File", "Edit", etc.). Apps declare these in
+ * `AppManifest.menus`; when omitted, sh3-core uses DEFAULT_MENU_CONTAINERS.
+ * Items reach a container by setting `Action.menuItem` to its `id`.
+ */
+export interface MenuContainer {
+    /** Container id referenced by Action.menuItem. */
+    id: string;
+    /** Display label shown in the menu bar. */
+    label: string;
+    /** Optional lucide icon name. */
+    icon?: string;
+    /** Icon placement relative to the label. Default: 'before'. */
+    iconPosition?: 'before' | 'after';
+    /**
+     * Optional explicit ordering. When omitted, declaration order in the
+     * `AppManifest.menus` array is used. Containers with `order` defined
+     * sort first (ascending); ties and undefined fall back to declaration
+     * order.
+     */
+    order?: number;
+}
 /**
  * Static description of an app as observed by the framework at runtime.
  * `version` is always present here: externally installed apps have it
@@ -46,6 +68,12 @@ export interface AppManifest {
      * in a later plan alongside the server-side sync runtime.
      */
     permissions?: string[];
+    /**
+     * Optional menu bar container list. When present, fully replaces the
+     * canonical fallback (file, edit, view, window, help) for this app.
+     * When absent, the canonical fallback is used. See MenuContainer.
+     */
+    menus?: MenuContainer[];
 }
 /**
  * Context object passed to `App.activate`. Provides app-scoped state zones

package/dist/layout/store.svelte.d.ts

@@ -23,6 +23,26 @@ export declare function attachApp(app: App): void;
  * only and let renderers own all refcounts.
  */
 export declare function acquireAppSlotHolds(): void;
+/**
+ * Rebuild the currently-attached app's active preset from a fresh copy
+ * of `app.initialLayout`. Discards in-place customizations (split sizes,
+ * tab order, drops, floats) and re-scopes slot-host refcount holds so
+ * the pool tears down hosts the new tree no longer references.
+ *
+ * The active preset name is preserved unless the app's initialLayout no
+ * longer declares it (the app shipped a new version that dropped the
+ * preset name); in that case the active preset is updated to the first
+ * canonical preset.
+ *
+ * Used by the `sh3.app.reset-layout` action — a recovery affordance
+ * available from the command palette only. Other presets are left alone;
+ * the user's customizations on them survive.
+ *
+ * Note: this re-scopes holds for the reset path only. The
+ * `presetManager.switch` slot-hold leak (TODO above on
+ * `acquireAppSlotHolds`) is a separate concern.
+ */
+export declare function resetActivePresetToDefault(): void;
 /**
  * Detach the currently-attached app. Releases its refcount holds; the
  * pool's microtask cleanup drops the pooled hosts if they also have no
@@ -63,3 +83,10 @@ export declare const layoutStore: {
  * tests import this submodule path directly.
  */
 export declare function __resetLayoutStoreForTest(): void;
+/**
+ * Test-only inspection: returns a shallow copy of the currently-attached
+ * app's held slot ids, in acquisition order. Returns `null` when no app
+ * is attached. Not exported from `src/index.ts` — tests import this
+ * submodule path directly.
+ */
+export declare function __inspectAppEntryHeldSlotIdsForTest(): string[] | null;

package/dist/layout/store.svelte.js

@@ -34,6 +34,7 @@ import { acquireSlotHost, releaseSlotHost } from './slotHostPool.svelte';
 import { normalizeInitialLayout } from './presets';
 import { collectTreeSlotRefs } from './tree-walk';
 import { bindPresetBlob, unbindPresetBlob } from '../overlays/presets';
+import { getRegisteredApp } from '../apps/registry.svelte';
 // ---------- orphan cleanup of pre-phase-8 shell layout key ----------------
 // Legacy pre-phase-8 orphan cleanup. The literal '__shell__' here is
 // intentional — it clears data written under the old reserved id before
@@ -168,6 +169,59 @@ export function acquireAppSlotHolds() {
         appEntry.heldSlotIds.push(slotId);
     }
 }
+/**
+ * Rebuild the currently-attached app's active preset from a fresh copy
+ * of `app.initialLayout`. Discards in-place customizations (split sizes,
+ * tab order, drops, floats) and re-scopes slot-host refcount holds so
+ * the pool tears down hosts the new tree no longer references.
+ *
+ * The active preset name is preserved unless the app's initialLayout no
+ * longer declares it (the app shipped a new version that dropped the
+ * preset name); in that case the active preset is updated to the first
+ * canonical preset.
+ *
+ * Used by the `sh3.app.reset-layout` action — a recovery affordance
+ * available from the command palette only. Other presets are left alone;
+ * the user's customizations on them survive.
+ *
+ * Note: this re-scopes holds for the reset path only. The
+ * `presetManager.switch` slot-hold leak (TODO above on
+ * `acquireAppSlotHolds`) is a separate concern.
+ */
+export function resetActivePresetToDefault() {
+    if (!appEntry) {
+        throw new Error('resetActivePresetToDefault: no app attached');
+    }
+    const app = getRegisteredApp(appEntry.appId);
+    if (!app) {
+        throw new Error(`resetActivePresetToDefault: attached app "${appEntry.appId}" not in registry`);
+    }
+    const canonical = normalizeInitialLayout(app.initialLayout);
+    const blob = appEntry.proxy;
+    const targetName = blob.activePreset;
+    let target = canonical.find((p) => p.name === targetName);
+    if (!target) {
+        target = canonical[0];
+        blob.activePreset = target.name;
+    }
+    // Release old slot holds before swapping the tree so the pool's
+    // microtask sees no live refs and tears down hosts that the new
+    // tree doesn't re-acquire.
+    for (const slotId of appEntry.heldSlotIds) {
+        releaseSlotHost(slotId);
+    }
+    appEntry.heldSlotIds = [];
+    // Deep-clone so the canonical object isn't aliased with future
+    // attaches or with the app's source `LayoutPreset` objects.
+    const freshTree = structuredClone(target.variants.default);
+    blob.presets[blob.activePreset].default = freshTree;
+    // Re-acquire holds against the new tree (mirrors acquireAppSlotHolds).
+    const refs = collectTreeSlotRefs(freshTree);
+    for (const { slotId, viewId, label, meta } of refs) {
+        acquireSlotHost(slotId, viewId, label, meta);
+        appEntry.heldSlotIds.push(slotId);
+    }
+}
 /**
  * Detach the currently-attached app. Releases its refcount holds; the
  * pool's microtask cleanup drops the pooled hosts if they also have no
@@ -275,3 +329,12 @@ export function __resetLayoutStoreForTest() {
     HOME_TREE.floats.length = 0;
     HOME_TREE.docked = HOME_LAYOUT;
 }
+/**
+ * Test-only inspection: returns a shallow copy of the currently-attached
+ * app's held slot ids, in acquisition order. Returns `null` when no app
+ * is attached. Not exported from `src/index.ts` — tests import this
+ * submodule path directly.
+ */
+export function __inspectAppEntryHeldSlotIdsForTest() {
+    return appEntry ? [...appEntry.heldSlotIds] : null;
+}

package/dist/overlays/ConfirmDialog.svelte

@@ -0,0 +1,138 @@
+<script lang="ts">
+  /*
+   * ConfirmDialog — small reusable confirmation primitive for destructive
+   * or otherwise non-trivial actions. Mounted via modalManager.open():
+   *
+   *   modalManager.open(ConfirmDialog, {
+   *     title: 'Reset layout?',
+   *     body: 'This discards your customizations.',
+   *     confirmLabel: 'Reset',
+   *     confirmTone: 'danger',
+   *     onConfirm: () => doReset(),
+   *   });
+   *
+   * Backdrop click does NOT dismiss (no dismissOnBackdrop on the modal).
+   * Escape dismisses via the modal manager's shared listener.
+   * Default focus is the Cancel button so destructive actions don't fire on
+   * stray Enter presses.
+   */
+
+  let {
+    title,
+    body,
+    confirmLabel = 'Confirm',
+    cancelLabel = 'Cancel',
+    confirmTone = 'default',
+    onConfirm,
+    onCancel,
+    close,
+  }: {
+    title: string;
+    body: string;
+    confirmLabel?: string;
+    cancelLabel?: string;
+    confirmTone?: 'default' | 'danger';
+    onConfirm: () => void | Promise<void>;
+    onCancel?: () => void;
+    close: () => void;
+  } = $props();
+
+  let cancelBtn: HTMLButtonElement | undefined = $state();
+  let busy = $state(false);
+
+  $effect(() => {
+    cancelBtn?.focus();
+  });
+
+  async function handleConfirm(): Promise<void> {
+    if (busy) return;
+    busy = true;
+    try {
+      await onConfirm();
+    } finally {
+      close();
+    }
+  }
+
+  function handleCancel(): void {
+    if (busy) return;
+    onCancel?.();
+    close();
+  }
+</script>
+
+<div class="confirm-dialog">
+  <div class="confirm-dialog-title">{title}</div>
+  <div class="confirm-dialog-body">{body}</div>
+  <div class="confirm-dialog-actions">
+    <button
+      type="button"
+      class="confirm-dialog-btn confirm-dialog-btn-cancel"
+      data-confirm-dialog-cancel
+      bind:this={cancelBtn}
+      onclick={handleCancel}
+      disabled={busy}
+    >
+      {cancelLabel}
+    </button>
+    <button
+      type="button"
+      class="confirm-dialog-btn"
+      class:confirm-dialog-btn-danger={confirmTone === 'danger'}
+      class:confirm-dialog-btn-default={confirmTone === 'default'}
+      data-confirm-dialog-confirm
+      onclick={handleConfirm}
+      disabled={busy}
+    >
+      {confirmLabel}
+    </button>
+  </div>
+</div>
+
+<style>
+  .confirm-dialog {
+    display: flex;
+    flex-direction: column;
+    gap: 16px;
+    padding: 20px 24px;
+    min-width: 360px;
+    max-width: 480px;
+  }
+  .confirm-dialog-title {
+    font-size: 16px;
+    font-weight: 600;
+    color: var(--shell-fg);
+  }
+  .confirm-dialog-body {
+    font-size: 13px;
+    color: var(--shell-fg-muted, var(--shell-fg));
+    line-height: 1.5;
+  }
+  .confirm-dialog-actions {
+    display: flex;
+    justify-content: flex-end;
+    gap: 8px;
+    margin-top: 4px;
+  }
+  .confirm-dialog-btn {
+    font-size: 13px;
+    padding: 6px 14px;
+    border-radius: var(--shell-radius-sm, 4px);
+    border: 1px solid var(--shell-border-strong);
+    background: transparent;
+    color: var(--shell-fg);
+    cursor: pointer;
+  }
+  .confirm-dialog-btn:disabled {
+    opacity: 0.6;
+    cursor: not-allowed;
+  }
+  .confirm-dialog-btn-default {
+    background: var(--shell-bg-elevated);
+  }
+  .confirm-dialog-btn-danger {
+    background: transparent;
+    color: var(--shell-error, #d32f2f);
+    border-color: var(--shell-error, #d32f2f);
+  }
+</style>

package/dist/overlays/ConfirmDialog.svelte.d.ts

@@ -0,0 +1,13 @@
+type $$ComponentProps = {
+    title: string;
+    body: string;
+    confirmLabel?: string;
+    cancelLabel?: string;
+    confirmTone?: 'default' | 'danger';
+    onConfirm: () => void | Promise<void>;
+    onCancel?: () => void;
+    close: () => void;
+};
+declare const ConfirmDialog: import("svelte").Component<$$ComponentProps, {}, "">;
+type ConfirmDialog = ReturnType<typeof ConfirmDialog>;
+export default ConfirmDialog;

package/dist/overlays/ConfirmDialog.test.d.ts

@@ -0,0 +1 @@
+export {};