sh3-core 0.11.2 → 0.11.6

package/dist/actions/MenuBar.test.js

@@ -0,0 +1,109 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { mount, unmount, tick } from 'svelte';
+import MenuBar from './MenuBar.svelte';
+import { registerLayerRoot, unregisterLayerRoot } from '../overlays/roots';
+import { __resetPopupManagerForTest } from '../overlays/popup';
+import { setActiveApp, __resetDispatcherStateForTest, } from './state.svelte';
+import { registerAction, __resetActionsRegistryForTest, } from './registry';
+import { __resetContributionsForTest } from '../contributions/registry';
+import { registerApp, __resetAppRegistryForTest, } from '../apps/registry.svelte';
+let layerRoot;
+let host;
+let cmp = null;
+function makeApp(id, menus) {
+    return {
+        manifest: {
+            id, label: id, version: '0.0.0',
+            requiredShards: ['shard.x'], layoutVersion: 1,
+            menus,
+        },
+        initialLayout: { type: 'leaf', viewId: 'shard.x:v' },
+    };
+}
+beforeEach(() => {
+    vi.stubGlobal('innerWidth', 2000);
+    vi.stubGlobal('innerHeight', 2000);
+    layerRoot = document.createElement('div');
+    layerRoot.style.position = 'relative';
+    document.body.appendChild(layerRoot);
+    registerLayerRoot('popup', layerRoot);
+    host = document.createElement('div');
+    document.body.appendChild(host);
+});
+afterEach(() => {
+    if (cmp) {
+        unmount(cmp);
+        cmp = null;
+    }
+    host.remove();
+    __resetPopupManagerForTest();
+    unregisterLayerRoot('popup');
+    layerRoot.remove();
+    __resetActionsRegistryForTest();
+    __resetContributionsForTest();
+    __resetAppRegistryForTest();
+    __resetDispatcherStateForTest();
+    vi.unstubAllGlobals();
+});
+describe('MenuBar', () => {
+    it('renders an empty menubar when no app is active', async () => {
+        cmp = mount(MenuBar, { target: host, props: {} });
+        await tick();
+        // The wrapper always renders (it occupies a grid cell in the shell
+        // tabbar so user chrome stays anchored right). When no app is active
+        // it's just empty.
+        const bar = host.querySelector('.sh3-menubar');
+        expect(bar).not.toBeNull();
+        expect(bar.querySelectorAll('.sh3-menubar-button')).toHaveLength(0);
+    });
+    it('renders one button per declared container when an app is active', async () => {
+        registerApp(makeApp('app.a', [
+            { id: 'file', label: 'File' },
+            { id: 'help', label: 'Help' },
+        ]));
+        registerAction({
+            id: 'open', label: 'Open', scope: 'app',
+            menuItem: 'file', run: () => { },
+        }, 'shard.x');
+        registerAction({
+            id: 'docs', label: 'Docs', scope: 'app',
+            menuItem: 'help', run: () => { },
+        }, 'shard.x');
+        setActiveApp('app.a', new Set(['shard.x']));
+        cmp = mount(MenuBar, { target: host, props: {} });
+        await tick();
+        const buttons = host.querySelectorAll('.sh3-menubar-button');
+        expect(buttons).toHaveLength(2);
+        expect(buttons[0].textContent).toContain('File');
+        expect(buttons[1].textContent).toContain('Help');
+    });
+    it('falls back to DEFAULT_MENU_CONTAINERS when manifest.menus is absent', async () => {
+        registerApp(makeApp('app.b'));
+        registerAction({
+            id: 'q', label: 'Quit', scope: 'app',
+            menuItem: 'file', run: () => { },
+        }, 'shard.x');
+        setActiveApp('app.b', new Set(['shard.x']));
+        cmp = mount(MenuBar, { target: host, props: {} });
+        await tick();
+        const buttons = host.querySelectorAll('.sh3-menubar-button');
+        expect(buttons).toHaveLength(1);
+        expect(buttons[0].textContent).toContain('File');
+    });
+    it('hides containers whose item list is empty', async () => {
+        registerApp(makeApp('app.c', [
+            { id: 'file', label: 'File' },
+            { id: 'edit', label: 'Edit' },
+        ]));
+        registerAction({
+            id: 'open', label: 'Open', scope: 'app',
+            menuItem: 'file', run: () => { },
+        }, 'shard.x');
+        setActiveApp('app.c', new Set(['shard.x']));
+        cmp = mount(MenuBar, { target: host, props: {} });
+        await tick();
+        const buttons = host.querySelectorAll('.sh3-menubar-button');
+        expect(buttons).toHaveLength(1);
+        expect(buttons[0].textContent).toContain('File');
+    });
+});

package/dist/actions/MenuButton.svelte

@@ -0,0 +1,104 @@
+<script lang="ts">
+  /*
+   * MenuButton — one menu bar container. A button that opens a popup
+   * containing an ActionPanel rendered with this container's items.
+   * Items are passed in (the parent MenuBar resolves them via
+   * menuBarModel.resolveMenuItems).
+   */
+  import { popupManager } from '../overlays/popup';
+  import ActionPanel, { type ActionPanelSection } from './ActionPanel.svelte';
+  import { listActions } from './registry';
+  import { getLiveDispatcherState } from './state.svelte';
+  import type { MenuBarItem } from './menuBarModel';
+  import type { MenuContainer } from '../apps/types';
+
+  let { container, items }: {
+    container: MenuContainer;
+    items: MenuBarItem[];
+  } = $props();
+
+  let buttonEl: HTMLButtonElement | undefined = $state();
+
+  function makeSections(list: MenuBarItem[]): ActionPanelSection[] {
+    const buckets = new Map<string, MenuBarItem[]>();
+    const order: string[] = [];
+    for (const item of list) {
+      const key = item.group || '';
+      if (!buckets.has(key)) {
+        buckets.set(key, []);
+        order.push(key);
+      }
+      buckets.get(key)!.push(item);
+    }
+    return order.map((k) => ({ id: `group:${k || '_default'}`, items: buckets.get(k)! }));
+  }
+
+  function openPopup() {
+    if (!buttonEl) return;
+    const state = getLiveDispatcherState();
+    popupManager.show(
+      ActionPanel,
+      { anchor: buttonEl, placement: 'bottom-start' },
+      {
+        sections: makeSections(items),
+        onInvoke: (id: string) => {
+          const entry = listActions().find((e) => e.action.id === id);
+          if (!entry) return;
+          try {
+            void entry.action.run({
+              action: { id, label: entry.action.label },
+              appId: state.activeAppId,
+              viewId: state.focusedViewId ?? undefined,
+              selection: state.selection ?? undefined,
+              invokedVia: 'palette',
+              dispatch: () => {},
+            });
+          } catch (err) {
+            console.error(`[sh3] menu-bar action "${id}" threw:`, err);
+          }
+        },
+        onDismiss: () => popupManager.close(),
+      },
+    );
+  }
+
+  const iconPosition = $derived(container.iconPosition ?? 'before');
+</script>
+
+<button
+  type="button"
+  class="sh3-menubar-button"
+  bind:this={buttonEl}
+  onclick={openPopup}
+>
+  {#if container.icon && iconPosition === 'before'}
+    <span class="sh3-menubar-icon" data-icon={container.icon}></span>
+  {/if}
+  <span class="sh3-menubar-label">{container.label}</span>
+  {#if container.icon && iconPosition === 'after'}
+    <span class="sh3-menubar-icon" data-icon={container.icon}></span>
+  {/if}
+</button>
+
+<style>
+  .sh3-menubar-button {
+    display: inline-flex;
+    align-items: center;
+    gap: 6px;
+    padding: 0 var(--shell-pad-md);
+    height: 100%;
+    background: transparent;
+    color: var(--shell-fg);
+    border: 0;
+    font: inherit;
+    cursor: default;
+  }
+  .sh3-menubar-button:hover {
+    background: var(--shell-bg-elevated);
+  }
+  .sh3-menubar-icon {
+    width: 14px;
+    height: 14px;
+    display: inline-block;
+  }
+</style>

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

@@ -0,0 +1,9 @@
+import type { MenuBarItem } from './menuBarModel';
+import type { MenuContainer } from '../apps/types';
+type $$ComponentProps = {
+    container: MenuContainer;
+    items: MenuBarItem[];
+};
+declare const MenuButton: import("svelte").Component<$$ComponentProps, {}, "">;
+type MenuButton = ReturnType<typeof MenuButton>;
+export default MenuButton;

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

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

package/dist/actions/MenuButton.test.js

@@ -0,0 +1,88 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { mount, unmount, tick } from 'svelte';
+import MenuButton from './MenuButton.svelte';
+import { registerLayerRoot, unregisterLayerRoot } from '../overlays/roots';
+import { __resetPopupManagerForTest } from '../overlays/popup';
+let layerRoot;
+let host;
+let cmp = null;
+beforeEach(() => {
+    vi.stubGlobal('innerWidth', 2000);
+    vi.stubGlobal('innerHeight', 2000);
+    layerRoot = document.createElement('div');
+    layerRoot.style.position = 'relative';
+    document.body.appendChild(layerRoot);
+    registerLayerRoot('popup', layerRoot);
+    host = document.createElement('div');
+    document.body.appendChild(host);
+});
+afterEach(() => {
+    if (cmp) {
+        unmount(cmp);
+        cmp = null;
+    }
+    host.remove();
+    __resetPopupManagerForTest();
+    unregisterLayerRoot('popup');
+    layerRoot.remove();
+    vi.unstubAllGlobals();
+});
+describe('MenuButton', () => {
+    it('renders the container label', () => {
+        cmp = mount(MenuButton, {
+            target: host,
+            props: {
+                container: { id: 'file', label: 'File' },
+                items: [],
+            },
+        });
+        expect(host.textContent).toContain('File');
+    });
+    it('renders icon before label when iconPosition is "before" (default)', () => {
+        cmp = mount(MenuButton, {
+            target: host,
+            props: {
+                container: { id: 'file', label: 'File', icon: 'folder' },
+                items: [],
+            },
+        });
+        const btn = host.querySelector('button');
+        const children = Array.from(btn.children);
+        const iconIdx = children.findIndex((c) => c.classList.contains('sh3-menubar-icon'));
+        const labelIdx = children.findIndex((c) => c.classList.contains('sh3-menubar-label'));
+        expect(iconIdx).toBeGreaterThanOrEqual(0);
+        expect(iconIdx).toBeLessThan(labelIdx);
+    });
+    it('renders icon after label when iconPosition is "after"', () => {
+        cmp = mount(MenuButton, {
+            target: host,
+            props: {
+                container: { id: 'file', label: 'File', icon: 'folder', iconPosition: 'after' },
+                items: [],
+            },
+        });
+        const btn = host.querySelector('button');
+        const children = Array.from(btn.children);
+        const iconIdx = children.findIndex((c) => c.classList.contains('sh3-menubar-icon'));
+        const labelIdx = children.findIndex((c) => c.classList.contains('sh3-menubar-label'));
+        expect(labelIdx).toBeLessThan(iconIdx);
+    });
+    it('clicking the button opens a popup with ActionPanel mounted', async () => {
+        cmp = mount(MenuButton, {
+            target: host,
+            props: {
+                container: { id: 'file', label: 'File' },
+                items: [
+                    { id: 'open', label: 'Open', shortcut: 'Ctrl+O', group: '', icon: undefined },
+                ],
+            },
+        });
+        await tick();
+        const btn = host.querySelector('button');
+        btn.click();
+        await tick();
+        const items = layerRoot.querySelectorAll('[role="menuitem"]');
+        expect(items.length).toBe(1);
+        expect(items[0].textContent).toContain('Open');
+    });
+});

package/dist/actions/bindings.d.ts

@@ -1,4 +1,13 @@
 import { type Platform } from './shortcuts';
-import type { Action } from './types';
+import type { Action, BindingSource } from './types';
 export type BindingOverrides = Record<string, string | null>;
 export declare function effectiveShortcut(action: Action, overrides: BindingOverrides, platform?: Platform): string | null;
+/**
+ * Like {@link effectiveShortcut}, but also reports the binding source so
+ * consumers (e.g., Help views) can distinguish "no shortcut assigned"
+ * from "user turned this off" — both of which yield a `null` shortcut.
+ */
+export declare function effectiveShortcutWithSource(action: Action, overrides: BindingOverrides, platform?: Platform): {
+    shortcut: string | null;
+    source: BindingSource;
+};

package/dist/actions/bindings.js

@@ -15,3 +15,19 @@ export function effectiveShortcut(action, overrides, platform = 'other') {
         return null;
     return resolveMod(action.defaultShortcut, platform);
 }
+/**
+ * Like {@link effectiveShortcut}, but also reports the binding source so
+ * consumers (e.g., Help views) can distinguish "no shortcut assigned"
+ * from "user turned this off" — both of which yield a `null` shortcut.
+ */
+export function effectiveShortcutWithSource(action, overrides, platform = 'other') {
+    if (action.id in overrides) {
+        const o = overrides[action.id];
+        if (o === null)
+            return { shortcut: null, source: 'disabled' };
+        return { shortcut: canonicalizeShortcut(o), source: 'user' };
+    }
+    if (!action.defaultShortcut)
+        return { shortcut: null, source: 'none' };
+    return { shortcut: resolveMod(action.defaultShortcut, platform), source: 'default' };
+}

package/dist/actions/bindings.test.js

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { effectiveShortcut } from './bindings';
+import { effectiveShortcut, effectiveShortcutWithSource } from './bindings';
 const mkAction = (overrides = {}) => (Object.assign({ id: 'shard.save', label: 'Save', scope: 'home', run: () => { } }, overrides));
 describe('effectiveShortcut', () => {
     it('returns defaultShortcut when no override', () => {
@@ -28,3 +28,25 @@ describe('effectiveShortcut', () => {
         expect(effectiveShortcut(a, { 'shard.save': 'Ctrl+K' }, 'mac')).toBe('Ctrl+K');
     });
 });
+describe('effectiveShortcutWithSource', () => {
+    it('returns default + "default" when no override and defaultShortcut present', () => {
+        const a = mkAction({ defaultShortcut: 'Mod+S' });
+        expect(effectiveShortcutWithSource(a, {}, 'other'))
+            .toEqual({ shortcut: 'Ctrl+S', source: 'default' });
+    });
+    it('returns canonicalized override + "user" when user rebound to a key', () => {
+        const a = mkAction({ defaultShortcut: 'Mod+S' });
+        expect(effectiveShortcutWithSource(a, { 'shard.save': 'Ctrl+K' }, 'other'))
+            .toEqual({ shortcut: 'Ctrl+K', source: 'user' });
+    });
+    it('returns null + "disabled" when user rebound to null', () => {
+        const a = mkAction({ defaultShortcut: 'Mod+S' });
+        expect(effectiveShortcutWithSource(a, { 'shard.save': null }, 'other'))
+            .toEqual({ shortcut: null, source: 'disabled' });
+    });
+    it('returns null + "none" when no default and no override', () => {
+        const a = mkAction();
+        expect(effectiveShortcutWithSource(a, {}, 'other'))
+            .toEqual({ shortcut: null, source: 'none' });
+    });
+});

package/dist/actions/contextMenuModel.js

@@ -3,44 +3,9 @@
  * dispatcher state, returns a tiered, deduplicated, shortcut-annotated
  * item list the Svelte component renders without further logic.
  */
-import { isScopeActive, TIER_ORDER, } from './dispatcher.svelte';
+import { TIER_ORDER } from './dispatcher.svelte';
 import { effectiveShortcut } from './bindings';
-function normalizeScope(scope) {
-    return Array.isArray(scope) ? scope : [scope];
-}
-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 innermostActiveTier(scope, state, owner) {
-    // Build a map of tier → active scopes for this action, then walk
-    // TIER_ORDER from innermost → outermost to find the first active tier.
-    const scopes = normalizeScope(scope);
-    const tierBuckets = {};
-    for (const s of scopes) {
-        const tier = scopeToTier(s);
-        if (!tierBuckets[tier])
-            tierBuckets[tier] = [];
-        tierBuckets[tier].push(s);
-    }
-    for (const tier of TIER_ORDER) {
-        const bucket = tierBuckets[tier];
-        if (!bucket)
-            continue;
-        for (const s of bucket) {
-            if (isScopeActive(s, state, owner))
-                return tier;
-        }
-    }
-    return null;
-}
+import { scopeToTier, innermostActiveScope } from './scope-helpers';
 export function buildContextMenuModel(entries, state) {
     var _a;
     const byTier = {
@@ -52,11 +17,11 @@ export function buildContextMenuModel(entries, state) {
             continue;
         if (seen.has(entry.action.id))
             continue;
-        const tier = innermostActiveTier(entry.action.scope, state, entry.ownerShardId);
-        if (!tier)
+        const winning = innermostActiveScope(entry.action.scope, state, entry.ownerShardId);
+        if (!winning)
             continue;
         seen.add(entry.action.id);
-        byTier[tier].push({
+        byTier[scopeToTier(winning)].push({
             id: entry.action.id,
             label: entry.action.label,
             shortcut: effectiveShortcut(entry.action, state.bindings, state.platform),

package/dist/actions/defaultMenuContainers.d.ts

@@ -0,0 +1,2 @@
+import type { MenuContainer } from '../apps/types';
+export declare const DEFAULT_MENU_CONTAINERS: readonly MenuContainer[];

package/dist/actions/defaultMenuContainers.js

@@ -0,0 +1,7 @@
+export const DEFAULT_MENU_CONTAINERS = Object.freeze([
+    { id: 'file', label: 'File' },
+    { id: 'edit', label: 'Edit' },
+    { id: 'view', label: 'View' },
+    { id: 'window', label: 'Window' },
+    { id: 'help', label: 'Help' },
+]);

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

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

package/dist/actions/defaultMenuContainers.test.js

@@ -0,0 +1,23 @@
+import { describe, it, expect } from 'vitest';
+import { DEFAULT_MENU_CONTAINERS } from './defaultMenuContainers';
+describe('DEFAULT_MENU_CONTAINERS', () => {
+    it('declares the canonical five containers in fixed order', () => {
+        expect(DEFAULT_MENU_CONTAINERS.map((c) => c.id))
+            .toEqual(['file', 'edit', 'view', 'window', 'help']);
+    });
+    it('declares matching labels', () => {
+        expect(DEFAULT_MENU_CONTAINERS.map((c) => c.label))
+            .toEqual(['File', 'Edit', 'View', 'Window', 'Help']);
+    });
+    it('declares no icons by default (text-only fallback)', () => {
+        for (const c of DEFAULT_MENU_CONTAINERS) {
+            expect(c.icon).toBeUndefined();
+        }
+    });
+    it('is frozen — mutating throws or is silently dropped', () => {
+        expect(() => {
+            // @ts-expect-error — testing runtime immutability of a readonly constant
+            DEFAULT_MENU_CONTAINERS.push({ id: 'x', label: 'X' });
+        }).toThrow();
+    });
+});

package/dist/actions/dispatcher.svelte.js

@@ -5,6 +5,7 @@
  * 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') {
@@ -31,20 +32,6 @@ export function isScopeActive(scope, state, ownerShardId) {
     }
     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(),

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']);
+    });
+});