sh3-core 0.11.2 → 0.11.6

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 {};

package/dist/overlays/ConfirmDialog.test.js

@@ -0,0 +1,123 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { tick } from 'svelte';
+import { modalManager } from './modal';
+import { registerLayerRoot, unregisterLayerRoot } from './roots';
+import ConfirmDialog from './ConfirmDialog.svelte';
+function makeLayerRoot() {
+    const el = document.createElement('div');
+    el.style.position = 'relative';
+    document.body.appendChild(el);
+    registerLayerRoot('modal', el);
+    return el;
+}
+function teardownLayerRoot(el) {
+    unregisterLayerRoot('modal');
+    el.remove();
+}
+describe('ConfirmDialog', () => {
+    let layerRoot;
+    beforeEach(() => {
+        layerRoot = makeLayerRoot();
+    });
+    afterEach(() => {
+        modalManager.closeAll();
+        teardownLayerRoot(layerRoot);
+    });
+    it('renders title and body', async () => {
+        modalManager.open(ConfirmDialog, {
+            title: 'Reset layout?',
+            body: 'This discards your customizations.',
+            onConfirm: () => { },
+        });
+        await tick();
+        const box = layerRoot.querySelector('.modal-box');
+        expect(box.textContent).toContain('Reset layout?');
+        expect(box.textContent).toContain('This discards your customizations.');
+    });
+    it('Cancel button calls onCancel and closes', async () => {
+        const onCancel = vi.fn();
+        const onConfirm = vi.fn();
+        modalManager.open(ConfirmDialog, {
+            title: 't',
+            body: 'b',
+            onCancel,
+            onConfirm,
+        });
+        await tick();
+        const cancelBtn = layerRoot.querySelector('[data-confirm-dialog-cancel]');
+        cancelBtn.click();
+        await tick();
+        expect(onCancel).toHaveBeenCalledOnce();
+        expect(onConfirm).not.toHaveBeenCalled();
+        expect(layerRoot.querySelector('.sh3-modal-host')).toBeNull();
+    });
+    it('Confirm button calls onConfirm and closes', async () => {
+        const onConfirm = vi.fn();
+        modalManager.open(ConfirmDialog, {
+            title: 't',
+            body: 'b',
+            onConfirm,
+        });
+        await tick();
+        const confirmBtn = layerRoot.querySelector('[data-confirm-dialog-confirm]');
+        confirmBtn.click();
+        await tick();
+        expect(onConfirm).toHaveBeenCalledOnce();
+        expect(layerRoot.querySelector('.sh3-modal-host')).toBeNull();
+    });
+    it('awaits async onConfirm before closing', async () => {
+        let resolveFn = () => { };
+        const onConfirm = vi.fn(() => new Promise((resolve) => {
+            resolveFn = resolve;
+        }));
+        modalManager.open(ConfirmDialog, {
+            title: 't',
+            body: 'b',
+            onConfirm,
+        });
+        await tick();
+        const confirmBtn = layerRoot.querySelector('[data-confirm-dialog-confirm]');
+        confirmBtn.click();
+        await tick();
+        // Modal still open — onConfirm hasn't resolved yet.
+        expect(layerRoot.querySelector('.sh3-modal-host')).not.toBeNull();
+        resolveFn();
+        await tick();
+        await tick();
+        expect(layerRoot.querySelector('.sh3-modal-host')).toBeNull();
+    });
+    it('confirmTone: "danger" applies the danger class to the confirm button', async () => {
+        modalManager.open(ConfirmDialog, {
+            title: 't',
+            body: 'b',
+            confirmTone: 'danger',
+            onConfirm: () => { },
+        });
+        await tick();
+        const confirmBtn = layerRoot.querySelector('[data-confirm-dialog-confirm]');
+        expect(confirmBtn.classList.contains('confirm-dialog-btn-danger')).toBe(true);
+    });
+    it('uses provided confirmLabel and cancelLabel', async () => {
+        modalManager.open(ConfirmDialog, {
+            title: 't',
+            body: 'b',
+            confirmLabel: 'Wipe',
+            cancelLabel: 'Keep',
+            onConfirm: () => { },
+        });
+        await tick();
+        expect(layerRoot.querySelector('[data-confirm-dialog-confirm]').textContent).toContain('Wipe');
+        expect(layerRoot.querySelector('[data-confirm-dialog-cancel]').textContent).toContain('Keep');
+    });
+    it('default focus is the Cancel button', async () => {
+        modalManager.open(ConfirmDialog, {
+            title: 't',
+            body: 'b',
+            onConfirm: () => { },
+        });
+        await tick();
+        await tick(); // focus is set in $effect after mount
+        const cancelBtn = layerRoot.querySelector('[data-confirm-dialog-cancel]');
+        expect(document.activeElement).toBe(cancelBtn);
+    });
+});

package/dist/overlays/FloatFrame.svelte

@@ -109,7 +109,7 @@
     position: absolute;
     display: flex;
     flex-direction: column;
-    background: var(--shell-grad-bg-elevated, var(--shell-bg-elevated, #1e1e1e));
+    background: var(--shell-grad-bg-elevated, var(--shell-bg-elevated));
     color: var(--shell-fg);
     border: 1px solid var(--shell-border-strong);
     border-radius: var(--shell-radius);
@@ -121,7 +121,7 @@
     align-items: center;
     justify-content: space-between;
     padding: 4px 8px;
-    background: var(--shell-bg, #111);
+    background: var(--shell-grad-bg-sunken, var(--shell-bg-sunken));
     cursor: move;
     user-select: none;
     border-bottom: 1px solid var(--shell-border-strong);

package/dist/overlays/ToastItem.svelte

@@ -66,9 +66,9 @@
   .toast-message { flex: 1; }
 
   .toast-info    { border-left-color: var(--shell-accent); }
-  .toast-success { border-left-color: #5cb176; }
-  .toast-warn    { border-left-color: #d6a84a; }
-  .toast-error   { border-left-color: #d06060; }
+  .toast-success { border-left-color: var(--shell-success); }
+  .toast-warn    { border-left-color: var(--shell-warning); }
+  .toast-error   { border-left-color: var(--shell-error); }
 
   @keyframes toast-in {
     from { opacity: 0; transform: translateY(8px); }

package/dist/primitives/base.css

@@ -15,8 +15,8 @@ input[type="submit"],
 input[type="reset"],
 .shell-base-button {
   padding: 6px 14px;
-  background: var(--shell-accent, #6ea8fe);
-  color: var(--shell-fg, #fff);
+  background: var(--shell-accent);
+  color: var(--shell-fg-on-accent);
   border: none;
   border-radius: var(--shell-radius);
   cursor: pointer;
@@ -113,7 +113,7 @@ input[type="radio"].shell-base-radio {
   content: "";
   width: 8px;
   height: 8px;
-  background: #fff;
+  background: var(--shell-fg-on-accent);
   clip-path: polygon(14% 44%, 0 60%, 40% 100%, 100% 20%, 85% 8%, 38% 70%);
 }
 
@@ -122,7 +122,7 @@ input[type="radio"].shell-base-radio {
   width: 6px;
   height: 6px;
   border-radius: 50%;
-  background: #fff;
+  background: var(--shell-fg-on-accent);
 }
 
 .shell-base-check:focus-visible,
@@ -167,7 +167,7 @@ input[type="checkbox"].shell-base-switch {
 .shell-base-switch:checked { background: var(--shell-accent); }
 .shell-base-switch:checked::before {
   transform: translateX(12px);
-  background: #fff;
+  background: var(--shell-fg-on-accent);
 }
 
 .shell-base-switch:focus-visible {

package/dist/sh3core-shard/sh3coreShard.svelte.js

@@ -24,10 +24,13 @@
 import { mount, unmount } from 'svelte';
 import ShellHome from './ShellHome.svelte';
 import KeysAndPeers from '../shell/views/KeysAndPeers.svelte';
+import ConfirmDialog from '../overlays/ConfirmDialog.svelte';
 import { VERSION } from '../version';
 import { __setBindingsZone } from '../actions/bindings-store';
 import { registeredApps } from '../apps/registry.svelte';
 import { launchApp } from '../apps/lifecycle';
+import { resetActivePresetToDefault } from '../layout/store.svelte';
+import { modalManager } from '../overlays/modal';
 export const sh3coreShard = {
     manifest: {
         id: '__sh3core__',
@@ -57,6 +60,23 @@ export const sh3coreShard = {
                 import('../actions/listeners').then(({ openPalette }) => openPalette());
             },
         });
+        ctx.actions.register({
+            id: 'sh3.app.reset-layout',
+            label: 'Reset Current Layout',
+            scope: ['app'],
+            paletteItem: true,
+            contextItem: false,
+            run() {
+                modalManager.open(ConfirmDialog, {
+                    title: 'Reset layout?',
+                    body: 'This discards the current arrangement of the active preset and ' +
+                        'rebuilds it from the app default. Floats will be removed.',
+                    confirmLabel: 'Reset',
+                    confirmTone: 'danger',
+                    onConfirm: () => resetActivePresetToDefault(),
+                });
+            },
+        });
         const factory = {
             mount(container, _context) {
                 const instance = mount(ShellHome, { target: container });

package/dist/shell-shard/shellShard.svelte.js

@@ -176,10 +176,6 @@ export function makeShellApiForTest() {
 export const shellShard = {
     manifest,
     activate(ctx) {
-        if (!ctx.isAdmin) {
-            // Non-admin: don't expose the view. Nothing to register.
-            return;
-        }
         registerV1Verbs(ctx);
         const shell = makeShellApi(ctx);
         // The AZERTY `²` key (top-left on FR keyboards, below Escape) opens the

package/dist/shellRuntime.svelte.d.ts

@@ -6,7 +6,9 @@ import { type ToastManager } from './overlays/toast';
 import { type FloatManager } from './overlays/float';
 import { type PresetManager } from './overlays/presets';
 import type { ConflictsApi } from './conflicts/api';
+import type { ColorApi } from './color/api';
 import { type OpenContextMenuOpts, type OpenPaletteOpts } from './actions/listeners';
+import type { ActiveActionDescriptor } from './actions/types';
 /**
  * The process-wide shell singleton exposed to shards and the shell's own
  * internal code. Provides state zone creation and overlay managers.
@@ -32,6 +34,8 @@ export interface Shell {
     presets: PresetManager;
     /** Conflict manager view. Shell-owned modal for conflict arbitration. */
     conflicts: ConflictsApi;
+    /** Color picker. Falls back to native <input type="color"> when no picker shard is contributed. */
+    color: ColorApi;
     /** Actions facade — rebind keys, query bindings, open menus/palette. */
     actions: ShellActionsApi;
 }
@@ -50,6 +54,22 @@ export interface ShellActionsApi {
     openContextMenu(opts: OpenContextMenuOpts): void;
     /** Open the command palette, optionally pre-filled. */
     openPalette(opts?: OpenPaletteOpts): void;
+    /**
+     * Snapshot of all currently-active actions with resolved shortcuts
+     * and badges. One descriptor per action id, in tier-innermost-first
+     * order. See {@link ActiveActionDescriptor}.
+     *
+     * Non-reactive: returns a fresh array on each call. Subscribe via
+     * {@link ShellActionsApi.onActiveChange} to re-call when the active
+     * set or shortcuts change.
+     */
+    listActive(): ActiveActionDescriptor[];
+    /**
+     * Subscribe to active-set changes: action registration/unregistration,
+     * active app / view / focus transitions, selection changes, user
+     * binding edits. Returns an unsubscribe function.
+     */
+    onActiveChange(cb: () => void): () => void;
 }
 /** The process-wide shell instance. Framework-internal code uses this directly; shards receive a scoped view via `ShardContext`. */
 export declare const shell: Shell;

package/dist/shellRuntime.svelte.js

@@ -21,9 +21,12 @@ import { toastManager } from './overlays/toast';
 import { floatManager } from './overlays/float';
 import { presetManager } from './overlays/presets';
 import { conflictsApi } from './conflicts/shell-api';
+import { colorApi } from './color/shell-api';
 import { loadUserBindings, saveUserBinding } from './actions/bindings-store';
 import { openContextMenu as listenersOpenContextMenu, openPalette as listenersOpenPalette, } from './actions/listeners';
-import { setUserBindings, getLiveDispatcherState } from './actions/state.svelte';
+import { setUserBindings, getLiveDispatcherState, onActiveChange as onActiveChangeState, __notifyActiveChange, } from './actions/state.svelte';
+import { listActions, onActionsChange } from './actions/registry';
+import { listActiveFromEntries } from './actions/listActive';
 const shellActions = {
     async rebind(appId, actionId, shortcut) {
         await saveUserBinding(appId, actionId, shortcut);
@@ -49,6 +52,17 @@ const shellActions = {
     },
     openContextMenu: listenersOpenContextMenu,
     openPalette: listenersOpenPalette,
+    listActive() {
+        return listActiveFromEntries(listActions(), getLiveDispatcherState());
+    },
+    onActiveChange(cb) {
+        const offState = onActiveChangeState(cb);
+        const offRegistry = onActionsChange(() => { __notifyActiveChange(); });
+        return () => {
+            offState();
+            offRegistry();
+        };
+    },
 };
 /** The process-wide shell instance. Framework-internal code uses this directly; shards receive a scoped view via `ShardContext`. */
 export const shell = {
@@ -59,5 +73,6 @@ export const shell = {
     float: floatManager,
     presets: presetManager,
     conflicts: conflictsApi,
+    color: colorApi,
     actions: shellActions,
 };

package/dist/tokens.css

@@ -33,7 +33,7 @@
   --shell-accent-muted: #3a5580;
 
   /* Inputs */
-  --shell-input-bg:           #2a2a2a;
+  --shell-input-bg:           var(--shell-bg-sunken);
   --shell-input-border-focus: var(--shell-accent);
   --shell-focus-ring:         0 0 0 2px color-mix(in srgb, var(--shell-accent) 40%, transparent);
 

package/dist/version.d.ts

@@ -1,2 +1,2 @@
 /** Auto-generated from package.json — do not edit manually. */
-export declare const VERSION = "0.11.2";
+export declare const VERSION = "0.11.6";

package/dist/version.js

@@ -1,2 +1,2 @@
 /** Auto-generated from package.json — do not edit manually. */
-export const VERSION = '0.11.2';
+export const VERSION = '0.11.6';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sh3-core",
-  "version": "0.11.2",
+  "version": "0.11.6",
   "type": "module",
   "files": [
     "dist"