sh3-core 0.10.4 → 0.11.2

package/dist/actions/palette-scorer.test.d.ts

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

package/dist/actions/palette-scorer.test.js

@@ -0,0 +1,40 @@
+import { describe, it, expect } from 'vitest';
+import { scoreMatch, rankPaletteEntries } from './palette-scorer';
+describe('scoreMatch', () => {
+    it('returns null when subsequence not present', () => {
+        expect(scoreMatch('abcd', 'z')).toBeNull();
+    });
+    it('returns a score when subsequence matches', () => {
+        expect(scoreMatch('save', 'sv')).not.toBeNull();
+        expect(scoreMatch('save', 'save')).not.toBeNull();
+    });
+    it('ranks tighter runs higher', () => {
+        const tight = scoreMatch('save all', 'sa');
+        const loose = scoreMatch('save all', 'sl');
+        expect(tight).toBeGreaterThan(loose);
+    });
+    it('applies prefix bonus', () => {
+        const prefix = scoreMatch('save', 'sa');
+        const mid = scoreMatch('xsave', 'sa');
+        expect(prefix).toBeGreaterThan(mid);
+    });
+    it('is case-insensitive', () => {
+        expect(scoreMatch('Save', 'sa')).not.toBeNull();
+        expect(scoreMatch('save', 'SA')).not.toBeNull();
+    });
+});
+describe('rankPaletteEntries', () => {
+    const mk = (id, label) => ({ id, label, shortcut: null, scopeBadge: null });
+    it('filters out non-matches', () => {
+        const out = rankPaletteEntries([mk('a', 'save'), mk('b', 'undo')], 'redo', []);
+        expect(out).toHaveLength(0);
+    });
+    it('sorts by score descending', () => {
+        const out = rankPaletteEntries([mk('a', 'save'), mk('b', 'save all')], 'sa', []);
+        expect(out[0].id).toBe('a'); // tighter
+    });
+    it('recency breaks ties', () => {
+        const out = rankPaletteEntries([mk('a', 'save'), mk('b', 'save')], 'sa', ['b']);
+        expect(out[0].id).toBe('b');
+    });
+});

package/dist/actions/paletteModel.d.ts

@@ -0,0 +1,4 @@
+import type { ActionEntry } from './registry';
+import type { DispatcherState } from './dispatcher.svelte';
+import type { PaletteCandidate } from './palette-scorer';
+export declare function buildPaletteCandidates(entries: ActionEntry[], state: DispatcherState): PaletteCandidate[];

package/dist/actions/paletteModel.js

@@ -0,0 +1,40 @@
+import { isScopeActive } from './dispatcher.svelte';
+import { effectiveShortcut } from './bindings';
+function normalize(s) {
+    return Array.isArray(s) ? s : [s];
+}
+function anyScopeActive(scope, state, owner) {
+    for (const s of normalize(scope)) {
+        if (isScopeActive(s, state, owner))
+            return s;
+    }
+    return null;
+}
+function scopeBadge(scope) {
+    if (scope === 'home' || scope === 'app')
+        return null;
+    if (typeof scope === 'string')
+        return scope; // view:X / focus:X
+    return scope.element;
+}
+export function buildPaletteCandidates(entries, state) {
+    const out = [];
+    const seen = new Set();
+    for (const entry of entries) {
+        if (entry.action.paletteItem === false)
+            continue;
+        if (seen.has(entry.action.id))
+            continue;
+        const active = anyScopeActive(entry.action.scope, state, entry.ownerShardId);
+        if (!active)
+            continue;
+        seen.add(entry.action.id);
+        out.push({
+            id: entry.action.id,
+            label: entry.action.label,
+            shortcut: effectiveShortcut(entry.action, state.bindings, state.platform),
+            scopeBadge: scopeBadge(active),
+        });
+    }
+    return out;
+}

package/dist/actions/paletteModel.test.d.ts

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

package/dist/actions/paletteModel.test.js

@@ -0,0 +1,33 @@
+import { describe, it, expect } from 'vitest';
+import { buildPaletteCandidates } from './paletteModel';
+const mkEntry = (a, owner = 'shard.x') => ({
+    ownerShardId: owner,
+    action: Object.assign({ id: 'a', label: 'A', scope: 'home', run: () => { } }, a),
+});
+const mkState = (o = {}) => (Object.assign({ activeAppId: null, activeAppRequiredShards: new Set(), autostartShards: new Set(), mountedViewIds: new Set(), focusedViewId: null, selection: null, bindings: {}, platform: 'other' }, o));
+describe('buildPaletteCandidates', () => {
+    it('includes actions with paletteItem default true', () => {
+        const entries = [mkEntry({ id: 'x', scope: 'home', label: 'X' })];
+        const out = buildPaletteCandidates(entries, mkState());
+        expect(out.map((c) => c.id)).toEqual(['x']);
+    });
+    it('excludes paletteItem false', () => {
+        const entries = [mkEntry({ id: 'x', scope: 'home', label: 'X', paletteItem: false })];
+        const out = buildPaletteCandidates(entries, mkState());
+        expect(out).toHaveLength(0);
+    });
+    it('excludes actions whose scope is inactive', () => {
+        const entries = [mkEntry({ id: 'x', scope: 'app', label: 'X' })];
+        const out = buildPaletteCandidates(entries, mkState());
+        expect(out).toHaveLength(0);
+    });
+    it('de-duplicates multi-scope actions', () => {
+        const entries = [mkEntry({ id: 'p', scope: ['home', 'app'], label: 'P' }, '__sh3core__')];
+        const state = mkState({
+            activeAppId: 'a',
+            autostartShards: new Set(['__sh3core__']),
+        });
+        const out = buildPaletteCandidates(entries, state);
+        expect(out).toHaveLength(1);
+    });
+});

package/dist/actions/registry.d.ts

@@ -0,0 +1,10 @@
+import type { Action } from './types';
+export declare const ACTIONS_POINT_ID = "sh3.actions";
+export interface ActionEntry {
+    action: Action;
+    ownerShardId: string;
+}
+export declare function registerAction(action: Action, ownerShardId: string): () => void;
+export declare function listActions(): ActionEntry[];
+export declare function onActionsChange(cb: () => void): () => void;
+export declare function __resetActionsRegistryForTest(): void;

package/dist/actions/registry.js

@@ -0,0 +1,36 @@
+/*
+ * Action registry — typed facade over the shared contributions point
+ * `sh3.actions`. One entry per (ownerShardId, action) pair. Disposers
+ * returned from registerAction clean up the underlying contribution
+ * entry; activate.svelte.ts also pushes them into the shard's cleanup
+ * queue so deactivate auto-clears.
+ */
+import { register as contributionsRegister, list as contributionsList, onChange as contributionsOnChange, } from '../contributions/registry';
+export const ACTIONS_POINT_ID = 'sh3.actions';
+const liveIds = new Set();
+export function registerAction(action, ownerShardId) {
+    if (liveIds.has(action.id)) {
+        console.warn(`[sh3] Duplicate action id "${action.id}" registered by "${ownerShardId}". ` +
+            `First registration wins; second registration still stored but shortcut conflicts may occur.`);
+    }
+    liveIds.add(action.id);
+    const entry = { action, ownerShardId };
+    const dispose = contributionsRegister(ACTIONS_POINT_ID, entry);
+    let disposed = false;
+    return () => {
+        if (disposed)
+            return;
+        disposed = true;
+        dispose();
+        liveIds.delete(action.id);
+    };
+}
+export function listActions() {
+    return contributionsList(ACTIONS_POINT_ID);
+}
+export function onActionsChange(cb) {
+    return contributionsOnChange(ACTIONS_POINT_ID, cb);
+}
+export function __resetActionsRegistryForTest() {
+    liveIds.clear();
+}

package/dist/actions/registry.test.d.ts

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

package/dist/actions/registry.test.js

@@ -0,0 +1,49 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { registerAction, listActions, onActionsChange, ACTIONS_POINT_ID, __resetActionsRegistryForTest, } from './registry';
+import { __resetContributionsForTest, list } from '../contributions/registry';
+const mkAction = (overrides = {}) => (Object.assign({ id: 'shard.test', label: 'Test', scope: 'home', run: () => { } }, overrides));
+describe('actions registry', () => {
+    beforeEach(() => {
+        __resetContributionsForTest();
+        __resetActionsRegistryForTest();
+    });
+    it('stores actions at the ACTIONS_POINT_ID contributions point', () => {
+        registerAction(mkAction(), 'shard.a');
+        expect(list(ACTIONS_POINT_ID)).toHaveLength(1);
+    });
+    it('listActions returns registered entries with owner', () => {
+        registerAction(mkAction({ id: 'a.one' }), 'shard.a');
+        registerAction(mkAction({ id: 'b.one' }), 'shard.b');
+        const entries = listActions();
+        expect(entries).toHaveLength(2);
+        expect(entries[0].ownerShardId).toBe('shard.a');
+        expect(entries[1].action.id).toBe('b.one');
+    });
+    it('returned disposer removes the entry', () => {
+        const dispose = registerAction(mkAction({ id: 'x' }), 'shard.a');
+        expect(listActions()).toHaveLength(1);
+        dispose();
+        expect(listActions()).toHaveLength(0);
+    });
+    it('double-dispose is safe', () => {
+        const dispose = registerAction(mkAction(), 'shard.a');
+        dispose();
+        dispose();
+        expect(listActions()).toHaveLength(0);
+    });
+    it('onActionsChange fires on register and dispose', () => {
+        let count = 0;
+        onActionsChange(() => { count++; });
+        const dispose = registerAction(mkAction(), 'shard.a');
+        expect(count).toBe(1);
+        dispose();
+        expect(count).toBe(2);
+    });
+    it('warns on duplicate action id', () => {
+        const warn = vi.spyOn(console, 'warn').mockImplementation(() => { });
+        registerAction(mkAction({ id: 'dup' }), 'shard.a');
+        registerAction(mkAction({ id: 'dup' }), 'shard.b');
+        expect(warn).toHaveBeenCalled();
+        warn.mockRestore();
+    });
+});

package/dist/actions/selection.svelte.d.ts

@@ -0,0 +1,8 @@
+import type { Selection, SelectionApi } from './types';
+export declare function getSelection(): Selection | null;
+export declare function makeSelectionApi(shardId: string): SelectionApi;
+/** Called by the shell on shard deactivate and app switch. */
+export declare function clearSelectionForShard(shardId: string): void;
+/** Called by the shell on app switch (unconditional). */
+export declare function clearSelectionUnconditional(): void;
+export declare function __resetSelectionForTest(): void;

package/dist/actions/selection.svelte.js

@@ -0,0 +1,44 @@
+/*
+ * Shell-level single-selection state. One selection at a time, reactive.
+ * Shards obtain a per-shard SelectionApi via makeSelectionApi(shardId)
+ * that stamps ownerShardId on set and checks owner on clear. Shell-level
+ * clearSelectionForShard is used when a shard deactivates or an app
+ * switches — it only clears if the owner matches, so two-shard
+ * interleavings don't accidentally wipe each other.
+ */
+let current = $state(null);
+export function getSelection() {
+    return current;
+}
+export function makeSelectionApi(shardId) {
+    return {
+        get() {
+            return current;
+        },
+        set(sel) {
+            current = { type: sel.type, ref: sel.ref, ownerShardId: shardId };
+        },
+        clear() {
+            if (!current)
+                return;
+            if (current.ownerShardId !== shardId) {
+                console.warn(`[sh3] Shard "${shardId}" tried to clear selection owned by "${current.ownerShardId}". Ignoring.`);
+                return;
+            }
+            current = null;
+        },
+    };
+}
+/** Called by the shell on shard deactivate and app switch. */
+export function clearSelectionForShard(shardId) {
+    if (current && current.ownerShardId === shardId) {
+        current = null;
+    }
+}
+/** Called by the shell on app switch (unconditional). */
+export function clearSelectionUnconditional() {
+    current = null;
+}
+export function __resetSelectionForTest() {
+    current = null;
+}

package/dist/actions/selection.test.d.ts

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

package/dist/actions/selection.test.js

@@ -0,0 +1,51 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { makeSelectionApi, getSelection, clearSelectionForShard, __resetSelectionForTest, } from './selection.svelte';
+describe('selection', () => {
+    beforeEach(() => {
+        __resetSelectionForTest();
+    });
+    it('returns null before any set', () => {
+        expect(getSelection()).toBeNull();
+    });
+    it('set stamps ownerShardId', () => {
+        const api = makeSelectionApi('shard.a');
+        api.set({ type: 'orb', ref: 42 });
+        expect(getSelection()).toEqual({ type: 'orb', ref: 42, ownerShardId: 'shard.a' });
+    });
+    it('clear by owner wipes selection', () => {
+        const api = makeSelectionApi('shard.a');
+        api.set({ type: 'orb', ref: 42 });
+        api.clear();
+        expect(getSelection()).toBeNull();
+    });
+    it('non-owner clear is a no-op with warn', () => {
+        var _a;
+        const warn = vi.spyOn(console, 'warn').mockImplementation(() => { });
+        const a = makeSelectionApi('shard.a');
+        const b = makeSelectionApi('shard.b');
+        a.set({ type: 'orb', ref: 42 });
+        b.clear();
+        expect((_a = getSelection()) === null || _a === void 0 ? void 0 : _a.type).toBe('orb');
+        expect(warn).toHaveBeenCalled();
+        warn.mockRestore();
+    });
+    it('shell-level clearSelectionForShard always works', () => {
+        const api = makeSelectionApi('shard.a');
+        api.set({ type: 'orb', ref: 42 });
+        clearSelectionForShard('shard.a');
+        expect(getSelection()).toBeNull();
+    });
+    it('clearSelectionForShard only clears when owner matches', () => {
+        const api = makeSelectionApi('shard.a');
+        api.set({ type: 'orb', ref: 42 });
+        clearSelectionForShard('shard.b');
+        expect(getSelection()).not.toBeNull();
+    });
+    it('set from a different shard replaces the previous selection', () => {
+        const a = makeSelectionApi('shard.a');
+        const b = makeSelectionApi('shard.b');
+        a.set({ type: 'orb', ref: 1 });
+        b.set({ type: 'node', ref: 2 });
+        expect(getSelection()).toEqual({ type: 'node', ref: 2, ownerShardId: 'shard.b' });
+    });
+});

package/dist/actions/shardContext.test.d.ts

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

package/dist/actions/shardContext.test.js

@@ -0,0 +1,41 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { registerShard, activateShard, deactivateShard } from '../shards/activate.svelte';
+import { __resetContributionsForTest } from '../contributions/registry';
+import { __resetActionsRegistryForTest, listActions } from './registry';
+import { __resetSelectionForTest, getSelection } from './selection.svelte';
+function mkShard(id, onActivate) {
+    return {
+        manifest: { id, label: id, version: '0.0.0-test', views: [] },
+        async activate(ctx) { onActivate(ctx); },
+    };
+}
+describe('ctx.actions on ShardContext', () => {
+    beforeEach(() => {
+        __resetContributionsForTest();
+        __resetActionsRegistryForTest();
+        __resetSelectionForTest();
+    });
+    it('registerAction is auto-unregistered on deactivate', async () => {
+        const shard = mkShard('shard.a', (ctx) => {
+            ctx.actions.register({
+                id: 'shard.a.x', label: 'X', scope: 'home',
+                run: () => { },
+            });
+        });
+        registerShard(shard);
+        await activateShard('shard.a');
+        expect(listActions()).toHaveLength(1);
+        deactivateShard('shard.a');
+        expect(listActions()).toHaveLength(0);
+    });
+    it('selection set by a shard is cleared on that shard deactivate', async () => {
+        const shard = mkShard('shard.a', (ctx) => {
+            ctx.actions.selection.set({ type: 'orb', ref: 42 });
+        });
+        registerShard(shard);
+        await activateShard('shard.a');
+        expect(getSelection()).not.toBeNull();
+        deactivateShard('shard.a');
+        expect(getSelection()).toBeNull();
+    });
+});

package/dist/actions/shellActions.test.d.ts

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

package/dist/actions/shellActions.test.js

@@ -0,0 +1,22 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { shell } from '../shellRuntime.svelte';
+import { __setBindingsZone } from './bindings-store';
+import { __resetDispatcherStateForTest, setActiveApp } from './state.svelte';
+describe('shell.actions facade', () => {
+    beforeEach(() => {
+        __setBindingsZone({ bindings: {} });
+        __resetDispatcherStateForTest();
+        setActiveApp('app.a', new Set(['shard.x']));
+    });
+    it('rebind persists and updates live state', async () => {
+        await shell.actions.rebind('app.a', 'shard.x.save', 'Ctrl+Alt+S');
+        const now = await shell.actions.bindingsFor('app.a');
+        expect(now['shard.x.save']).toBe('Ctrl+Alt+S');
+    });
+    it('resetBinding removes the override', async () => {
+        await shell.actions.rebind('app.a', 'shard.x.save', 'Ctrl+Alt+S');
+        await shell.actions.resetBinding('app.a', 'shard.x.save');
+        const now = await shell.actions.bindingsFor('app.a');
+        expect(now['shard.x.save']).toBeUndefined();
+    });
+});

package/dist/actions/shortcuts.d.ts

@@ -0,0 +1,5 @@
+export type Platform = 'mac' | 'other';
+export declare function canonicalizeShortcut(raw: string): string;
+export declare function resolveMod(shortcut: string, platform: Platform): string;
+export declare function eventToShortcut(ev: KeyboardEvent): string;
+export declare function detectPlatform(): Platform;

package/dist/actions/shortcuts.js

@@ -0,0 +1,87 @@
+/*
+ * Shortcut normalization — canonical form is "Mod1+Mod2+...+Key" with
+ * modifiers ordered Ctrl, Alt, Shift, Meta. Single-character keys are
+ * uppercased; named keys preserve their .key value.
+ *
+ * Mod is a pseudo-modifier: Meta on Mac, Ctrl elsewhere. Resolved once,
+ * at the moment a default shortcut is written into the tier index (not
+ * at match time) — the index stores concrete shortcuts only.
+ */
+const MOD_ORDER = ['Ctrl', 'Alt', 'Shift', 'Meta'];
+const MOD_ALIASES = {
+    control: 'Ctrl',
+    ctrl: 'Ctrl',
+    alt: 'Alt',
+    option: 'Alt',
+    shift: 'Shift',
+    meta: 'Meta',
+    cmd: 'Meta',
+    command: 'Meta',
+    super: 'Meta',
+    win: 'Meta',
+};
+const PURE_MODIFIER_KEYS = new Set(['Control', 'Alt', 'Shift', 'Meta']);
+function titleCaseNamedKey(key) {
+    if (key.length === 1)
+        return key.toUpperCase();
+    // Preserve browser's named-key casing (Enter, Escape, ArrowUp, etc.)
+    return key;
+}
+export function canonicalizeShortcut(raw) {
+    if (!raw)
+        throw new Error('Empty shortcut');
+    const rawParts = raw.split('+');
+    // Any empty segment (leading/trailing/consecutive '+') means malformed
+    if (rawParts.some((p) => p.trim() === ''))
+        throw new Error(`Malformed shortcut: "${raw}"`);
+    const parts = rawParts.map((p) => p.trim());
+    if (parts.length === 0)
+        throw new Error(`Malformed shortcut: "${raw}"`);
+    const modifiers = new Set();
+    let key;
+    for (const part of parts) {
+        const lower = part.toLowerCase();
+        if (lower in MOD_ALIASES) {
+            modifiers.add(MOD_ALIASES[lower]);
+        }
+        else {
+            if (key !== undefined)
+                throw new Error(`Multiple keys in shortcut: "${raw}"`);
+            key = titleCaseNamedKey(part);
+        }
+    }
+    if (key === undefined)
+        throw new Error(`No key in shortcut: "${raw}"`);
+    const ordered = MOD_ORDER.filter((m) => modifiers.has(m));
+    return [...ordered, key].join('+');
+}
+export function resolveMod(shortcut, platform) {
+    if (!shortcut.toLowerCase().includes('mod'))
+        return shortcut;
+    const parts = shortcut.split('+').map((p) => {
+        if (p.toLowerCase() === 'mod')
+            return platform === 'mac' ? 'Meta' : 'Ctrl';
+        return p;
+    });
+    return canonicalizeShortcut(parts.join('+'));
+}
+export function eventToShortcut(ev) {
+    if (PURE_MODIFIER_KEYS.has(ev.key))
+        return '';
+    const mods = [];
+    if (ev.ctrlKey)
+        mods.push('Ctrl');
+    if (ev.altKey)
+        mods.push('Alt');
+    if (ev.shiftKey)
+        mods.push('Shift');
+    if (ev.metaKey)
+        mods.push('Meta');
+    const key = titleCaseNamedKey(ev.key);
+    return [...mods, key].join('+');
+}
+export function detectPlatform() {
+    if (typeof navigator === 'undefined')
+        return 'other';
+    return /Mac|iPhone|iPad|iPod/i.test(navigator.platform) ? 'mac' : 'other';
+}

package/dist/actions/shortcuts.test.d.ts

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

package/dist/actions/shortcuts.test.js

@@ -0,0 +1,49 @@
+import { describe, it, expect } from 'vitest';
+import { canonicalizeShortcut, eventToShortcut, resolveMod, } from './shortcuts';
+describe('canonicalizeShortcut', () => {
+    it('orders modifiers Ctrl Alt Shift Meta', () => {
+        expect(canonicalizeShortcut('Shift+Ctrl+S')).toBe('Ctrl+Shift+S');
+        expect(canonicalizeShortcut('Meta+Alt+Ctrl+K')).toBe('Ctrl+Alt+Meta+K');
+    });
+    it('uppercases single-character keys', () => {
+        expect(canonicalizeShortcut('Ctrl+s')).toBe('Ctrl+S');
+    });
+    it('preserves named keys', () => {
+        expect(canonicalizeShortcut('Ctrl+Enter')).toBe('Ctrl+Enter');
+        expect(canonicalizeShortcut('Escape')).toBe('Escape');
+    });
+    it('is case-insensitive on modifiers', () => {
+        expect(canonicalizeShortcut('ctrl+SHIFT+k')).toBe('Ctrl+Shift+K');
+    });
+    it('throws on malformed input', () => {
+        expect(() => canonicalizeShortcut('')).toThrow();
+        expect(() => canonicalizeShortcut('Ctrl+')).toThrow();
+        expect(() => canonicalizeShortcut('+S')).toThrow();
+    });
+});
+describe('resolveMod', () => {
+    it('maps Mod to Cmd on Mac', () => {
+        expect(resolveMod('Mod+K', 'mac')).toBe('Meta+K');
+    });
+    it('maps Mod to Ctrl on non-Mac', () => {
+        expect(resolveMod('Mod+K', 'other')).toBe('Ctrl+K');
+    });
+    it('leaves non-Mod shortcuts unchanged', () => {
+        expect(resolveMod('Ctrl+S', 'mac')).toBe('Ctrl+S');
+        expect(resolveMod('Ctrl+S', 'other')).toBe('Ctrl+S');
+    });
+});
+describe('eventToShortcut', () => {
+    function mkEvt(partial) {
+        return Object.assign({ ctrlKey: false, altKey: false, shiftKey: false, metaKey: false, key: '' }, partial);
+    }
+    it('builds canonical form from event', () => {
+        expect(eventToShortcut(mkEvt({ ctrlKey: true, key: 's' }))).toBe('Ctrl+S');
+        expect(eventToShortcut(mkEvt({ ctrlKey: true, shiftKey: true, key: 'K' }))).toBe('Ctrl+Shift+K');
+        expect(eventToShortcut(mkEvt({ key: 'Escape' }))).toBe('Escape');
+    });
+    it('returns empty string for pure modifier press', () => {
+        expect(eventToShortcut(mkEvt({ ctrlKey: true, key: 'Control' }))).toBe('');
+        expect(eventToShortcut(mkEvt({ shiftKey: true, key: 'Shift' }))).toBe('');
+    });
+});

package/dist/actions/state.svelte.d.ts

@@ -0,0 +1,16 @@
+import type { DispatcherState } from './dispatcher.svelte';
+export declare function setActiveApp(appId: string | null, requiredShards: Set<string>): void;
+export declare function setAutostartShards(shards: Set<string>): void;
+export declare function setMountedViewIds(ids: Set<string>): void;
+/**
+ * One-shot snapshot: walk the active layout tree and update
+ * `mountedViewIds` to match. Non-reactive — call from an `$effect` that
+ * reads `layoutStore.tree` to keep the set in sync as the tree mutates.
+ * Shell.svelte owns that effect during boot.
+ */
+export declare function syncMountedViewIdsFromLayout(): void;
+export declare function setFocusedViewId(id: string | null): void;
+export declare function setUserBindings(bindings: Record<string, string | null>): void;
+export declare function getLiveDispatcherState(): DispatcherState;
+export declare function addAutostartShard(id: string): void;
+export declare function __resetDispatcherStateForTest(): void;

package/dist/actions/state.svelte.js

@@ -0,0 +1,76 @@
+/*
+ * Live dispatcher state. The pure dispatcher takes a snapshot; this
+ * module maintains one, driven by setters called from listeners.ts,
+ * lifecycle hooks, and the selection module.
+ *
+ * Using primitive setters (rather than $effect chains) keeps the test
+ * surface small and lets callers update state in a predictable order
+ * during lifecycle transitions.
+ */
+import { getSelection } from './selection.svelte';
+import { detectPlatform } from './shortcuts';
+import { layoutStore } from '../layout/store.svelte';
+import { collectTreeSlotRefs } from '../layout/tree-walk';
+let activeAppId = $state(null);
+let activeAppRequiredShards = $state(new Set());
+let autostartShards = $state(new Set());
+let mountedViewIds = $state(new Set());
+let focusedViewId = $state(null);
+let userBindings = $state({});
+const platform = detectPlatform();
+export function setActiveApp(appId, requiredShards) {
+    activeAppId = appId;
+    activeAppRequiredShards = new Set(requiredShards);
+}
+export function setAutostartShards(shards) {
+    autostartShards = new Set(shards);
+}
+export function setMountedViewIds(ids) {
+    mountedViewIds = new Set(ids);
+}
+/**
+ * One-shot snapshot: walk the active layout tree and update
+ * `mountedViewIds` to match. Non-reactive — call from an `$effect` that
+ * reads `layoutStore.tree` to keep the set in sync as the tree mutates.
+ * Shell.svelte owns that effect during boot.
+ */
+export function syncMountedViewIdsFromLayout() {
+    const refs = collectTreeSlotRefs(layoutStore.tree);
+    const ids = new Set();
+    for (const r of refs) {
+        if (r.viewId !== null)
+            ids.add(r.viewId);
+    }
+    mountedViewIds = ids;
+}
+export function setFocusedViewId(id) {
+    focusedViewId = id;
+}
+export function setUserBindings(bindings) {
+    userBindings = Object.assign({}, bindings);
+}
+export function getLiveDispatcherState() {
+    return {
+        activeAppId,
+        activeAppRequiredShards,
+        autostartShards,
+        mountedViewIds,
+        focusedViewId,
+        selection: getSelection(),
+        bindings: userBindings,
+        platform,
+    };
+}
+export function addAutostartShard(id) {
+    if (!autostartShards.has(id)) {
+        autostartShards = new Set([...autostartShards, id]);
+    }
+}
+export function __resetDispatcherStateForTest() {
+    activeAppId = null;
+    activeAppRequiredShards = new Set();
+    autostartShards = new Set();
+    mountedViewIds = new Set();
+    focusedViewId = null;
+    userBindings = {};
+}

package/dist/actions/state.test.d.ts

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