sh3-core 0.10.5 → 0.11.4

package/dist/actions/dispatcher.svelte.js

@@ -0,0 +1,104 @@
+/*
+ * Pure dispatcher — scope activation + tier index build. DOM wiring
+ * (keydown, focus tracking, user zone subscribe) lives in listeners.ts.
+ * This module exposes testable state transitions; listeners feed it
+ * state snapshots.
+ */
+import { effectiveShortcut } from './bindings';
+import { scopeToTier, normalizeScope } from './scope-helpers';
+export const TIER_ORDER = ['element', 'focus', 'view', 'app', 'home'];
+export function isScopeActive(scope, state, ownerShardId) {
+    if (scope === 'home') {
+        return state.activeAppId === null;
+    }
+    if (scope === 'app') {
+        if (state.activeAppId === null)
+            return false;
+        if (!ownerShardId)
+            return false;
+        return (state.activeAppRequiredShards.has(ownerShardId) ||
+            state.autostartShards.has(ownerShardId));
+    }
+    if (typeof scope === 'string') {
+        if (scope.startsWith('view:')) {
+            return state.mountedViewIds.has(scope.slice(5));
+        }
+        if (scope.startsWith('focus:')) {
+            return state.focusedViewId === scope.slice(6);
+        }
+    }
+    if (typeof scope === 'object' && 'element' in scope) {
+        return state.selection !== null && state.selection.type === scope.element;
+    }
+    return false;
+}
+export function buildTierIndex(entries, state) {
+    const idx = {
+        element: new Map(),
+        focus: new Map(),
+        view: new Map(),
+        app: new Map(),
+        home: new Map(),
+    };
+    for (const entry of entries) {
+        const shortcut = effectiveShortcut(entry.action, state.bindings, state.platform);
+        if (!shortcut)
+            continue;
+        for (const scope of normalizeScope(entry.action.scope)) {
+            if (!isScopeActive(scope, state, entry.ownerShardId))
+                continue;
+            const tier = scopeToTier(scope);
+            const existing = idx[tier].get(shortcut);
+            if (existing && existing !== entry.action.id) {
+                console.warn(`[sh3] Shortcut "${shortcut}" in tier "${tier}" is bound to both ` +
+                    `"${existing}" and "${entry.action.id}"; first-registered wins. ` +
+                    `Users can rebind to resolve.`);
+                continue;
+            }
+            idx[tier].set(shortcut, entry.action.id);
+        }
+    }
+    return idx;
+}
+function isTextInput(target) {
+    if (!(target instanceof Element))
+        return false;
+    const tag = target.tagName;
+    if (tag === 'INPUT' || tag === 'TEXTAREA')
+        return true;
+    const ce = target.contentEditable;
+    if (ce === 'true' || ce === 'plaintext-only')
+        return true;
+    // Fallback: check attribute directly (happy-dom doesn't reflect the property correctly)
+    const attr = target.getAttribute('contenteditable');
+    if (attr === 'true' || attr === '' || attr === 'plaintext-only')
+        return true;
+    return false;
+}
+export function dispatchKeydown(env) {
+    var _a, _b, _c;
+    const idx = buildTierIndex(env.entries, env.state);
+    const actionById = new Map(env.entries.map((e) => [e.action.id, e]));
+    for (const tier of TIER_ORDER) {
+        const id = idx[tier].get(env.shortcut);
+        if (!id)
+            continue;
+        const entry = actionById.get(id);
+        if (!entry)
+            continue;
+        // Input-target blocking
+        if (isTextInput(env.target) && !entry.action.allowInInputs) {
+            return null;
+        }
+        env.runAction(id, {
+            action: { id: entry.action.id, label: entry.action.label },
+            appId: env.state.activeAppId,
+            viewId: (_a = env.state.focusedViewId) !== null && _a !== void 0 ? _a : undefined,
+            selection: (_b = env.state.selection) !== null && _b !== void 0 ? _b : undefined,
+            invokedVia: 'keyboard',
+            dispatch: (_c = env.dispatch) !== null && _c !== void 0 ? _c : (() => { }),
+        });
+        return id;
+    }
+    return null;
+}

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

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

package/dist/actions/dispatcher.test.js

@@ -0,0 +1,155 @@
+import { describe, it, expect, vi } from 'vitest';
+import { buildTierIndex, isScopeActive, dispatchKeydown, } from './dispatcher.svelte';
+const mkEntry = (action, owner = 'shard.x') => ({
+    ownerShardId: owner,
+    action: Object.assign({ id: 'a', label: 'A', scope: 'home', run: () => { } }, action),
+});
+const mkState = (overrides = {}) => (Object.assign({ activeAppId: null, activeAppRequiredShards: new Set(), autostartShards: new Set(), mountedViewIds: new Set(), focusedViewId: null, selection: null, bindings: {}, platform: 'other' }, overrides));
+describe('isScopeActive', () => {
+    it('home active iff no app', () => {
+        expect(isScopeActive('home', mkState())).toBe(true);
+        expect(isScopeActive('home', mkState({ activeAppId: 'app.a' }))).toBe(false);
+    });
+    it('app active when app is loaded and declaring shard is required', () => {
+        const state = mkState({
+            activeAppId: 'app.a',
+            activeAppRequiredShards: new Set(['shard.x']),
+        });
+        expect(isScopeActive('app', state, 'shard.x')).toBe(true);
+        expect(isScopeActive('app', state, 'shard.y')).toBe(false);
+    });
+    it('app active for autostart shards regardless of requiredShards', () => {
+        const state = mkState({
+            activeAppId: 'app.a',
+            activeAppRequiredShards: new Set(),
+            autostartShards: new Set(['__sh3core__']),
+        });
+        expect(isScopeActive('app', state, '__sh3core__')).toBe(true);
+    });
+    it('view:X active iff X is mounted', () => {
+        const state = mkState({ mountedViewIds: new Set(['editor']) });
+        expect(isScopeActive('view:editor', state)).toBe(true);
+        expect(isScopeActive('view:terminal', state)).toBe(false);
+    });
+    it('focus:X active iff X is the focused view', () => {
+        const state = mkState({ focusedViewId: 'editor' });
+        expect(isScopeActive('focus:editor', state)).toBe(true);
+        expect(isScopeActive('focus:terminal', state)).toBe(false);
+    });
+    it('element matches selection type', () => {
+        const state = mkState({ selection: { type: 'orb', ref: 1, ownerShardId: 'shard.x' } });
+        expect(isScopeActive({ element: 'orb' }, state)).toBe(true);
+        expect(isScopeActive({ element: 'node' }, state)).toBe(false);
+        expect(isScopeActive({ element: 'orb' }, mkState())).toBe(false);
+    });
+});
+describe('buildTierIndex', () => {
+    it('places a home-scope action in the home tier with its shortcut', () => {
+        const entries = [
+            mkEntry({ id: 'x', scope: 'home', defaultShortcut: 'Ctrl+S' }),
+        ];
+        const idx = buildTierIndex(entries, mkState());
+        expect(idx.home.get('Ctrl+S')).toBe('x');
+        expect(idx.app.size).toBe(0);
+    });
+    it('ignores actions whose scope is inactive', () => {
+        const entries = [
+            mkEntry({ id: 'x', scope: 'app', defaultShortcut: 'Ctrl+S' }),
+        ];
+        // No app loaded → app scope inactive.
+        const idx = buildTierIndex(entries, mkState());
+        expect(idx.app.size).toBe(0);
+    });
+    it('places array-scope action in every matching tier', () => {
+        const entries = [
+            mkEntry({ id: 'p', scope: ['home', 'app'], defaultShortcut: 'Mod+K' }),
+        ];
+        const state = mkState({
+            activeAppId: null, // home active
+            autostartShards: new Set(['shard.x']),
+        });
+        const idx = buildTierIndex(entries, state);
+        // Home is active; app is not (no app).
+        expect(idx.home.get('Ctrl+K')).toBe('p');
+        expect(idx.app.size).toBe(0);
+    });
+    it('applies user override to the indexed shortcut', () => {
+        const entries = [
+            mkEntry({ id: 'shard.x.save', scope: 'home', defaultShortcut: 'Ctrl+S' }),
+        ];
+        const idx = buildTierIndex(entries, mkState({
+            bindings: { 'shard.x.save': 'Ctrl+Shift+S' },
+        }));
+        expect(idx.home.has('Ctrl+S')).toBe(false);
+        expect(idx.home.get('Ctrl+Shift+S')).toBe('shard.x.save');
+    });
+    it('null override disables the shortcut entirely', () => {
+        const entries = [
+            mkEntry({ id: 'a', scope: 'home', defaultShortcut: 'Ctrl+S' }),
+        ];
+        const idx = buildTierIndex(entries, mkState({ bindings: { a: null } }));
+        expect(idx.home.size).toBe(0);
+    });
+    it('first-registered wins and warns on same-tier shortcut conflict', () => {
+        const warn = vi.spyOn(console, 'warn').mockImplementation(() => { });
+        const entries = [
+            mkEntry({ id: 'first', scope: 'home', defaultShortcut: 'Ctrl+S' }),
+            mkEntry({ id: 'second', scope: 'home', defaultShortcut: 'Ctrl+S' }),
+        ];
+        const idx = buildTierIndex(entries, mkState());
+        expect(idx.home.get('Ctrl+S')).toBe('first');
+        expect(warn).toHaveBeenCalled();
+        warn.mockRestore();
+    });
+});
+const mkEnv = (overrides = {}) => (Object.assign({ target: null, shortcut: 'Ctrl+S', state: mkState(), entries: [], runAction: vi.fn() }, overrides));
+describe('dispatchKeydown', () => {
+    it('returns null when no match', () => {
+        const env = mkEnv();
+        const result = dispatchKeydown(env);
+        expect(result).toBeNull();
+        expect(env.runAction).not.toHaveBeenCalled();
+    });
+    it('matches in innermost tier and runs the action', () => {
+        const runAction = vi.fn();
+        const entries = [mkEntry({ id: 'home.x', scope: 'home', defaultShortcut: 'Ctrl+S' })];
+        const env = mkEnv({ entries, runAction });
+        const result = dispatchKeydown(env);
+        expect(result).toBe('home.x');
+        expect(runAction).toHaveBeenCalledWith('home.x', expect.objectContaining({ invokedVia: 'keyboard' }));
+    });
+    it('element tier beats app tier on same shortcut', () => {
+        const runAction = vi.fn();
+        const entries = [
+            mkEntry({ id: 'el', scope: { element: 'orb' }, defaultShortcut: 'Ctrl+S' }),
+            mkEntry({ id: 'app', scope: 'app', defaultShortcut: 'Ctrl+S' }, '__sh3core__'),
+        ];
+        const state = mkState({
+            activeAppId: 'a',
+            activeAppRequiredShards: new Set(),
+            autostartShards: new Set(['__sh3core__']),
+            selection: { type: 'orb', ref: 1, ownerShardId: 's' },
+        });
+        const result = dispatchKeydown(mkEnv({ entries, runAction, state }));
+        expect(result).toBe('el');
+    });
+    it('blocks when target is <input> and allowInInputs is false', () => {
+        const inp = document.createElement('input');
+        const entries = [mkEntry({ id: 'x', scope: 'home', defaultShortcut: 'Ctrl+S' })];
+        const result = dispatchKeydown(mkEnv({ entries, target: inp }));
+        expect(result).toBeNull();
+    });
+    it('fires when target is <input> and allowInInputs is true', () => {
+        const inp = document.createElement('input');
+        const entries = [mkEntry({ id: 'x', scope: 'home', defaultShortcut: 'Ctrl+S', allowInInputs: true })];
+        const result = dispatchKeydown(mkEnv({ entries, target: inp }));
+        expect(result).toBe('x');
+    });
+    it('treats contenteditable like <input>', () => {
+        const div = document.createElement('div');
+        div.setAttribute('contenteditable', 'true');
+        const entries = [mkEntry({ id: 'x', scope: 'home', defaultShortcut: 'Ctrl+S' })];
+        const result = dispatchKeydown(mkEnv({ entries, target: div }));
+        expect(result).toBeNull();
+    });
+});

package/dist/actions/listActive.d.ts

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

package/dist/actions/listActive.js

@@ -0,0 +1,42 @@
+/*
+ * Pure read-side producer for `shell.actions.listActive()`.
+ *
+ * Given a snapshot of the action registry and the dispatcher state,
+ * return one `ActiveActionDescriptor` per currently-active action, in
+ * tier-innermost-first order (element > focus > view > app > home),
+ * with registration order preserved within a tier.
+ *
+ * The shell's live wrapper calls this with `listActions()` + `getLiveDispatcherState()`.
+ */
+import { TIER_ORDER, } from './dispatcher.svelte';
+import { effectiveShortcutWithSource } from './bindings';
+import { innermostActiveScope, scopeBadge, scopeToTier } from './scope-helpers';
+export function listActiveFromEntries(entries, state) {
+    const byTier = {
+        element: [], focus: [], view: [], app: [], home: [],
+    };
+    const seen = new Set();
+    for (const entry of entries) {
+        if (seen.has(entry.action.id))
+            continue;
+        const winning = innermostActiveScope(entry.action.scope, state, entry.ownerShardId);
+        if (!winning)
+            continue;
+        seen.add(entry.action.id);
+        const { shortcut, source } = effectiveShortcutWithSource(entry.action, state.bindings, state.platform);
+        byTier[scopeToTier(winning)].push({
+            id: entry.action.id,
+            label: entry.action.label,
+            effectiveShortcut: shortcut,
+            bindingSource: source,
+            scope: winning,
+            scopeBadge: scopeBadge(winning),
+            group: entry.action.group,
+            icon: entry.action.icon,
+            ownerShardId: entry.ownerShardId,
+            paletteItem: entry.action.paletteItem !== false,
+            contextItem: entry.action.contextItem !== false,
+        });
+    }
+    return TIER_ORDER.flatMap((tier) => byTier[tier]);
+}

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

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

package/dist/actions/listActive.test.js

@@ -0,0 +1,86 @@
+import { describe, it, expect } from 'vitest';
+import { listActiveFromEntries } from './listActive';
+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('listActiveFromEntries', () => {
+    it('omits actions whose scope is not active', () => {
+        const entries = [mkEntry({ id: 'p', scope: 'app' })];
+        expect(listActiveFromEntries(entries, mkState())).toEqual([]);
+    });
+    it('includes an active home action with default shortcut resolution', () => {
+        const entries = [mkEntry({
+                id: 'open', label: 'Open', scope: 'home', defaultShortcut: 'Mod+O',
+            })];
+        const out = listActiveFromEntries(entries, mkState({ platform: 'mac' }));
+        expect(out).toHaveLength(1);
+        expect(out[0]).toMatchObject({
+            id: 'open', label: 'Open',
+            effectiveShortcut: 'Meta+O', bindingSource: 'default',
+            scope: 'home', scopeBadge: null,
+        });
+    });
+    it('reports innermost tier for multi-scope action', () => {
+        const entries = [mkEntry({
+                id: 'm', scope: ['app', 'view:editor'],
+            }, '__sh3core__')];
+        const state = mkState({
+            activeAppId: 'a', autostartShards: new Set(['__sh3core__']),
+            mountedViewIds: new Set(['editor']),
+        });
+        const out = listActiveFromEntries(entries, state);
+        expect(out[0].scope).toBe('view:editor');
+        expect(out[0].scopeBadge).toBe('view:editor');
+    });
+    it('reports bindingSource=disabled when user null-rebound', () => {
+        const entries = [mkEntry({
+                id: 'x', scope: 'home', defaultShortcut: 'Mod+S',
+            })];
+        const state = mkState({ bindings: { x: null } });
+        const out = listActiveFromEntries(entries, state);
+        expect(out[0].effectiveShortcut).toBeNull();
+        expect(out[0].bindingSource).toBe('disabled');
+    });
+    it('reports bindingSource=none when no default and no override', () => {
+        const entries = [mkEntry({ id: 'x', scope: 'home' })];
+        const out = listActiveFromEntries(entries, mkState());
+        expect(out[0].effectiveShortcut).toBeNull();
+        expect(out[0].bindingSource).toBe('none');
+    });
+    it('carries paletteItem/contextItem defaults and overrides', () => {
+        const entries = [mkEntry({
+                id: 'a', scope: 'home', paletteItem: false,
+            })];
+        const out = listActiveFromEntries(entries, mkState());
+        expect(out[0].paletteItem).toBe(false);
+        expect(out[0].contextItem).toBe(true); // defaults to true
+    });
+    it('dedupes by action id', () => {
+        const entries = [
+            mkEntry({ id: 'dup', scope: 'home' }, 'shard.a'),
+            mkEntry({ id: 'dup', scope: 'home' }, 'shard.b'),
+        ];
+        const out = listActiveFromEntries(entries, mkState());
+        expect(out).toHaveLength(1);
+        expect(out[0].ownerShardId).toBe('shard.a');
+    });
+    it('orders innermost tier first, stable by registration inside a tier', () => {
+        // `app` and `view:editor` both activate under an active app with the
+        // owning shard autostart-registered and the view mounted.
+        const entries = [
+            mkEntry({ id: 'a1', scope: 'app', label: 'A1' }, '__sh3core__'),
+            mkEntry({ id: 'v1', scope: 'view:editor', label: 'V1' }, '__sh3core__'),
+            mkEntry({ id: 'a2', scope: 'app', label: 'A2' }, '__sh3core__'),
+        ];
+        const state = mkState({
+            activeAppId: 'a',
+            autostartShards: new Set(['__sh3core__']),
+            mountedViewIds: new Set(['editor']),
+        });
+        const out = listActiveFromEntries(entries, state);
+        // view tier first (innermost of the two), then app tier in reg order.
+        expect(out.map((d) => d.id)).toEqual(['v1', 'a1', 'a2']);
+    });
+});

package/dist/actions/listeners.d.ts

@@ -0,0 +1,11 @@
+export interface OpenContextMenuOpts {
+    x: number;
+    y: number;
+}
+export interface OpenPaletteOpts {
+    prefill?: string;
+}
+export declare function attachGlobalListeners(): void;
+export declare function detachGlobalListeners(): void;
+export declare function openContextMenu(opts: OpenContextMenuOpts): void;
+export declare function openPalette(opts?: OpenPaletteOpts): void;

package/dist/actions/listeners.js

@@ -0,0 +1,180 @@
+/*
+ * Document-level listener wiring for actions. Single keydown and single
+ * contextmenu listener, attached at shell boot (Task 18) and removed on
+ * shell teardown.
+ */
+import { listActions } from './registry';
+import { dispatchKeydown } from './dispatcher.svelte';
+import { getLiveDispatcherState, setFocusedViewId, } from './state.svelte';
+import { eventToShortcut } from './shortcuts';
+import ContextMenu from './ContextMenu.svelte';
+import { buildContextMenuModel } from './contextMenuModel';
+import CommandPalette from './CommandPalette.svelte';
+import { buildPaletteCandidates } from './paletteModel';
+import { shell } from '../shellRuntime.svelte';
+let attached = false;
+function viewIdOfEl(el) {
+    var _a;
+    if (!el)
+        return null;
+    const host = el.closest('[data-sh3-view]');
+    return (_a = host === null || host === void 0 ? void 0 : host.getAttribute('data-sh3-view')) !== null && _a !== void 0 ? _a : null;
+}
+function runAction(actionId, ctx) {
+    const entry = listActions().find((e) => e.action.id === actionId);
+    if (!entry)
+        return;
+    try {
+        void entry.action.run(ctx);
+    }
+    catch (err) {
+        console.error(`[sh3] action "${actionId}" threw:`, err);
+    }
+}
+/**
+ * Invoke another action by id from within an action's `run`. Builds a fresh
+ * dispatch context using current live state with `invokedVia: 'programmatic'`.
+ * Called via `ctx.dispatch(id)` on ActionDispatchContext.
+ */
+function chainedDispatch(actionId) {
+    var _a, _b;
+    const entry = listActions().find((e) => e.action.id === actionId);
+    if (!entry) {
+        console.warn(`[sh3] ctx.dispatch("${actionId}") — no action registered with that id.`);
+        return;
+    }
+    const state = getLiveDispatcherState();
+    runAction(actionId, {
+        action: { id: entry.action.id, label: entry.action.label },
+        appId: state.activeAppId,
+        viewId: (_a = state.focusedViewId) !== null && _a !== void 0 ? _a : undefined,
+        selection: (_b = state.selection) !== null && _b !== void 0 ? _b : undefined,
+        invokedVia: 'programmatic',
+        dispatch: chainedDispatch,
+    });
+}
+function onFocusIn(ev) {
+    const id = viewIdOfEl(ev.target);
+    setFocusedViewId(id);
+}
+function onFocusOut(_ev) {
+    // Defer — a focusout is usually followed immediately by focusin on the next element.
+    queueMicrotask(() => {
+        const id = viewIdOfEl(document.activeElement);
+        setFocusedViewId(id);
+    });
+}
+function isNativeOptOut(target) {
+    if (!(target instanceof Element))
+        return false;
+    return target.closest('[data-sh3-context-menu="native"]') !== null;
+}
+function onContextMenu(ev) {
+    if (isNativeOptOut(ev.target))
+        return;
+    const entries = listActions();
+    const state = getLiveDispatcherState();
+    const model = buildContextMenuModel(entries, state);
+    if (model.tiers.length === 0)
+        return;
+    ev.preventDefault();
+    const handle = shell.popup.show(ContextMenu, { anchor: { x: ev.clientX, y: ev.clientY } }, {
+        model,
+        onInvoke: (id) => {
+            var _a, _b;
+            const entry = listActions().find((e) => e.action.id === id);
+            if (entry) {
+                try {
+                    void entry.action.run({
+                        action: { id, label: entry.action.label },
+                        appId: state.activeAppId,
+                        viewId: (_a = state.focusedViewId) !== null && _a !== void 0 ? _a : undefined,
+                        selection: (_b = state.selection) !== null && _b !== void 0 ? _b : undefined,
+                        invokedVia: 'context-menu',
+                        dispatch: chainedDispatch,
+                    });
+                }
+                catch (err) {
+                    console.error(`[sh3] context-menu action "${id}" threw:`, err);
+                }
+            }
+        },
+        onClose: () => handle.close(),
+    });
+}
+function onKeydown(ev) {
+    const shortcut = eventToShortcut(ev);
+    if (!shortcut)
+        return; // pure modifier press
+    const entries = listActions();
+    const state = getLiveDispatcherState();
+    const matched = dispatchKeydown({
+        target: ev.target,
+        shortcut,
+        state,
+        entries,
+        runAction,
+        dispatch: chainedDispatch,
+    });
+    if (matched)
+        ev.preventDefault();
+}
+export function attachGlobalListeners() {
+    if (attached)
+        return;
+    attached = true;
+    document.addEventListener('keydown', onKeydown);
+    document.addEventListener('focusin', onFocusIn);
+    document.addEventListener('focusout', onFocusOut);
+    document.addEventListener('contextmenu', onContextMenu);
+}
+export function detachGlobalListeners() {
+    if (!attached)
+        return;
+    attached = false;
+    document.removeEventListener('keydown', onKeydown);
+    document.removeEventListener('focusin', onFocusIn);
+    document.removeEventListener('focusout', onFocusOut);
+    document.removeEventListener('contextmenu', onContextMenu);
+}
+export function openContextMenu(opts) {
+    const fakeEvent = { target: null, clientX: opts.x, clientY: opts.y, preventDefault: () => { } };
+    onContextMenu(fakeEvent);
+}
+const RECENCY_CAP = 20;
+let recency = [];
+function recordUse(id) {
+    recency = [id, ...recency.filter((x) => x !== id)].slice(0, RECENCY_CAP);
+}
+export function openPalette(opts) {
+    var _a;
+    const entries = listActions();
+    const state = getLiveDispatcherState();
+    const candidates = buildPaletteCandidates(entries, state);
+    const handle = shell.modal.open(CommandPalette, {
+        candidates,
+        recency,
+        prefill: (_a = opts === null || opts === void 0 ? void 0 : opts.prefill) !== null && _a !== void 0 ? _a : '',
+        onInvoke: (id) => {
+            var _a, _b;
+            const entry = listActions().find((e) => e.action.id === id);
+            if (!entry)
+                return;
+            recordUse(id);
+            try {
+                void entry.action.run({
+                    action: { id, label: entry.action.label },
+                    appId: state.activeAppId,
+                    viewId: (_a = state.focusedViewId) !== null && _a !== void 0 ? _a : undefined,
+                    selection: (_b = state.selection) !== null && _b !== void 0 ? _b : undefined,
+                    invokedVia: 'palette',
+                    dispatch: chainedDispatch,
+                });
+            }
+            catch (err) {
+                console.error(`[sh3] palette action "${id}" threw:`, err);
+            }
+        },
+        onClose: () => handle.close(),
+    }, { dismissOnBackdrop: true });
+}

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

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