sh3-core 0.10.5 → 0.11.2

package/dist/actions/dispatcher.svelte.js

@@ -0,0 +1,117 @@
+/*
+ * 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';
+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;
+}
+function scopeToTier(scope) {
+    if (scope === 'home')
+        return 'home';
+    if (scope === 'app')
+        return 'app';
+    if (typeof scope === 'string' && scope.startsWith('view:'))
+        return 'view';
+    if (typeof scope === 'string' && scope.startsWith('focus:'))
+        return 'focus';
+    return 'element';
+}
+function normalizeScope(scope) {
+    return Array.isArray(scope) ? scope : [scope];
+}
+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/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 {};

package/dist/actions/listeners.test.js

@@ -0,0 +1,149 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { attachGlobalListeners, detachGlobalListeners, openPalette } from './listeners';
+import { registerAction, __resetActionsRegistryForTest } from './registry';
+import { __resetContributionsForTest } from '../contributions/registry';
+import { __resetDispatcherStateForTest, setActiveApp, setMountedViewIds, setFocusedViewId, } from './state.svelte';
+import { registerLayerRoot, unregisterLayerRoot } from '../overlays/roots';
+import { __resetPopupManagerForTest } from '../overlays/popup';
+import { modalManager } from '../overlays/modal';
+function pressKey(key, opts = {}, target) {
+    const ev = new KeyboardEvent('keydown', Object.assign({ key, bubbles: true, cancelable: true }, opts));
+    if (target) {
+        Object.defineProperty(ev, 'target', { value: target });
+    }
+    return document.dispatchEvent(ev);
+}
+describe('global keydown listener', () => {
+    beforeEach(() => {
+        __resetContributionsForTest();
+        __resetActionsRegistryForTest();
+        __resetDispatcherStateForTest();
+        attachGlobalListeners();
+    });
+    afterEach(() => {
+        detachGlobalListeners();
+    });
+    it('invokes a matched home-scope action and preventDefault()s', () => {
+        const run = vi.fn();
+        registerAction({ id: 'a.x', label: 'X', scope: 'home', defaultShortcut: 'Ctrl+S', run }, 'a');
+        const defaulted = pressKey('s', { ctrlKey: true });
+        expect(run).toHaveBeenCalled();
+        expect(defaulted).toBe(false); // preventDefault called → dispatch returns false
+    });
+    it('lets unmatched keypresses bubble', () => {
+        const defaulted = pressKey('s', { ctrlKey: true });
+        expect(defaulted).toBe(true);
+    });
+    it('blocks when target is <input> and allowInInputs is absent', () => {
+        const run = vi.fn();
+        registerAction({ id: 'a.x', label: 'X', scope: 'home', defaultShortcut: 'Ctrl+S', run }, 'a');
+        const input = document.createElement('input');
+        document.body.appendChild(input);
+        pressKey('s', { ctrlKey: true }, input);
+        expect(run).not.toHaveBeenCalled();
+        input.remove();
+    });
+    it('reads focusedViewId from data-sh3-view ancestor of activeElement', () => {
+        const run = vi.fn();
+        registerAction({ id: 'a.x', label: 'X', scope: 'focus:editor', defaultShortcut: 'Ctrl+S', run }, 'a');
+        setActiveApp('app.a', new Set(['a']));
+        setMountedViewIds(new Set(['editor']));
+        const wrap = document.createElement('div');
+        wrap.setAttribute('data-sh3-view', 'editor');
+        const btn = document.createElement('button');
+        wrap.appendChild(btn);
+        document.body.appendChild(wrap);
+        btn.focus();
+        // Manually set focusedViewId in case happy-dom doesn't fire focusin synchronously
+        setFocusedViewId('editor');
+        pressKey('s', { ctrlKey: true }, btn);
+        expect(run).toHaveBeenCalled();
+        wrap.remove();
+    });
+});
+describe('global contextmenu listener', () => {
+    let popupLayerRoot;
+    beforeEach(() => {
+        vi.stubGlobal('innerWidth', 2000);
+        vi.stubGlobal('innerHeight', 2000);
+        popupLayerRoot = document.createElement('div');
+        popupLayerRoot.style.position = 'relative';
+        document.body.appendChild(popupLayerRoot);
+        registerLayerRoot('popup', popupLayerRoot);
+        __resetContributionsForTest();
+        __resetActionsRegistryForTest();
+        __resetDispatcherStateForTest();
+        attachGlobalListeners();
+    });
+    afterEach(() => {
+        detachGlobalListeners();
+        __resetPopupManagerForTest();
+        unregisterLayerRoot('popup');
+        popupLayerRoot.remove();
+        vi.unstubAllGlobals();
+    });
+    it('opens popup on contextmenu and preventDefault()s native', () => {
+        registerAction({ id: 'a.x', label: 'Dup', scope: 'home', contextItem: true, run: () => { } }, 'a');
+        const target = document.createElement('div');
+        document.body.appendChild(target);
+        const ev = new MouseEvent('contextmenu', { clientX: 10, clientY: 20, bubbles: true, cancelable: true });
+        Object.defineProperty(ev, 'target', { value: target });
+        const def = target.dispatchEvent(ev);
+        expect(def).toBe(false); // preventDefault
+        expect(document.querySelector('.sh3-context-menu')).not.toBeNull();
+        target.remove();
+    });
+    it('opts out via data-sh3-context-menu="native"', () => {
+        registerAction({ id: 'a.x', label: 'Dup', scope: 'home', contextItem: true, run: () => { } }, 'a');
+        const target = document.createElement('div');
+        target.setAttribute('data-sh3-context-menu', 'native');
+        document.body.appendChild(target);
+        const ev = new MouseEvent('contextmenu', { clientX: 10, clientY: 20, bubbles: true, cancelable: true });
+        Object.defineProperty(ev, 'target', { value: target });
+        const def = target.dispatchEvent(ev);
+        expect(def).toBe(true); // native preserved
+        expect(document.querySelector('.sh3-context-menu')).toBeNull();
+        target.remove();
+    });
+    it('does not open when no contextItem actions are active', () => {
+        registerAction({ id: 'a.x', label: 'Save', scope: 'home', contextItem: false, run: () => { } }, 'a');
+        const target = document.createElement('div');
+        document.body.appendChild(target);
+        const ev = new MouseEvent('contextmenu', { clientX: 10, clientY: 20, bubbles: true, cancelable: true });
+        Object.defineProperty(ev, 'target', { value: target });
+        const def = target.dispatchEvent(ev);
+        expect(def).toBe(true); // no menu → native preserved
+        target.remove();
+    });
+});
+describe('command palette', () => {
+    let modalLayerRoot;
+    beforeEach(() => {
+        modalLayerRoot = document.createElement('div');
+        modalLayerRoot.style.position = 'relative';
+        document.body.appendChild(modalLayerRoot);
+        registerLayerRoot('modal', modalLayerRoot);
+        __resetContributionsForTest();
+        __resetActionsRegistryForTest();
+        __resetDispatcherStateForTest();
+        attachGlobalListeners();
+    });
+    afterEach(() => {
+        detachGlobalListeners();
+        modalManager.closeAll();
+        unregisterLayerRoot('modal');
+        modalLayerRoot.remove();
+    });
+    it('openPalette mounts the CommandPalette modal', async () => {
+        registerAction({ id: 'a.x', label: 'Duplicate Orb', scope: 'home', run: () => { } }, 'a');
+        openPalette();
+        await Promise.resolve();
+        expect(document.querySelector('.sh3-palette')).not.toBeNull();
+    });
+    it('palette populates from active actions', async () => {
+        registerAction({ id: 'a.y', label: 'Rename', scope: 'home', run: () => { } }, 'a');
+        openPalette();
+        await Promise.resolve();
+        expect(document.querySelector('.sh3-palette-item')).not.toBeNull();
+    });
+});

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

@@ -0,0 +1,11 @@
+export interface PaletteCandidate {
+    id: string;
+    label: string;
+    shortcut: string | null;
+    scopeBadge: string | null;
+}
+export interface RankedCandidate extends PaletteCandidate {
+    score: number;
+}
+export declare function scoreMatch(label: string, query: string): number | null;
+export declare function rankPaletteEntries(candidates: PaletteCandidate[], query: string, recency: string[]): RankedCandidate[];

package/dist/actions/palette-scorer.js

@@ -0,0 +1,49 @@
+/*
+ * Fuzzy scorer for the command palette. Subsequence match with
+ * prefix-bonus and tight-run scoring. Session-local recency ring
+ * breaks ties.
+ */
+export function scoreMatch(label, query) {
+    if (!query)
+        return 0;
+    const L = label.toLowerCase();
+    const Q = query.toLowerCase();
+    let i = 0, j = 0;
+    let score = 0;
+    let runLen = 0;
+    let prevMatchIdx = -2;
+    while (i < L.length && j < Q.length) {
+        if (L[i] === Q[j]) {
+            const prefixBonus = i === 0 ? 5 : 0;
+            const runBonus = i === prevMatchIdx + 1 ? ++runLen : (runLen = 1);
+            score += 1 + prefixBonus + runBonus;
+            prevMatchIdx = i;
+            j++;
+        }
+        else {
+            runLen = 0;
+        }
+        i++;
+    }
+    return j === Q.length ? score : null;
+}
+export function rankPaletteEntries(candidates, query, recency) {
+    const ranked = [];
+    for (const c of candidates) {
+        const s = scoreMatch(c.label, query);
+        if (s === null)
+            continue;
+        ranked.push(Object.assign(Object.assign({}, c), { score: s }));
+    }
+    const recencyIdx = new Map();
+    recency.forEach((id, i) => recencyIdx.set(id, recency.length - i));
+    ranked.sort((a, b) => {
+        var _a, _b;
+        if (a.score !== b.score)
+            return b.score - a.score;
+        const ra = (_a = recencyIdx.get(a.id)) !== null && _a !== void 0 ? _a : 0;
+        const rb = (_b = recencyIdx.get(b.id)) !== null && _b !== void 0 ? _b : 0;
+        return rb - ra;
+    });
+    return ranked;
+}