sh3-core 0.11.2 → 0.11.6

package/dist/api.js

@@ -32,6 +32,7 @@ export { inspectActiveLayout, spliceIntoActiveLayout, dockIntoActiveLayout, focu
 export { PERMISSION_DOCUMENTS_BROWSE, PERMISSION_DOCUMENTS_READ, PERMISSION_DOCUMENTS_WRITE, } from './documents/types';
 export { PERMISSION_SYNC_PEER, PERMISSION_SYNC_POLICY } from './documents/sync-types';
 export { CONFLICT_RENDERER_POINT, ConflictPermissionError, ConflictSessionOrphanedError, } from './conflicts/api';
+export { COLOR_PICKER_POINT } from './color/api';
 // Shard introspection — read-only reactive maps exposing which shards are
 // known to the host and which are currently active. Intended for diagnostic
 // and tooling shards that need to visualize framework state. Phase 9
@@ -65,3 +66,8 @@ export const FRAMEWORK_SHARD_IDS = [
 ];
 // Theme token override API (shell-level theming support).
 export { setTokenOverrides, clearTokenOverrides, getTokenOverrides, } from './theme';
+// UI primitives for shards and apps. Must live on the public shim surface
+// (api.ts) — not just index.ts — so dynamically loaded bundles can resolve
+// `import { Button } from 'sh3-core'` against the runtime shim in loader.ts.
+export { default as Button } from './primitives/Button.svelte';
+export { provideIcons, getIconSprite } from './primitives/icon-context';

package/dist/apps/lifecycle.js

@@ -14,7 +14,7 @@
 import { createStateZones } from '../state/zones.svelte';
 import { activateShard, deactivateShard, getShardContext, registeredShards, } from '../shards/activate.svelte';
 import { attachApp, acquireAppSlotHolds, detachApp, switchToApp, switchToHome, } from '../layout/store.svelte';
-import { activeApp, getRegisteredApp, registeredApps } from './registry.svelte';
+import { activeApp, breadcrumbApp, getRegisteredApp, registeredApps } from './registry.svelte';
 import { createZoneManager } from '../state/manage';
 import { PERMISSION_STATE_MANAGE } from '../state/types';
 import { setActiveApp, setUserBindings } from '../actions/state.svelte';
@@ -96,6 +96,7 @@ export async function launchApp(id) {
         switchToApp();
         void ((_c = app.onAppReady) === null || _c === void 0 ? void 0 : _c.call(app, getOrCreateAppContext(id)));
         writeLastApp(id);
+        breadcrumbApp.id = id;
         setActiveApp(id, new Set((_d = app.manifest.requiredShards) !== null && _d !== void 0 ? _d : []));
         void loadUserBindings(id).then(setUserBindings);
         return;
@@ -135,6 +136,7 @@ export async function launchApp(id) {
     switchToApp();
     void ((_g = app.onAppReady) === null || _g === void 0 ? void 0 : _g.call(app, getOrCreateAppContext(id)));
     writeLastApp(id);
+    breadcrumbApp.id = id;
 }
 // ---------- unload --------------------------------------------------------
 /**
@@ -226,6 +228,11 @@ export async function returnToHome() {
             return false;
     }
     switchToHome();
+    // Mirror unregisterApp: clear the dispatcher's active-app pointer so
+    // 'app'-scope actions become inactive on home. Without this, any action
+    // registered with scope: ['app'] keeps appearing in the palette while
+    // the user is on home.
+    setActiveApp(null, new Set());
     writeLastApp(null);
     return true;
 }

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/assets/favicon.svg

@@ -0,0 +1,5 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" data-svg-designer-scene-id="13a98ace">
+  <rect id="07433d30" x="2" y="2" width="20" height="20" rx="2" fill="#a15c67" stroke="#ff7373" stroke-width="0.5" opacity="1"/>
+  <text id="deb1fa9e" x="2.0101" y="16.2415" font-family="monospace" font-size="12" font-weight="bold" fill="#2b0f2b" opacity="0.8">SH3</text>
+  <text id="055bb24a" x="2.0709" y="15.3866" font-family="monospace" font-size="12" font-weight="bold" fill="#fae3b6" opacity="1">SH3</text>
+</svg>

package/dist/color/api.d.ts

@@ -0,0 +1,38 @@
+/** Contribution-point id for color pickers. */
+export declare const COLOR_PICKER_POINT = "sh3.color-picker";
+export interface ColorPickOptions {
+    /** Initial color as '#rrggbb'. If omitted, contributors choose a default. */
+    initial?: string;
+    /** Request alpha support. Ignored by contributors that don't support it. */
+    alpha?: boolean;
+    /** Anchor element for floating/positioned pickers. Native fallback ignores. */
+    anchor?: HTMLElement;
+    /** Display title (e.g. 'Background color'). Native fallback ignores. */
+    title?: string;
+}
+/**
+ * A color-picker contribution. Higher `priority` wins; the inlined native
+ * fallback is priority 0, so contributors typically use >= 10.
+ *
+ * `open(opts)` resolves with '#rrggbb' (or '#rrggbbaa' when the contributor
+ * honors `opts.alpha`) or `null` if the user dismissed.
+ */
+export interface ColorContribution {
+    id: string;
+    priority?: number;
+    open(opts: ColorPickOptions): Promise<string | null>;
+}
+/** Shell-level color API, mounted at `shell.color`. */
+export interface ColorApi {
+    /**
+     * Open a color picker. Resolves with the chosen color as '#rrggbb'
+     * (or '#rrggbbaa' when a contributor honors `opts.alpha === true`),
+     * or `null` if the user dismissed.
+     *
+     * On browsers without `<input type="color">` cancel-event support, the
+     * returned promise may not resolve if the user closes the native
+     * fallback without committing. Install a color-picker shard (e.g.
+     * sh3-editor) to avoid this.
+     */
+    pick(opts?: ColorPickOptions): Promise<string | null>;
+}

package/dist/color/api.js

@@ -0,0 +1,10 @@
+/*
+ * Public types for the color-picker contribution point.
+ *
+ * A contribution registered at COLOR_PICKER_POINT is picked by the
+ * primitive in ./primitive.ts when `shell.color.pick()` is called.
+ * The native <input type="color"> fallback is inlined there at priority 0;
+ * contributed pickers typically register at priority >= 10.
+ */
+/** Contribution-point id for color pickers. */
+export const COLOR_PICKER_POINT = 'sh3.color-picker';

package/dist/color/native-fallback.test.d.ts

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

package/dist/color/native-fallback.test.js

@@ -0,0 +1,43 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { register, __resetContributionsForTest } from '../contributions/registry';
+import { COLOR_PICKER_POINT } from './api';
+import { pickColor } from './primitive';
+describe('native fallback', () => {
+    beforeEach(() => __resetContributionsForTest());
+    afterEach(() => {
+        document.querySelectorAll('input[type="color"]').forEach((el) => el.remove());
+    });
+    it('creates an input[type=color], clicks it, and resolves on change', async () => {
+        const p = pickColor({ initial: '#ff8800' });
+        const el = document.querySelector('input[type="color"]');
+        expect(el).not.toBeNull();
+        expect(el.value).toBe('#ff8800');
+        el.value = '#112233';
+        el.dispatchEvent(new Event('change'));
+        await expect(p).resolves.toBe('#112233');
+        expect(document.querySelector('input[type="color"]')).toBeNull();
+    });
+    it('resolves null on cancel', async () => {
+        const p = pickColor();
+        const el = document.querySelector('input[type="color"]');
+        expect(el).not.toBeNull();
+        el.dispatchEvent(new Event('cancel'));
+        await expect(p).resolves.toBeNull();
+        expect(document.querySelector('input[type="color"]')).toBeNull();
+    });
+    it('ignores malformed initial values without crashing', () => {
+        pickColor({ initial: 'not-a-color' });
+        const el = document.querySelector('input[type="color"]');
+        expect(el).not.toBeNull();
+        expect(el.value).not.toBe('not-a-color');
+    });
+    it('priority-≥1 contributor bypasses native entirely', async () => {
+        register(COLOR_PICKER_POINT, {
+            id: 'c',
+            priority: 10,
+            open: () => Promise.resolve('#abcdef'),
+        });
+        await expect(pickColor()).resolves.toBe('#abcdef');
+        expect(document.querySelector('input[type="color"]')).toBeNull();
+    });
+});

package/dist/color/primitive.d.ts

@@ -0,0 +1,2 @@
+import { type ColorPickOptions } from './api';
+export declare function pickColor(opts?: ColorPickOptions): Promise<string | null>;

package/dist/color/primitive.js

@@ -0,0 +1,40 @@
+/*
+ * Color-picker selection primitive.
+ *
+ * Reads contributions registered at COLOR_PICKER_POINT, sorts by
+ * priority descending, and calls `open(opts)` on the winner. The
+ * inlined native fallback at priority 0 guarantees there is always
+ * at least one candidate.
+ */
+import { list } from '../contributions/registry';
+import { COLOR_PICKER_POINT } from './api';
+const nativeFallback = {
+    id: 'sh3.color-picker.native',
+    priority: 0,
+    open: ({ initial }) => new Promise((resolve) => {
+        const el = document.createElement('input');
+        el.type = 'color';
+        if (initial && /^#[0-9a-f]{6}$/i.test(initial))
+            el.value = initial;
+        let settled = false;
+        const settle = (v) => {
+            if (settled)
+                return;
+            settled = true;
+            el.remove();
+            resolve(v);
+        };
+        el.addEventListener('change', () => settle(el.value));
+        el.addEventListener('cancel', () => settle(null));
+        el.style.position = 'fixed';
+        el.style.left = '-9999px';
+        document.body.appendChild(el);
+        el.click();
+    }),
+};
+export function pickColor(opts = {}) {
+    const contributed = list(COLOR_PICKER_POINT);
+    const winner = [...contributed, nativeFallback]
+        .sort((a, b) => { var _a, _b; return ((_a = b.priority) !== null && _a !== void 0 ? _a : 0) - ((_b = a.priority) !== null && _b !== void 0 ? _b : 0); })[0];
+    return winner.open(opts);
+}

package/dist/color/primitive.test.d.ts

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

package/dist/color/primitive.test.js

@@ -0,0 +1,42 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { register, __resetContributionsForTest } from '../contributions/registry';
+import { COLOR_PICKER_POINT } from './api';
+import { pickColor } from './primitive';
+describe('pickColor / selection', () => {
+    beforeEach(() => __resetContributionsForTest());
+    it('picks the highest-priority contributor', async () => {
+        const low = {
+            id: 'low',
+            priority: 5,
+            open: vi.fn(() => Promise.resolve('#111111')),
+        };
+        const high = {
+            id: 'high',
+            priority: 50,
+            open: vi.fn(() => Promise.resolve('#222222')),
+        };
+        register(COLOR_PICKER_POINT, low);
+        register(COLOR_PICKER_POINT, high);
+        await expect(pickColor({ initial: '#ff0000' })).resolves.toBe('#222222');
+        expect(high.open).toHaveBeenCalledWith({ initial: '#ff0000' });
+        expect(low.open).not.toHaveBeenCalled();
+    });
+    it('passes opts through unchanged', async () => {
+        const open = vi.fn(() => Promise.resolve(null));
+        register(COLOR_PICKER_POINT, { id: 'c', priority: 10, open });
+        const opts = { initial: '#abcdef', alpha: true, title: 'Pick' };
+        await pickColor(opts);
+        expect(open).toHaveBeenCalledWith(opts);
+    });
+    it('re-reads contributions on each call (no caching)', async () => {
+        const first = vi.fn(() => Promise.resolve('#111111'));
+        const unreg = register(COLOR_PICKER_POINT, { id: 'a', priority: 10, open: first });
+        await pickColor();
+        unreg();
+        const second = vi.fn(() => Promise.resolve('#222222'));
+        register(COLOR_PICKER_POINT, { id: 'b', priority: 10, open: second });
+        await pickColor();
+        expect(first).toHaveBeenCalledTimes(1);
+        expect(second).toHaveBeenCalledTimes(1);
+    });
+});

package/dist/color/shell-api.d.ts

@@ -0,0 +1,2 @@
+import type { ColorApi } from './api';
+export declare const colorApi: ColorApi;

package/dist/color/shell-api.js

@@ -0,0 +1,11 @@
+/*
+ * shell.color assembled API.
+ *
+ * The selector + inlined native fallback live in primitive.ts;
+ * this file just binds `pick` onto the object exposed on the shell
+ * singleton, mirroring conflicts/shell-api.ts.
+ */
+import { pickColor } from './primitive';
+export const colorApi = {
+    pick: pickColor,
+};

package/dist/index.d.ts

@@ -1,6 +1,4 @@
 export * from './api';
 export { default as Shell } from './Shell.svelte';
-export { default as Button } from './primitives/Button.svelte';
-export { provideIcons, getIconSprite, type ButtonVariant } from './primitives/icon-context';
 export type { ArtifactManifest } from './artifact';
 export * from './shell-shard/protocol';

package/dist/index.js

@@ -11,6 +11,4 @@
  */
 export * from './api';
 export { default as Shell } from './Shell.svelte';
-export { default as Button } from './primitives/Button.svelte';
-export { provideIcons, getIconSprite } from './primitives/icon-context';
 export * from './shell-shard/protocol';

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;