sh3-core 0.11.6 → 0.11.8

package/dist/actions/listeners.d.ts

@@ -1,9 +1,15 @@
+import type { AtomicScope } from './types';
 export interface OpenContextMenuOpts {
     x: number;
     y: number;
+    scope?: AtomicScope;
 }
 export interface OpenPaletteOpts {
     prefill?: string;
+    /** Restrict candidates to children of the given submenu parent (sub-palette drill). */
+    filter?: {
+        submenuOf?: string;
+    };
 }
 export declare function attachGlobalListeners(): void;
 export declare function detachGlobalListeners(): void;

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';
@@ -20,9 +22,19 @@ function viewIdOfEl(el) {
     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 resolveAnchor(args) {
+    if (args.explicit !== undefined)
+        return args.explicit;
+    if (args.event && args.event.target) {
+        const viewId = viewIdOfEl(args.event.target);
+        if (viewId)
+            return `focus:${viewId}`;
+    }
+    return args.state.activeAppId ? 'app' : 'home';
+}
 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,12 +81,55 @@ function isNativeOptOut(target) {
         return false;
     return target.closest('[data-sh3-context-menu="native"]') !== null;
 }
+function openContextSubmenu(parentId, state, handle, anchor) {
+    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, anchor);
+    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;
     const entries = listActions();
     const state = getLiveDispatcherState();
-    const model = buildContextMenuModel(entries, state);
+    const anchor = resolveAnchor({ event: ev, state });
+    const model = buildContextMenuModel(entries, state, anchor);
     if (model.tiers.length === 0)
         return;
     ev.preventDefault();
@@ -83,20 +138,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, anchor);
+                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(),
@@ -138,8 +199,41 @@ export function detachGlobalListeners() {
     document.removeEventListener('contextmenu', onContextMenu);
 }
 export function openContextMenu(opts) {
-    const fakeEvent = { target: null, clientX: opts.x, clientY: opts.y, preventDefault: () => { } };
-    onContextMenu(fakeEvent);
+    const entries = listActions();
+    const state = getLiveDispatcherState();
+    const anchor = resolveAnchor({ explicit: opts.scope, state });
+    const model = buildContextMenuModel(entries, state, anchor);
+    if (model.tiers.length === 0)
+        return;
+    const handle = shell.popup.show(ContextMenu, { anchor: { x: opts.x, y: opts.y } }, {
+        model,
+        onInvoke: (id) => {
+            var _a, _b;
+            const entry = listActions().find((e) => e.action.id === id);
+            if (!entry)
+                return;
+            if (entry.action.submenu === true) {
+                openContextSubmenu(id, state, handle, anchor);
+                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(),
+    });
 }
 const RECENCY_CAP = 20;
 let recency = [];
@@ -150,7 +244,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 +255,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

@@ -1,5 +1,5 @@
 import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { attachGlobalListeners, detachGlobalListeners, openPalette } from './listeners';
+import { attachGlobalListeners, detachGlobalListeners, openPalette, openContextMenu } from './listeners';
 import { registerAction, __resetActionsRegistryForTest } from './registry';
 import { __resetContributionsForTest } from '../contributions/registry';
 import { __resetDispatcherStateForTest, setActiveApp, setMountedViewIds, setFocusedViewId, } from './state.svelte';
@@ -82,14 +82,14 @@ describe('global contextmenu listener', () => {
         popupLayerRoot.remove();
         vi.unstubAllGlobals();
     });
-    it('opens popup on contextmenu and preventDefault()s native', () => {
+    it('opens popup with home anchor when no view ancestor and no active app', () => {
         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(def).toBe(false);
         expect(document.querySelector('.sh3-context-menu')).not.toBeNull();
         target.remove();
     });
@@ -101,18 +101,81 @@ describe('global contextmenu listener', () => {
         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(def).toBe(true);
         expect(document.querySelector('.sh3-context-menu')).toBeNull();
         target.remove();
     });
-    it('does not open when no contextItem actions are active', () => {
+    it('does not open when no contextItem actions match the anchor', () => {
         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
+        expect(def).toBe(true);
+        target.remove();
+    });
+    it('right-click inside data-sh3-view anchors to focus:<viewId>', async () => {
+        setActiveApp('app.a', new Set(['shard.x']));
+        setMountedViewIds(new Set(['editor']));
+        registerAction({ id: 'view-only', label: 'View', scope: 'focus:editor', contextItem: true, run: () => { } }, 'shard.x');
+        registerAction({ id: 'home-only', label: 'Home', scope: 'home', contextItem: true, run: () => { } }, 'shard.x');
+        const wrap = document.createElement('div');
+        wrap.setAttribute('data-sh3-view', 'editor');
+        document.body.appendChild(wrap);
+        const inner = document.createElement('button');
+        wrap.appendChild(inner);
+        const ev = new MouseEvent('contextmenu', { clientX: 10, clientY: 20, bubbles: true, cancelable: true });
+        Object.defineProperty(ev, 'target', { value: inner });
+        inner.dispatchEvent(ev);
+        await Promise.resolve();
+        const labels = [...document.querySelectorAll('.sh3-context-menu [role="menuitem"] .sh3-ctx-label')]
+            .map((n) => n.textContent);
+        expect(labels).toEqual(['View']);
+        wrap.remove();
+    });
+    it('right-click outside any view falls back to app anchor when an app is active', async () => {
+        setActiveApp('app.a', new Set(['shard.x']));
+        registerAction({ id: 'app.a', label: 'App', scope: 'app', contextItem: true, run: () => { } }, 'shard.x');
+        registerAction({ id: 'h.a', label: 'Home', scope: 'home', contextItem: true, run: () => { } }, 'shard.x');
+        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();
+        const labels = [...document.querySelectorAll('.sh3-context-menu [role="menuitem"] .sh3-ctx-label')]
+            .map((n) => n.textContent);
+        expect(labels).toEqual(['App']);
+        target.remove();
+    });
+    it('openContextMenu({scope}) uses the explicit anchor', async () => {
+        registerAction({ id: 'cell.copy', label: 'Copy Cell', scope: { element: 'cell' }, contextItem: true, run: () => { } }, 'shard.x');
+        registerAction({ id: 'home.x', label: 'Home', scope: 'home', contextItem: true, run: () => { } }, 'shard.x');
+        openContextMenu({ x: 10, y: 20, scope: { element: 'cell' } });
+        await Promise.resolve();
+        const labels = [...document.querySelectorAll('.sh3-context-menu [role="menuitem"] .sh3-ctx-label')]
+            .map((n) => n.textContent);
+        expect(labels).toEqual(['Copy Cell']);
+    });
+    it('clicking a submenu-parent row opens children filtered by the same anchor', 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();
+        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();
     });
 });
@@ -146,4 +209,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

@@ -7,6 +7,12 @@ export interface MenuBarItem {
     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:
@@ -26,3 +32,11 @@ export declare function resolveMenuContainers(activeAppId: string | null, declar
  * 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

@@ -7,6 +7,11 @@
 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 []
@@ -49,6 +54,41 @@ export function resolveMenuItems(entries, state, containerId) {
     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);
@@ -61,6 +101,9 @@ export function resolveMenuItems(entries, state, containerId) {
             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.js

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { resolveMenuContainers, resolveMenuItems, } from './menuBarModel';
+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),
@@ -82,3 +82,77 @@ describe('resolveMenuItems', () => {
         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;