sh3-core 0.11.4 → 0.11.7

package/dist/actions/listeners.js

@@ -3,12 +3,14 @@
  * contextmenu listener, attached at shell boot (Task 18) and removed on
  * shell teardown.
  */
+import { mount } from 'svelte';
 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 { buildContextMenuModel, buildContextMenuSubmenu } from './contextMenuModel';
+import ActionPanel from './ActionPanel.svelte';
 import CommandPalette from './CommandPalette.svelte';
 import { buildPaletteCandidates } from './paletteModel';
 import { shell } from '../shellRuntime.svelte';
@@ -22,7 +24,7 @@ function viewIdOfEl(el) {
 }
 function runAction(actionId, ctx) {
     const entry = listActions().find((e) => e.action.id === actionId);
-    if (!entry)
+    if (!entry || typeof entry.action.run !== 'function')
         return;
     try {
         void entry.action.run(ctx);
@@ -69,6 +71,48 @@ function isNativeOptOut(target) {
         return false;
     return target.closest('[data-sh3-context-menu="native"]') !== null;
 }
+function openContextSubmenu(parentId, state, handle) {
+    const root = document.querySelector('.sh3-popup-host');
+    if (!root)
+        return;
+    const sub = document.createElement('div');
+    sub.className = 'sh3-popup-submenu';
+    sub.style.position = 'absolute';
+    sub.style.pointerEvents = 'auto';
+    const activeRow = root.querySelector('.sh3-ctx-active');
+    const anchorRect = (activeRow !== null && activeRow !== void 0 ? activeRow : root).getBoundingClientRect();
+    sub.style.left = `${anchorRect.right + 2}px`;
+    sub.style.top = `${anchorRect.top}px`;
+    root.appendChild(sub);
+    const subItems = buildContextMenuSubmenu(listActions(), state, parentId);
+    mount(ActionPanel, {
+        target: sub,
+        props: {
+            sections: [{ id: `submenu:${parentId}`, items: subItems }],
+            onInvoke: (cid) => {
+                var _a, _b;
+                const child = listActions().find((e) => e.action.id === cid);
+                if (!child || typeof child.action.run !== 'function')
+                    return;
+                try {
+                    void child.action.run({
+                        action: { id: cid, label: child.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 submenu action "${cid}" threw:`, err);
+                }
+                handle.close();
+            },
+            onDismiss: () => handle.close(),
+        },
+    });
+}
 function onContextMenu(ev) {
     if (isNativeOptOut(ev.target))
         return;
@@ -83,20 +127,26 @@ function onContextMenu(ev) {
         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);
-                }
+            if (!entry)
+                return;
+            if (entry.action.submenu === true) {
+                openContextSubmenu(id, state, handle);
+                return;
+            }
+            if (typeof entry.action.run !== 'function')
+                return;
+            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(),
@@ -150,7 +200,7 @@ export function openPalette(opts) {
     var _a;
     const entries = listActions();
     const state = getLiveDispatcherState();
-    const candidates = buildPaletteCandidates(entries, state);
+    const candidates = buildPaletteCandidates(entries, state, { filter: opts === null || opts === void 0 ? void 0 : opts.filter });
     const handle = shell.modal.open(CommandPalette, {
         candidates,
         recency,
@@ -161,6 +211,16 @@ export function openPalette(opts) {
             if (!entry)
                 return;
             recordUse(id);
+            // Submenu drill: a parent without a run() opens a sub-palette
+            // filtered to its children. Apps that supply their own run()
+            // keep that behavior — drill is only the default.
+            if (entry.action.submenu === true && typeof entry.action.run !== 'function') {
+                handle.close();
+                openPalette({ filter: { submenuOf: id } });
+                return;
+            }
+            if (typeof entry.action.run !== 'function')
+                return;
             try {
                 void entry.action.run({
                     action: { id, label: entry.action.label },

package/dist/actions/listeners.test.js

@@ -115,6 +115,27 @@ describe('global contextmenu listener', () => {
         expect(def).toBe(true); // no menu → native preserved
         target.remove();
     });
+    it('clicking a submenu-parent row opens a nested ActionPanel listing children', async () => {
+        registerAction({ id: 'p', label: 'Open with…', scope: 'home', contextItem: true, submenu: true }, 'a');
+        registerAction({ id: 'p.a', label: 'A', scope: 'home', submenuOf: 'p', run: () => { } }, 'a');
+        registerAction({ id: 'p.b', label: 'B', scope: 'home', submenuOf: 'p', 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 });
+        target.dispatchEvent(ev);
+        await Promise.resolve();
+        expect(document.querySelectorAll('.sh3-context-menu')).toHaveLength(1);
+        const parentRow = document.querySelector('.sh3-context-menu [role="menuitem"]');
+        parentRow.click();
+        await Promise.resolve();
+        const panels = document.querySelectorAll('.sh3-context-menu');
+        expect(panels.length).toBe(2);
+        const submenuLabels = [...panels[1].querySelectorAll('[role="menuitem"] .sh3-ctx-label')]
+            .map((n) => n.textContent);
+        expect(submenuLabels).toEqual(['A', 'B']);
+        target.remove();
+    });
 });
 describe('command palette', () => {
     let modalLayerRoot;
@@ -146,4 +167,33 @@ describe('command palette', () => {
         await Promise.resolve();
         expect(document.querySelector('.sh3-palette-item')).not.toBeNull();
     });
+    it('openPalette({filter}) builds candidates filtered to children of the parent', async () => {
+        registerAction({ id: 'p', label: 'P', scope: 'home', submenu: true }, 'shard.x');
+        registerAction({ id: 'p.a', label: 'A', scope: 'home', submenuOf: 'p', run: () => { } }, 'shard.x');
+        registerAction({ id: 'p.b', label: 'B', scope: 'home', submenuOf: 'p', run: () => { } }, 'shard.x');
+        registerAction({ id: 'q', label: 'Q', scope: 'home', run: () => { } }, 'shard.x');
+        openPalette({ filter: { submenuOf: 'p' } });
+        await Promise.resolve();
+        const labels = [...document.querySelectorAll('.sh3-palette-item .sh3-palette-label')]
+            .map((n) => n.textContent)
+            .sort();
+        expect(labels).toEqual(['A', 'B']);
+    });
+    it('invoking a submenu parent with no run() opens a sub-palette filtered to its children', async () => {
+        registerAction({ id: 'p', label: 'P', scope: 'home', submenu: true }, 'shard.x');
+        registerAction({ id: 'p.a', label: 'A', scope: 'home', submenuOf: 'p', run: () => { } }, 'shard.x');
+        openPalette();
+        await Promise.resolve();
+        // The idle palette shows only the parent (children hidden until search).
+        const initial = [...document.querySelectorAll('.sh3-palette-item .sh3-palette-label')]
+            .map((n) => n.textContent);
+        expect(initial).toEqual(['P']);
+        // Clicking the parent should drill into a sub-palette listing the child.
+        const item = document.querySelector('.sh3-palette-item');
+        item.click();
+        await Promise.resolve();
+        const drilled = [...document.querySelectorAll('.sh3-palette-item .sh3-palette-label')]
+            .map((n) => n.textContent);
+        expect(drilled).toEqual(['A']);
+    });
 });

package/dist/actions/menuBarModel.d.ts

@@ -0,0 +1,42 @@
+import type { ActionEntry } from './registry';
+import type { DispatcherState } from './dispatcher.svelte';
+import type { MenuContainer } from '../apps/types';
+export interface MenuBarItem {
+    id: string;
+    label: string;
+    shortcut: string | null;
+    group: string;
+    icon: string | undefined;
+    /** True iff `Action.checked` evaluates truthy at derive time. */
+    checked: boolean;
+    /** True iff `Action.disabled` evaluates truthy at derive time. */
+    disabled: boolean;
+    /** True iff `Action.submenu === true`. */
+    submenu: boolean;
+}
+/**
+ * Resolved container list for the currently-active app:
+ *   - activeAppId == null              → returns []
+ *   - declared has entries             → returns declared, sorted by `order`
+ *                                        ascending then declaration order
+ *                                        for ties / undefined
+ *   - declared is undefined            → returns a copy of DEFAULT_MENU_CONTAINERS
+ *
+ * Callers can render unconditionally; the empty-array case naturally
+ * suppresses the menu bar at home.
+ */
+export declare function resolveMenuContainers(activeAppId: string | null, declared: readonly MenuContainer[] | undefined): MenuContainer[];
+/**
+ * Items targeting `containerId`, filtered by current scope activation
+ * and de-duplicated to the innermost active scope per action id (mirrors
+ * contextMenuModel).
+ */
+export declare function resolveMenuItems(entries: readonly ActionEntry[], state: DispatcherState, containerId: string): MenuBarItem[];
+/**
+ * Items belonging to a submenu — entries whose `submenuOf` equals
+ * `parentId` and whose scope is active. Same `MenuBarItem` shape as
+ * top-level container items. Order is registration order, matching the
+ * top-level resolver's behavior. De-duplicated by id (multi-scope
+ * children resolve to one row, mirroring `resolveMenuItems`).
+ */
+export declare function resolveSubmenuItems(entries: readonly ActionEntry[], state: DispatcherState, parentId: string): MenuBarItem[];

package/dist/actions/menuBarModel.js

@@ -0,0 +1,110 @@
+/*
+ * Pure model layer for the menu bar: resolves container list for the
+ * active app, and resolves per-container item lists by filtering the
+ * action registry by `menuItem` + scope-activation. Mirrors the
+ * de-duplication semantics of contextMenuModel.
+ */
+import { effectiveShortcut } from './bindings';
+import { innermostActiveScope } from './scope-helpers';
+import { DEFAULT_MENU_CONTAINERS } from './defaultMenuContainers';
+function evalFlag(v) {
+    if (v === undefined)
+        return false;
+    return typeof v === 'function' ? !!v() : !!v;
+}
+/**
+ * Resolved container list for the currently-active app:
+ *   - activeAppId == null              → returns []
+ *   - declared has entries             → returns declared, sorted by `order`
+ *                                        ascending then declaration order
+ *                                        for ties / undefined
+ *   - declared is undefined            → returns a copy of DEFAULT_MENU_CONTAINERS
+ *
+ * Callers can render unconditionally; the empty-array case naturally
+ * suppresses the menu bar at home.
+ */
+export function resolveMenuContainers(activeAppId, declared) {
+    if (activeAppId == null)
+        return [];
+    if (declared == null)
+        return DEFAULT_MENU_CONTAINERS.slice();
+    const indexed = declared.map((c, i) => ({ c, i }));
+    indexed.sort((a, b) => {
+        const ao = a.c.order;
+        const bo = b.c.order;
+        if (ao != null && bo != null)
+            return ao - bo || a.i - b.i;
+        if (ao != null)
+            return -1;
+        if (bo != null)
+            return 1;
+        return a.i - b.i;
+    });
+    return indexed.map((x) => x.c);
+}
+/**
+ * Items targeting `containerId`, filtered by current scope activation
+ * and de-duplicated to the innermost active scope per action id (mirrors
+ * contextMenuModel).
+ */
+export function resolveMenuItems(entries, state, containerId) {
+    var _a;
+    const out = [];
+    const seen = new Set();
+    for (const entry of entries) {
+        if (entry.action.menuItem !== containerId)
+            continue;
+        if (entry.action.submenuOf !== undefined)
+            continue;
+        if (seen.has(entry.action.id))
+            continue;
+        const winning = innermostActiveScope(entry.action.scope, state, entry.ownerShardId);
+        if (!winning)
+            continue;
+        seen.add(entry.action.id);
+        out.push({
+            id: entry.action.id,
+            label: entry.action.label,
+            shortcut: effectiveShortcut(entry.action, state.bindings, state.platform),
+            group: (_a = entry.action.group) !== null && _a !== void 0 ? _a : '',
+            icon: entry.action.icon,
+            checked: evalFlag(entry.action.checked),
+            disabled: evalFlag(entry.action.disabled),
+            submenu: entry.action.submenu === true,
+        });
+    }
+    return out;
+}
+/**
+ * Items belonging to a submenu — entries whose `submenuOf` equals
+ * `parentId` and whose scope is active. Same `MenuBarItem` shape as
+ * top-level container items. Order is registration order, matching the
+ * top-level resolver's behavior. De-duplicated by id (multi-scope
+ * children resolve to one row, mirroring `resolveMenuItems`).
+ */
+export function resolveSubmenuItems(entries, state, parentId) {
+    var _a;
+    const out = [];
+    const seen = new Set();
+    for (const entry of entries) {
+        if (entry.action.submenuOf !== parentId)
+            continue;
+        if (seen.has(entry.action.id))
+            continue;
+        const winning = innermostActiveScope(entry.action.scope, state, entry.ownerShardId);
+        if (!winning)
+            continue;
+        seen.add(entry.action.id);
+        out.push({
+            id: entry.action.id,
+            label: entry.action.label,
+            shortcut: effectiveShortcut(entry.action, state.bindings, state.platform),
+            group: (_a = entry.action.group) !== null && _a !== void 0 ? _a : '',
+            icon: entry.action.icon,
+            checked: evalFlag(entry.action.checked),
+            disabled: evalFlag(entry.action.disabled),
+            submenu: entry.action.submenu === true,
+        });
+    }
+    return out;
+}

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

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

package/dist/actions/menuBarModel.test.js

@@ -0,0 +1,158 @@
+import { describe, it, expect } from 'vitest';
+import { resolveMenuContainers, resolveMenuItems, resolveSubmenuItems, } from './menuBarModel';
+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('resolveMenuContainers', () => {
+    it('returns [] when no app is active', () => {
+        expect(resolveMenuContainers(null, undefined)).toEqual([]);
+    });
+    it('returns DEFAULT_MENU_CONTAINERS when app has no manifest.menus', () => {
+        const out = resolveMenuContainers('app.a', undefined);
+        expect(out.map((c) => c.id)).toEqual(['file', 'edit', 'view', 'window', 'help']);
+    });
+    it('returns manifest.menus when declared', () => {
+        const declared = [
+            { id: 'project', label: 'Project' },
+            { id: 'help', label: 'Help' },
+        ];
+        expect(resolveMenuContainers('app.a', declared).map((c) => c.id))
+            .toEqual(['project', 'help']);
+    });
+    it('sorts by `order` ascending, then by declaration order for ties/undefined', () => {
+        const declared = [
+            { id: 'a', label: 'A', order: 10 },
+            { id: 'b', label: 'B' },
+            { id: 'c', label: 'C', order: 5 },
+            { id: 'd', label: 'D' },
+        ];
+        expect(resolveMenuContainers('app.a', declared).map((c) => c.id))
+            .toEqual(['c', 'a', 'b', 'd']);
+    });
+});
+describe('resolveMenuItems', () => {
+    const stateWithApp = mkState({
+        activeAppId: 'app.a',
+        activeAppRequiredShards: new Set(['shard.x']),
+    });
+    it('returns only actions whose menuItem matches the container id', () => {
+        const entries = [
+            mkEntry({ id: 'open', scope: 'app', menuItem: 'file', label: 'Open' }),
+            mkEntry({ id: 'copy', scope: 'app', menuItem: 'edit', label: 'Copy' }),
+            mkEntry({ id: 'close', scope: 'app', menuItem: 'file', label: 'Close' }),
+        ];
+        const out = resolveMenuItems(entries, stateWithApp, 'file');
+        expect(out.map((i) => i.id)).toEqual(['open', 'close']);
+    });
+    it('skips actions whose scope is not currently active', () => {
+        const entries = [
+            mkEntry({ id: 'open', scope: 'app', menuItem: 'file', label: 'Open' }),
+            mkEntry({ id: 'help', scope: 'home', menuItem: 'file', label: 'Help' }),
+        ];
+        const out = resolveMenuItems(entries, stateWithApp, 'file');
+        expect(out.map((i) => i.id)).toEqual(['open']);
+    });
+    it('skips actions without a menuItem field', () => {
+        const entries = [
+            mkEntry({ id: 'a', scope: 'app', menuItem: 'file', label: 'A' }),
+            mkEntry({ id: 'b', scope: 'app', label: 'B' }),
+        ];
+        const out = resolveMenuItems(entries, stateWithApp, 'file');
+        expect(out.map((i) => i.id)).toEqual(['a']);
+    });
+    it('returns [] for an unknown container id', () => {
+        const entries = [
+            mkEntry({ id: 'open', scope: 'app', menuItem: 'file', label: 'Open' }),
+        ];
+        expect(resolveMenuItems(entries, stateWithApp, 'sausage')).toEqual([]);
+    });
+    it('de-duplicates multi-scope actions by innermost active scope', () => {
+        const state = mkState({
+            activeAppId: 'app.a',
+            activeAppRequiredShards: new Set(['shard.x']),
+            autostartShards: new Set(['shard.x']),
+        });
+        const entries = [
+            mkEntry({ id: 'p', scope: ['home', 'app'], menuItem: 'file', label: 'P' }),
+        ];
+        const out = resolveMenuItems(entries, state, 'file');
+        expect(out).toHaveLength(1);
+        expect(out[0].id).toBe('p');
+    });
+});
+describe('resolveMenuItems — checked / disabled / submenu', () => {
+    const stateWithApp = mkState({
+        activeAppId: 'app.a',
+        activeAppRequiredShards: new Set(['shard.x']),
+    });
+    it('evaluates checked: boolean to flag on the item', () => {
+        const entries = [
+            mkEntry({ id: 'a', scope: 'app', menuItem: 'view', label: 'A', checked: true }),
+        ];
+        const out = resolveMenuItems(entries, stateWithApp, 'view');
+        expect(out[0].checked).toBe(true);
+    });
+    it('evaluates checked: () => boolean on each derive', () => {
+        let v = false;
+        const entries = [
+            mkEntry({ id: 'a', scope: 'app', menuItem: 'view', label: 'A', checked: () => v }),
+        ];
+        expect(resolveMenuItems(entries, stateWithApp, 'view')[0].checked).toBe(false);
+        v = true;
+        expect(resolveMenuItems(entries, stateWithApp, 'view')[0].checked).toBe(true);
+    });
+    it('evaluates disabled: () => boolean on each derive', () => {
+        const entries = [
+            mkEntry({ id: 'a', scope: 'app', menuItem: 'view', label: 'A', disabled: () => true }),
+        ];
+        expect(resolveMenuItems(entries, stateWithApp, 'view')[0].disabled).toBe(true);
+    });
+    it('defaults checked / disabled to false when omitted', () => {
+        const entries = [
+            mkEntry({ id: 'a', scope: 'app', menuItem: 'view', label: 'A' }),
+        ];
+        const item = resolveMenuItems(entries, stateWithApp, 'view')[0];
+        expect(item.checked).toBe(false);
+        expect(item.disabled).toBe(false);
+    });
+    it('flags submenu: true parents and excludes their children from the container list', () => {
+        const entries = [
+            mkEntry({ id: 'p', scope: 'app', menuItem: 'view', label: 'Parent', submenu: true }),
+            mkEntry({ id: 'p.a', scope: 'app', label: 'A', submenuOf: 'p' }),
+            mkEntry({ id: 'p.b', scope: 'app', label: 'B', submenuOf: 'p' }),
+        ];
+        const out = resolveMenuItems(entries, stateWithApp, 'view');
+        expect(out.map((i) => i.id)).toEqual(['p']);
+        expect(out[0].submenu).toBe(true);
+    });
+});
+describe('resolveSubmenuItems', () => {
+    const stateWithApp = mkState({
+        activeAppId: 'app.a',
+        activeAppRequiredShards: new Set(['shard.x']),
+    });
+    it('returns only children whose submenuOf matches the parent id', () => {
+        const entries = [
+            mkEntry({ id: 'p', scope: 'app', menuItem: 'view', label: 'P', submenu: true }),
+            mkEntry({ id: 'p.a', scope: 'app', label: 'A', submenuOf: 'p' }),
+            mkEntry({ id: 'p.b', scope: 'app', label: 'B', submenuOf: 'p' }),
+            mkEntry({ id: 'q.x', scope: 'app', label: 'X', submenuOf: 'q' }),
+        ];
+        const out = resolveSubmenuItems(entries, stateWithApp, 'p');
+        expect(out.map((i) => i.id)).toEqual(['p.a', 'p.b']);
+    });
+    it('skips children whose scope is inactive', () => {
+        const entries = [
+            mkEntry({ id: 'p', scope: 'app', menuItem: 'view', label: 'P', submenu: true }),
+            mkEntry({ id: 'p.app', scope: 'app', label: 'AppOK', submenuOf: 'p' }),
+            mkEntry({ id: 'p.hom', scope: 'home', label: 'HomeNo', submenuOf: 'p' }),
+        ];
+        expect(resolveSubmenuItems(entries, stateWithApp, 'p').map((i) => i.id))
+            .toEqual(['p.app']);
+    });
+    it('returns [] for an unknown parent id', () => {
+        expect(resolveSubmenuItems([], stateWithApp, 'nope')).toEqual([]);
+    });
+});

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

@@ -3,6 +3,10 @@ export interface PaletteCandidate {
     label: string;
     shortcut: string | null;
     scopeBadge: string | null;
+    /** True when `Action.submenu === true`. Hint only; ranker treats it like any candidate. */
+    submenu: boolean;
+    /** Set when this candidate is a child of a submenu parent. Hidden when the palette query is empty. */
+    submenuOf?: string;
 }
 export interface RankedCandidate extends PaletteCandidate {
     score: number;

package/dist/actions/palette-scorer.js

@@ -30,6 +30,11 @@ export function scoreMatch(label, query) {
 export function rankPaletteEntries(candidates, query, recency) {
     const ranked = [];
     for (const c of candidates) {
+        // Hide submenu children from the idle (empty-query) palette so the
+        // default view stays uncluttered. A direct text match still surfaces
+        // them because the scorer runs once query is non-empty.
+        if (query === '' && c.submenuOf !== undefined)
+            continue;
         const s = scoreMatch(c.label, query);
         if (s === null)
             continue;

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

@@ -24,7 +24,7 @@ describe('scoreMatch', () => {
     });
 });
 describe('rankPaletteEntries', () => {
-    const mk = (id, label) => ({ id, label, shortcut: null, scopeBadge: null });
+    const mk = (id, label, extra = {}) => (Object.assign({ id, label, shortcut: null, scopeBadge: null, submenu: false }, extra));
     it('filters out non-matches', () => {
         const out = rankPaletteEntries([mk('a', 'save'), mk('b', 'undo')], 'redo', []);
         expect(out).toHaveLength(0);
@@ -37,4 +37,12 @@ describe('rankPaletteEntries', () => {
         const out = rankPaletteEntries([mk('a', 'save'), mk('b', 'save')], 'sa', ['b']);
         expect(out[0].id).toBe('b');
     });
+    it('hides submenu children when query is empty', () => {
+        const out = rankPaletteEntries([mk('p', 'P', { submenu: true }), mk('p.a', 'A', { submenuOf: 'p' })], '', []);
+        expect(out.map((c) => c.id)).toEqual(['p']);
+    });
+    it('surfaces submenu children when query matches them', () => {
+        const out = rankPaletteEntries([mk('p', 'Launch app', { submenu: true }), mk('p.a', 'guml', { submenuOf: 'p' })], 'guml', []);
+        expect(out.map((c) => c.id)).toContain('p.a');
+    });
 });

package/dist/actions/paletteModel.d.ts

@@ -1,4 +1,10 @@
 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[];
+export interface BuildPaletteOpts {
+    /** When set, return only children of the given submenu parent. */
+    filter?: {
+        submenuOf?: string;
+    };
+}
+export declare function buildPaletteCandidates(entries: ActionEntry[], state: DispatcherState, opts?: BuildPaletteOpts): PaletteCandidate[];

package/dist/actions/paletteModel.js

@@ -3,15 +3,34 @@
  * action, deduplicated, with shortcut and scope badge resolved. Uses
  * innermost-first scope selection so the badge matches keyboard dispatch
  * and context-menu tiering (audit: RFC #24).
+ *
+ * Submenu rules:
+ *   - When `opts.filter.submenuOf` is set, return ONLY children whose
+ *     `submenuOf` matches it. Used by sub-palette drill.
+ *   - Otherwise return all active candidates. The scorer
+ *     (`rankPaletteEntries`) is responsible for hiding children when
+ *     the user's query is empty.
+ *   - Disabled actions are hidden in all modes (v1 — see spec).
  */
 import { effectiveShortcut } from './bindings';
 import { innermostActiveScope, scopeBadge } from './scope-helpers';
-export function buildPaletteCandidates(entries, state) {
+function evalFlag(v) {
+    if (v === undefined)
+        return false;
+    return typeof v === 'function' ? !!v() : !!v;
+}
+export function buildPaletteCandidates(entries, state, opts = {}) {
+    var _a;
     const out = [];
     const seen = new Set();
+    const filterParent = (_a = opts.filter) === null || _a === void 0 ? void 0 : _a.submenuOf;
     for (const entry of entries) {
         if (entry.action.paletteItem === false)
             continue;
+        if (evalFlag(entry.action.disabled))
+            continue;
+        if (filterParent !== undefined && entry.action.submenuOf !== filterParent)
+            continue;
         if (seen.has(entry.action.id))
             continue;
         const winning = innermostActiveScope(entry.action.scope, state, entry.ownerShardId);
@@ -23,6 +42,12 @@ export function buildPaletteCandidates(entries, state) {
             label: entry.action.label,
             shortcut: effectiveShortcut(entry.action, state.bindings, state.platform),
             scopeBadge: scopeBadge(winning),
+            submenu: entry.action.submenu === true,
+            // When a submenuOf-filter is in effect, the resulting candidates are
+            // already scoped — they ARE the visible set in this palette, not
+            // hidden children of some other parent. Drop the `submenuOf` hint so
+            // the ranker doesn't apply its hide-children-on-empty rule to them.
+            submenuOf: filterParent !== undefined ? undefined : entry.action.submenuOf,
         });
     }
     return out;