sh3-core 0.10.5 → 0.11.2

package/dist/Shell.svelte

@@ -19,9 +19,10 @@
   import FloatLayer from './overlays/FloatLayer.svelte';
   import type { OverlayLayer } from './overlays/types';
   import { registerLayerRoot, unregisterLayerRoot } from './overlays/roots';
-  import { bindFloatStore, unbindFloatStore, floatManager } from './overlays/float';
-  import { returnToHome, isAdmin, focusView } from './api';
+  import { bindFloatStore, unbindFloatStore } from './overlays/float';
+  import { returnToHome, isAdmin } from './api';
   import { getActiveRoot, layoutStore } from './layout/store.svelte';
+  import { syncMountedViewIdsFromLayout } from './actions/state.svelte';
   import { isAuthenticated, isLocalOwner, getUser, logout } from './auth/index';
   import iconsUrl from './assets/icons.svg';
   import GuestBanner from './auth/GuestBanner.svelte';
@@ -62,35 +63,6 @@
     };
   });
 
-  // The AZERTY `²` key (top-left, below Escape) opens the terminal view
-  // in a floating panel (DF3 float runtime). Admin-only because the shell
-  // shard is admin-gated. Provisional ergonomics shortcut; a real hotkey
-  // contribution API is DF1 in the roadmap.
-  //
-  // Bare key (no modifier) so it must be suppressed while the user is
-  // typing into an input/textarea/contenteditable, or the shortcut would
-  // eat `²` characters mid-word.
-  $effect(() => {
-    function onKeyDown(e: KeyboardEvent) {
-      if (e.key !== '²') return;
-      if (!elevated) return;
-      const target = e.target as HTMLElement | null;
-      if (target) {
-        const tag = target.tagName;
-        if (
-          tag === 'INPUT' ||
-          tag === 'TEXTAREA' ||
-          target.isContentEditable
-        ) return;
-      }
-      e.preventDefault();
-      if (!focusView('shell:terminal'))
-        floatManager.open('shell:terminal', { title: 'Shell' });
-    }
-    window.addEventListener('keydown', onKeyDown);
-    return () => window.removeEventListener('keydown', onKeyDown);
-  });
-
   $effect(() => {
     const tree = layoutStore.tree;
     bindFloatStore(tree.floats, () => ({
@@ -100,6 +72,15 @@
     return () => unbindFloatStore();
   });
 
+  // Keep the actions dispatcher's `mountedViewIds` set in sync with the
+  // live layout tree, so `view:<viewId>` scope checks (context menu,
+  // palette, keyboard) see currently-mounted views. Deep Svelte 5
+  // reactivity means this re-runs on any tree mutation.
+  $effect(() => {
+    void layoutStore.tree;
+    syncMountedViewIdsFromLayout();
+  });
+
   // Open the server-sent events stream for key revocations.
   // Forwards server-side revocations to the local revocation bus so that
   // onKeyRevoked fires on the owning shard even when the user revokes from

package/dist/__test__/reset.js

@@ -2,6 +2,7 @@
 // Central reset orchestrator. Every new test file calls this in
 // beforeEach. Order matters — see the in-line comments.
 import { __resetFloatManagerForTest } from '../overlays/float';
+import { __resetDismissRegistryForTest } from '../overlays/floatDismiss';
 import { __resetPresetManagerForTest } from '../overlays/presets';
 import { __resetDragStateForTest } from '../layout/drag.svelte';
 import { __resetLayoutStoreForTest } from '../layout/store.svelte';
@@ -9,6 +10,8 @@ import { resetSlotHostPool } from '../layout/slotHostPool.svelte';
 import { __resetViewRegistryForTest } from '../shards/registry';
 import { __resetShardRegistryForTest } from '../shards/activate.svelte';
 import { __resetAppRegistryForTest } from '../apps/registry.svelte';
+import { __resetDispatcherStateForTest } from '../actions/state.svelte';
+import { __resetSelectionForTest } from '../actions/selection.svelte';
 /**
  * Return the framework to a deterministic boot state for tests.
  *
@@ -24,6 +27,7 @@ import { __resetAppRegistryForTest } from '../apps/registry.svelte';
  */
 export function resetFramework() {
     __resetFloatManagerForTest();
+    __resetDismissRegistryForTest();
     __resetPresetManagerForTest();
     __resetDragStateForTest();
     __resetLayoutStoreForTest();
@@ -31,4 +35,6 @@ export function resetFramework() {
     __resetViewRegistryForTest();
     __resetShardRegistryForTest();
     __resetAppRegistryForTest();
+    __resetDispatcherStateForTest();
+    __resetSelectionForTest();
 }

package/dist/actions/CommandPalette.svelte

@@ -0,0 +1,68 @@
+<script lang="ts">
+  import { rankPaletteEntries, type PaletteCandidate } from './palette-scorer';
+
+  let { candidates, recency, prefill = '', onInvoke, onClose }: {
+    candidates: PaletteCandidate[];
+    recency: string[];
+    prefill?: string;
+    onInvoke: (id: string) => void;
+    onClose: () => void;
+  } = $props();
+
+  let query = $state((() => prefill)());
+  let cursor = $state(0);
+  const ranked = $derived(rankPaletteEntries(candidates, query, recency));
+
+  $effect(() => { if (cursor >= ranked.length) cursor = 0; });
+
+  function onKeydown(ev: KeyboardEvent) {
+    if (ev.key === 'ArrowDown') {
+      cursor = Math.min(cursor + 1, Math.max(0, ranked.length - 1));
+      ev.preventDefault();
+    } else if (ev.key === 'ArrowUp') {
+      cursor = Math.max(cursor - 1, 0);
+      ev.preventDefault();
+    } else if (ev.key === 'Enter') {
+      if (ranked[cursor]) {
+        onInvoke(ranked[cursor].id);
+        onClose();
+      }
+      ev.preventDefault();
+    } else if (ev.key === 'Escape') {
+      onClose();
+      ev.preventDefault();
+    }
+  }
+</script>
+
+<!-- svelte-ignore a11y_autofocus -->
+<div class="sh3-palette" role="dialog" aria-label="Command palette" aria-modal="true" tabindex="-1" onkeydown={onKeydown}>
+  <input class="sh3-palette-input hell-base-input" bind:value={query} autofocus placeholder="Command…" />
+  <div class="sh3-palette-list" role="listbox">
+    {#each ranked as item, i (item.id)}
+      <button
+        class="sh3-palette-item"
+        class:sh3-palette-active={i === cursor}
+        role="option"
+        aria-selected={i === cursor}
+        onpointerenter={() => cursor = i}
+        onclick={() => { onInvoke(item.id); onClose(); }}
+      >
+        <span class="sh3-palette-label">{item.label}</span>
+        {#if item.scopeBadge}<span class="sh3-palette-badge">[{item.scopeBadge}]</span>{/if}
+        {#if item.shortcut}<span class="sh3-palette-shortcut">{item.shortcut}</span>{/if}
+      </button>
+    {/each}
+  </div>
+</div>
+
+<style>
+  .sh3-palette { min-width: 480px; max-width: 640px; background: var(--shell-bg-elevated, #22232a); color: var(--shell-fg, #e4e6eb); border-radius: var(--shell-radius-md, 6px); box-shadow: 0 8px 24px rgba(0,0,0,.4); }
+  .sh3-palette-input { width: 100%; padding: 10px; background: none; border: 0; border-bottom: 1px solid rgba(255,255,255,.1); color: inherit; font: inherit; outline: none; }
+  .sh3-palette-list { max-height: 320px; overflow-y: auto; padding: 4px 0; }
+  .sh3-palette-item { display: flex; align-items: center; gap: 12px; width: 100%; padding: 6px 12px; background: none; border: 0; color: inherit; text-align: left; font: inherit; cursor: default; }
+  .sh3-palette-active { background: var(--shell-accent, #4a5); border-radius: 0; color: #fff; }
+  .sh3-palette-label { flex: 1; }
+  .sh3-palette-badge { opacity: .5; font-size: .85em; }
+  .sh3-palette-shortcut { opacity: .6; font-size: .9em; }
+</style>

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

@@ -0,0 +1,11 @@
+import { type PaletteCandidate } from './palette-scorer';
+type $$ComponentProps = {
+    candidates: PaletteCandidate[];
+    recency: string[];
+    prefill?: string;
+    onInvoke: (id: string) => void;
+    onClose: () => void;
+};
+declare const CommandPalette: import("svelte").Component<$$ComponentProps, {}, "">;
+type CommandPalette = ReturnType<typeof CommandPalette>;
+export default CommandPalette;

package/dist/actions/ContextMenu.svelte

@@ -0,0 +1,97 @@
+<script lang="ts">
+  /*
+   * ContextMenu — popup-rendered, tier-grouped action list. Receives
+   * a pre-built model and an onInvoke callback. Dismiss and anchoring
+   * are handled by PopupFrame / popupManager — this component only
+   * renders the list and handles keyboard navigation within it.
+   */
+  import type { ContextMenuModel, MenuItem } from './contextMenuModel';
+
+  let { model, onInvoke, onClose }: {
+    model: ContextMenuModel;
+    onInvoke: (id: string) => void;
+    onClose: () => void;
+  } = $props();
+
+  const flatItems: MenuItem[] = $derived(model.tiers.flatMap((t) => t.items));
+  let cursor = $state(0);
+
+  function onKeydown(ev: KeyboardEvent) {
+    if (ev.key === 'ArrowDown') {
+      cursor = (cursor + 1) % flatItems.length;
+      ev.preventDefault();
+    } else if (ev.key === 'ArrowUp') {
+      cursor = (cursor - 1 + flatItems.length) % flatItems.length;
+      ev.preventDefault();
+    } else if (ev.key === 'Enter') {
+      if (flatItems[cursor]) {
+        onInvoke(flatItems[cursor].id);
+        onClose();
+      }
+      ev.preventDefault();
+    } else if (ev.key === 'Escape') {
+      onClose();
+      ev.preventDefault();
+    } else if (ev.key.length === 1) {
+      // type-ahead: jump to next item whose label starts with the pressed character
+      const q = ev.key.toLowerCase();
+      const start = (cursor + 1) % flatItems.length;
+      for (let i = 0; i < flatItems.length; i++) {
+        const idx = (start + i) % flatItems.length;
+        if (flatItems[idx].label.toLowerCase().startsWith(q)) {
+          cursor = idx;
+          break;
+        }
+      }
+    }
+  }
+</script>
+
+<!-- svelte-ignore a11y_autofocus -->
+<div class="sh3-context-menu" role="menu" tabindex="0" onkeydown={onKeydown} autofocus>
+  {#each model.tiers as tier, tIdx (tier.tier)}
+    {#if tIdx > 0}<div class="sh3-ctx-sep" role="separator"></div>{/if}
+    {#each tier.items as item (item.id)}
+      {@const globalIdx = flatItems.indexOf(item)}
+      <button
+        class="sh3-ctx-item"
+        class:sh3-ctx-active={globalIdx === cursor}
+        role="menuitem"
+        onpointerenter={() => { cursor = globalIdx; }}
+        onclick={() => { onInvoke(item.id); onClose(); }}
+      >
+        <span class="sh3-ctx-label">{item.label}</span>
+        {#if item.shortcut}<span class="sh3-ctx-shortcut">{item.shortcut}</span>{/if}
+      </button>
+    {/each}
+  {/each}
+</div>
+
+<style>
+  .sh3-context-menu {
+    min-width: 200px;
+    background: var(--shell-bg-elevated, #222);
+    color: var(--shell-fg, #eee);
+    border-radius: 4px;
+    padding: 4px 0;
+    box-shadow: 0 4px 16px rgba(0, 0, 0, 0.35);
+    outline: none;
+  }
+  .sh3-ctx-item {
+    display: flex;
+    align-items: center;
+    gap: 16px;
+    width: 100%;
+    padding: 4px 10px;
+    background: none;
+    border: 0;
+    text-align: left;
+    color: inherit;
+    cursor: default;
+    font: inherit;
+  }
+  .sh3-ctx-active { background: var(--shell-accent, #6ea8fe); color: var(--shell-fg,#e4e6eb); }
+  .sh3-ctx-label { flex: 1; }
+  .sh3-ctx-shortcut { opacity: 0.6; font-size: 0.9em; }
+  .sh3-ctx-sep { height: 1px; background: rgba(255, 255, 255, 0.1); margin: 4px 0; }
+</style>

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

@@ -0,0 +1,9 @@
+import type { ContextMenuModel } from './contextMenuModel';
+type $$ComponentProps = {
+    model: ContextMenuModel;
+    onInvoke: (id: string) => void;
+    onClose: () => void;
+};
+declare const ContextMenu: import("svelte").Component<$$ComponentProps, {}, "">;
+type ContextMenu = ReturnType<typeof ContextMenu>;
+export default ContextMenu;

package/dist/actions/bindings-store.d.ts

@@ -0,0 +1,8 @@
+type PerApp = Record<string, string | null>;
+type AllApps = Record<string, PerApp>;
+export declare function __setBindingsZone(z: {
+    bindings: AllApps;
+}): void;
+export declare function loadUserBindings(appId: string): Promise<PerApp>;
+export declare function saveUserBinding(appId: string, actionId: string, shortcut: string | null | undefined): Promise<void>;
+export {};

package/dist/actions/bindings-store.js

@@ -0,0 +1,27 @@
+/*
+ * User-binding persistence backed by the __sh3core__ user-zone slot
+ * `bindings: { [appId]: { [actionId]: shortcut | null } }`.
+ */
+let zone = null;
+export function __setBindingsZone(z) {
+    zone = z;
+}
+export async function loadUserBindings(appId) {
+    var _a;
+    if (!zone)
+        return {};
+    return Object.assign({}, ((_a = zone.bindings[appId]) !== null && _a !== void 0 ? _a : {}));
+}
+export async function saveUserBinding(appId, actionId, shortcut) {
+    var _a;
+    if (!zone)
+        return;
+    const forApp = Object.assign({}, ((_a = zone.bindings[appId]) !== null && _a !== void 0 ? _a : {}));
+    if (shortcut === undefined) {
+        delete forApp[actionId];
+    }
+    else {
+        forApp[actionId] = shortcut;
+    }
+    zone.bindings = Object.assign(Object.assign({}, zone.bindings), { [appId]: forApp });
+}

package/dist/actions/bindings-store.test.d.ts

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

package/dist/actions/bindings-store.test.js

@@ -0,0 +1,25 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { __setBindingsZone, loadUserBindings, saveUserBinding } from './bindings-store';
+describe('bindings-store', () => {
+    let zone;
+    beforeEach(() => {
+        zone = { bindings: {} };
+        __setBindingsZone(zone);
+    });
+    it('load returns empty for unknown app', async () => {
+        expect(await loadUserBindings('app.x')).toEqual({});
+    });
+    it('save then load round-trips', async () => {
+        await saveUserBinding('app.x', 'act.save', 'Ctrl+Alt+S');
+        expect(await loadUserBindings('app.x')).toEqual({ 'act.save': 'Ctrl+Alt+S' });
+    });
+    it('null disables', async () => {
+        await saveUserBinding('app.x', 'act.save', null);
+        expect(await loadUserBindings('app.x')).toEqual({ 'act.save': null });
+    });
+    it('removing (undefined) deletes the key', async () => {
+        await saveUserBinding('app.x', 'act.save', 'Ctrl+S');
+        await saveUserBinding('app.x', 'act.save', undefined);
+        expect(await loadUserBindings('app.x')).toEqual({});
+    });
+});

package/dist/actions/bindings.d.ts

@@ -0,0 +1,4 @@
+import { type Platform } from './shortcuts';
+import type { Action } from './types';
+export type BindingOverrides = Record<string, string | null>;
+export declare function effectiveShortcut(action: Action, overrides: BindingOverrides, platform?: Platform): string | null;

package/dist/actions/bindings.js

@@ -0,0 +1,17 @@
+/*
+ * Effective-shortcut merge. User overrides live in the user state zone
+ * under `bindings.<appId>`; this module is pure — load/persist is done
+ * by the dispatcher layer.
+ */
+import { canonicalizeShortcut, resolveMod } from './shortcuts';
+export function effectiveShortcut(action, overrides, platform = 'other') {
+    if (action.id in overrides) {
+        const o = overrides[action.id];
+        if (o === null)
+            return null;
+        return canonicalizeShortcut(o);
+    }
+    if (!action.defaultShortcut)
+        return null;
+    return resolveMod(action.defaultShortcut, platform);
+}

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

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

package/dist/actions/bindings.test.js

@@ -0,0 +1,30 @@
+import { describe, it, expect } from 'vitest';
+import { effectiveShortcut } from './bindings';
+const mkAction = (overrides = {}) => (Object.assign({ id: 'shard.save', label: 'Save', scope: 'home', run: () => { } }, overrides));
+describe('effectiveShortcut', () => {
+    it('returns defaultShortcut when no override', () => {
+        const a = mkAction({ defaultShortcut: 'Ctrl+S' });
+        expect(effectiveShortcut(a, {})).toBe('Ctrl+S');
+    });
+    it('returns override when present', () => {
+        const a = mkAction({ defaultShortcut: 'Ctrl+S' });
+        const overrides = { 'shard.save': 'Ctrl+Shift+S' };
+        expect(effectiveShortcut(a, overrides)).toBe('Ctrl+Shift+S');
+    });
+    it('returns null when override is null (disabled)', () => {
+        const a = mkAction({ defaultShortcut: 'Ctrl+S' });
+        const overrides = { 'shard.save': null };
+        expect(effectiveShortcut(a, overrides)).toBeNull();
+    });
+    it('returns null when no default and no override', () => {
+        const a = mkAction();
+        expect(effectiveShortcut(a, {})).toBeNull();
+    });
+    it('applies Mod resolution to defaults but stores overrides literally', () => {
+        const a = mkAction({ defaultShortcut: 'Mod+K' });
+        expect(effectiveShortcut(a, {}, 'mac')).toBe('Meta+K');
+        expect(effectiveShortcut(a, {}, 'other')).toBe('Ctrl+K');
+        // Override stored literally — no Mod in user-typed binds.
+        expect(effectiveShortcut(a, { 'shard.save': 'Ctrl+K' }, 'mac')).toBe('Ctrl+K');
+    });
+});

package/dist/actions/contextMenuModel.d.ts

@@ -0,0 +1,16 @@
+import type { ActionEntry } from './registry';
+import { type DispatcherState, type TierName } from './dispatcher.svelte';
+export interface MenuItem {
+    id: string;
+    label: string;
+    shortcut: string | null;
+    group: string;
+}
+export interface MenuTier {
+    tier: TierName;
+    items: MenuItem[];
+}
+export interface ContextMenuModel {
+    tiers: MenuTier[];
+}
+export declare function buildContextMenuModel(entries: ActionEntry[], state: DispatcherState): ContextMenuModel;

package/dist/actions/contextMenuModel.js

@@ -0,0 +1,71 @@
+/*
+ * Pure model layer for the context menu: takes the action registry +
+ * 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 { 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;
+}
+export function buildContextMenuModel(entries, state) {
+    var _a;
+    const byTier = {
+        element: [], focus: [], view: [], app: [], home: [],
+    };
+    const seen = new Set();
+    for (const entry of entries) {
+        if (!entry.action.contextItem)
+            continue;
+        if (seen.has(entry.action.id))
+            continue;
+        const tier = innermostActiveTier(entry.action.scope, state, entry.ownerShardId);
+        if (!tier)
+            continue;
+        seen.add(entry.action.id);
+        byTier[tier].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 : '',
+        });
+    }
+    return {
+        tiers: TIER_ORDER
+            .map((tier) => ({ tier, items: byTier[tier] }))
+            .filter((t) => t.items.length > 0),
+    };
+}

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

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

package/dist/actions/contextMenuModel.test.js

@@ -0,0 +1,44 @@
+import { describe, it, expect } from 'vitest';
+import { buildContextMenuModel } from './contextMenuModel';
+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('buildContextMenuModel', () => {
+    it('returns only actions with contextItem: true', () => {
+        const entries = [
+            mkEntry({ id: 'a', scope: 'home', contextItem: true, label: 'A' }),
+            mkEntry({ id: 'b', scope: 'home', label: 'B' }), // no contextItem
+        ];
+        const model = buildContextMenuModel(entries, mkState());
+        expect(model.tiers.flatMap((t) => t.items).map((i) => i.id)).toEqual(['a']);
+    });
+    it('groups by scope tier in innermost-first order with separators', () => {
+        const state = mkState({
+            activeAppId: 'app.a',
+            activeAppRequiredShards: new Set(['shard.x']),
+            selection: { type: 'orb', ref: 1, ownerShardId: 'shard.x' },
+        });
+        const entries = [
+            mkEntry({ id: 'el', scope: { element: 'orb' }, contextItem: true, label: 'Dup' }),
+            mkEntry({ id: 'ap', scope: 'app', contextItem: true, label: 'Undo' }),
+        ];
+        const model = buildContextMenuModel(entries, state);
+        expect(model.tiers.map((t) => t.tier)).toEqual(['element', 'app']);
+        expect(model.tiers[0].items[0].id).toBe('el');
+    });
+    it('de-duplicates multi-scope action to innermost tier', () => {
+        const state = mkState({
+            activeAppId: 'app.a',
+            activeAppRequiredShards: new Set(['shard.x']),
+            autostartShards: new Set(['shard.x']),
+        });
+        const entries = [
+            mkEntry({ id: 'p', scope: ['home', 'app'], contextItem: true, label: 'P' }),
+        ];
+        const model = buildContextMenuModel(entries, state);
+        expect(model.tiers).toHaveLength(1);
+        expect(model.tiers[0].tier).toBe('app');
+    });
+});

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

@@ -0,0 +1,34 @@
+import type { AtomicScope, Selection } from './types';
+import type { ActionEntry } from './registry';
+import type { Platform } from './shortcuts';
+export interface DispatcherState {
+    activeAppId: string | null;
+    activeAppRequiredShards: Set<string>;
+    autostartShards: Set<string>;
+    mountedViewIds: Set<string>;
+    focusedViewId: string | null;
+    selection: Selection | null;
+    bindings: Record<string, string | null>;
+    platform: Platform;
+}
+export type TierName = 'element' | 'focus' | 'view' | 'app' | 'home';
+export declare const TIER_ORDER: readonly TierName[];
+export interface TierIndex {
+    element: Map<string, string>;
+    focus: Map<string, string>;
+    view: Map<string, string>;
+    app: Map<string, string>;
+    home: Map<string, string>;
+}
+export declare function isScopeActive(scope: AtomicScope, state: DispatcherState, ownerShardId?: string): boolean;
+export declare function buildTierIndex(entries: ActionEntry[], state: DispatcherState): TierIndex;
+export interface KeydownEnv {
+    target: EventTarget | null;
+    shortcut: string;
+    state: DispatcherState;
+    entries: ActionEntry[];
+    runAction(actionId: string, dispatchCtx: import('./types').ActionDispatchContext): void;
+    /** Optional chained-dispatch function passed through to the action's `run` ctx. Noop by default. */
+    dispatch?: (actionId: string) => void;
+}
+export declare function dispatchKeydown(env: KeydownEnv): string | null;