sh3-core 0.15.2 → 0.15.4

package/dist/shell-shard/InputLine.svelte

@@ -10,8 +10,10 @@
     history: string[];                     // persisted history, newest last
     session: SessionClient;
     onSubmit: (line: string) => void;      // called with the raw entered line
+    /** Fired when the inner <input> receives focus. */
+    onFocus?: () => void;
   }
-  let { cwd, showCwd = true, locked, history, session, onSubmit }: Props = $props();
+  let { cwd, showCwd = true, locked, history, session, onSubmit, onFocus }: Props = $props();
 
   let draft = $state('');
   let historyIndex = $state<number | null>(null);  // null = live draft
@@ -94,6 +96,7 @@
     disabled={locked}
     name="shell-cmdline"
     onkeydown={onKeyDown}
+    onfocus={() => onFocus?.()}
   >
     {#snippet prefix()}
       {#if showCwd}<span class="shell-input-cwd">{cwd}</span>{/if}

package/dist/shell-shard/InputLine.svelte.d.ts

@@ -7,6 +7,8 @@ interface Props {
     history: string[];
     session: SessionClient;
     onSubmit: (line: string) => void;
+    /** Fired when the inner <input> receives focus. */
+    onFocus?: () => void;
 }
 declare const InputLine: import("svelte").Component<Props, {}, "">;
 type InputLine = ReturnType<typeof InputLine>;

package/dist/shell-shard/Terminal.svelte

@@ -26,6 +26,8 @@
   import FocusLockSlot from './toolbar/slots/FocusLockSlot.svelte';
   import TargetShardSlot from './toolbar/slots/TargetShardSlot.svelte';
   import BusySlot from './toolbar/slots/BusySlot.svelte';
+  import { registerTerminalView, mintTerminalId, type TerminalHandle } from './terminal-registry';
+  import { makeDispatchToTerminal } from './dispatch-to-terminal';
 
   interface Props {
     shell: ShellApi;
@@ -116,6 +118,16 @@
     }),
   );
 
+  // Focus stamp — bumped when the input receives focus so dispatchToTerminal
+  // can pick this terminal over other open terminals. Programmatic dispatches
+  // do NOT bump the stamp; otherwise they'd self-elect their target as
+  // 'focused' and mask multi-terminal ambiguity.
+  let focusStamp = $state(0);
+  function bumpFocusStamp(): void {
+    focusStamp = performance.now();
+  }
+  const terminalId = untrack(() => mintTerminalId());
+
   // Active-mode buffer derivation. Reads `mode.id` reactively so that
   // mode-switch flips ScrollbackView and InputLine bindings in lockstep.
   const currentBuffer = $derived(getBuffer(mode.id));
@@ -195,6 +207,7 @@
     },
     listModes: () => visibleModes.map((m) => ({ id: m.id, label: m.label })),
     getMode: () => ({ id: mode.id, label: mode.label }),
+    dispatchToTerminal: makeDispatchToTerminal({ headless: false }),
   }));
 
   // wsUrl is a prop read at construction only. untrack prevents Svelte 5's
@@ -364,6 +377,7 @@
   }
 
   let unsub: (() => void) | null = null;
+  let disposeRegistration: (() => void) | null = null;
 
   onMount(() => {
     unsub = session.onMessage(handleServerMessage);
@@ -379,11 +393,20 @@
     // negligible, and non-bash modes still need to log mode-tagged
     // history server-side via history-log messages.
     session.connect();
+
+    const handle: TerminalHandle = {
+      id: terminalId,
+      dispatch,
+      getFocusStamp: () => focusStamp,
+      getMode: () => mode,
+    };
+    disposeRegistration = registerTerminalView(handle);
   });
 
   onDestroy(() => {
     unsub?.();
     session.close();
+    disposeRegistration?.();
   });
 </script>
 
@@ -406,6 +429,7 @@
     history={currentBuffer.history}
     {session}
     onSubmit={dispatch}
+    onFocus={bumpFocusStamp}
   />
 </div>
 

package/dist/shell-shard/dispatch-to-terminal.d.ts

@@ -0,0 +1,13 @@
+export type DispatchToTerminalResult = {
+    ok: true;
+    terminalId: string;
+} | {
+    ok: false;
+    error: 'no-terminal' | 'ambiguous' | 'no-active-context';
+    message: string;
+};
+export interface MakeDispatchToTerminalOpts {
+    /** When true, always return 'no-active-context'. */
+    headless: boolean;
+}
+export declare function makeDispatchToTerminal(opts: MakeDispatchToTerminalOpts): (line: string) => DispatchToTerminalResult;

package/dist/shell-shard/dispatch-to-terminal.js

@@ -0,0 +1,37 @@
+/*
+ * makeDispatchToTerminal — factory returning the `shell.dispatchToTerminal`
+ * function. Two flavors:
+ *   - headless: always returns 'no-active-context'. Used by makeShellApiHeadless
+ *     so verbs run via runVerbProgrammatic (and node-only tests) get a clean
+ *     failure instead of hitting the live registry.
+ *   - live: consults the module-scoped terminal-registry and routes through the
+ *     resolved handle's dispatch. Used by Terminal.svelte's shellWithModes
+ *     wrapper.
+ *
+ * The dispatch itself is fire-and-forget — the function resolves synchronously
+ * with the routing outcome (ok or error). Matches InputLine submit semantics:
+ * the caller doesn't await the targeted terminal's dispatch.
+ */
+import { resolveTargetTerminal } from './terminal-registry';
+const ERROR_MESSAGES = {
+    'no-terminal': 'no terminal open',
+    'ambiguous': 'multiple terminals open; focus one first',
+    'no-active-context': 'dispatchToTerminal is not available in this context',
+};
+export function makeDispatchToTerminal(opts) {
+    if (opts.headless) {
+        return () => ({
+            ok: false,
+            error: 'no-active-context',
+            message: ERROR_MESSAGES['no-active-context'],
+        });
+    }
+    return (line) => {
+        const r = resolveTargetTerminal();
+        if (!r.ok) {
+            return { ok: false, error: r.error, message: ERROR_MESSAGES[r.error] };
+        }
+        void r.handle.dispatch(line);
+        return { ok: true, terminalId: r.handle.id };
+    };
+}

package/dist/shell-shard/dispatch-to-terminal.test.d.ts

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

package/dist/shell-shard/dispatch-to-terminal.test.js

@@ -0,0 +1,79 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { registerTerminalView, __resetTerminalRegistryForTest, } from './terminal-registry';
+import { makeDispatchToTerminal } from './dispatch-to-terminal';
+function makeHandle(id, focusStamp = 0, dispatch = vi.fn(async () => undefined)) {
+    return {
+        id,
+        dispatch,
+        getFocusStamp: () => focusStamp,
+        getMode: () => ({ id: 'sh3', label: 'sh3', transport: 'none', autoRelocate: false, showCwd: true }),
+    };
+}
+describe('makeDispatchToTerminal', () => {
+    beforeEach(() => {
+        __resetTerminalRegistryForTest();
+    });
+    describe('headless: true', () => {
+        const dispatchToTerminal = makeDispatchToTerminal({ headless: true });
+        it('returns no-active-context even when handles are registered', () => {
+            registerTerminalView(makeHandle('term-1'));
+            const r = dispatchToTerminal('foo');
+            expect(r).toMatchObject({
+                ok: false,
+                error: 'no-active-context',
+                message: expect.stringContaining('not available'),
+            });
+        });
+        it('returns no-active-context when registry is empty', () => {
+            const r = dispatchToTerminal('foo');
+            expect(r).toMatchObject({ ok: false, error: 'no-active-context' });
+        });
+    });
+    describe('headless: false (live)', () => {
+        const dispatchToTerminal = makeDispatchToTerminal({ headless: false });
+        it('returns no-terminal when registry is empty', () => {
+            const r = dispatchToTerminal('foo');
+            expect(r).toMatchObject({
+                ok: false,
+                error: 'no-terminal',
+                message: 'no terminal open',
+            });
+        });
+        it('returns ambiguous when multiple terminals all have stamp 0', () => {
+            registerTerminalView(makeHandle('term-a', 0));
+            registerTerminalView(makeHandle('term-b', 0));
+            const r = dispatchToTerminal('foo');
+            expect(r).toMatchObject({
+                ok: false,
+                error: 'ambiguous',
+                message: 'multiple terminals open; focus one first',
+            });
+        });
+        it('hands the line to the resolved handle and returns ok with terminalId', () => {
+            const dispatch = vi.fn(async () => undefined);
+            registerTerminalView(makeHandle('term-1', 0, dispatch));
+            const r = dispatchToTerminal('foo bar baz');
+            expect(r).toEqual({ ok: true, terminalId: 'term-1' });
+            expect(dispatch).toHaveBeenCalledWith('foo bar baz');
+        });
+        it('targets the highest-stamped handle when multiple are registered', () => {
+            const dispatchA = vi.fn(async () => undefined);
+            const dispatchB = vi.fn(async () => undefined);
+            registerTerminalView(makeHandle('term-a', 100, dispatchA));
+            registerTerminalView(makeHandle('term-b', 200, dispatchB));
+            const r = dispatchToTerminal('hi');
+            expect(r).toEqual({ ok: true, terminalId: 'term-b' });
+            expect(dispatchA).not.toHaveBeenCalled();
+            expect(dispatchB).toHaveBeenCalledWith('hi');
+        });
+        it('does not await the dispatch (returns synchronously even when dispatch is slow)', async () => {
+            let resolveDispatch;
+            const slow = vi.fn(() => new Promise((res) => { resolveDispatch = res; }));
+            registerTerminalView(makeHandle('term-1', 0, slow));
+            const r = dispatchToTerminal('hi');
+            expect(r).toEqual({ ok: true, terminalId: 'term-1' });
+            expect(slow).toHaveBeenCalledWith('hi');
+            resolveDispatch();
+        });
+    });
+});

package/dist/shell-shard/shellApi.js

@@ -15,6 +15,7 @@ import { registeredShards, listStandaloneViews } from '../shards/activate.svelte
 import { inspectActiveLayout, focusView, closeTab, popoutView, dockFloat, dockIntoActiveLayout, locateSlot as locateSlotInActiveLayout, } from '../layout/inspection';
 import { floatManager } from '../overlays/float';
 import { getUser, isAdmin } from '../auth/index';
+import { makeDispatchToTerminal } from './dispatch-to-terminal';
 const KNOWN_ZONES = ['ephemeral', 'session', 'workspace', 'user'];
 function collectTabEntries(node) {
     if (node.type === 'tabs') {
@@ -164,6 +165,7 @@ export function makeShellApiHeadless(zones) {
         setMode(_id) { return false; },
         listModes() { return []; },
         getMode() { return { id: 'sh3', label: 'sh3' }; },
+        dispatchToTerminal: makeDispatchToTerminal({ headless: true }),
     };
 }
 export function makeShellApiForTest() {

package/dist/shell-shard/terminal-registry.d.ts

@@ -0,0 +1,25 @@
+import type { ShellMode } from './modes/types';
+export interface TerminalHandle {
+    /** Stable per-mount id, e.g. `term-${counter}`. */
+    id: string;
+    /** Same dispatch fn `InputLine` calls on submit. */
+    dispatch: (line: string) => Promise<void>;
+    /** Monotonic stamp; 0 if the terminal has never been focused. */
+    getFocusStamp: () => number;
+    /** Currently active ShellMode for this terminal (informational). */
+    getMode: () => ShellMode;
+}
+export type ResolveTargetResult = {
+    ok: true;
+    handle: TerminalHandle;
+} | {
+    ok: false;
+    error: 'no-terminal' | 'ambiguous';
+};
+/** Mint a stable id for a Terminal.svelte instance. Called once per mount. */
+export declare function mintTerminalId(): string;
+export declare function registerTerminalView(handle: TerminalHandle): () => void;
+export declare function listTerminalViews(): TerminalHandle[];
+export declare function resolveTargetTerminal(): ResolveTargetResult;
+/** Test-only — wipes the registry and id counter between cases. */
+export declare function __resetTerminalRegistryForTest(): void;

package/dist/shell-shard/terminal-registry.js

@@ -0,0 +1,62 @@
+/*
+ * Module-scoped registry of live Terminal.svelte instances.
+ *
+ * Used by `shell.dispatchToTerminal(line)` to find a target terminal when a
+ * non-terminal view (floating picker, dialog) wants to drive a terminal as
+ * if the user had typed the line. Each Terminal.svelte instance registers
+ * itself on mount and disposes on destroy.
+ *
+ * Resolution rule (resolveTargetTerminal):
+ *   - empty registry          → { ok: false, error: 'no-terminal' }
+ *   - exactly one handle      → { ok: true, handle }
+ *   - >1 handles, all stamps 0 → { ok: false, error: 'ambiguous' }
+ *   - >1 handles, ≥1 non-zero → highest-stamped wins; equal non-zero stamps
+ *                               break to last-registered.
+ *
+ * No Svelte runes here — the registry is plain module state so node-project
+ * tests can drive it directly.
+ */
+const handles = [];
+let nextTerminalId = 0;
+/** Mint a stable id for a Terminal.svelte instance. Called once per mount. */
+export function mintTerminalId() {
+    return `term-${++nextTerminalId}`;
+}
+export function registerTerminalView(handle) {
+    handles.push(handle);
+    let disposed = false;
+    return () => {
+        if (disposed)
+            return;
+        disposed = true;
+        const idx = handles.indexOf(handle);
+        if (idx !== -1)
+            handles.splice(idx, 1);
+    };
+}
+export function listTerminalViews() {
+    return handles.slice();
+}
+export function resolveTargetTerminal() {
+    if (handles.length === 0)
+        return { ok: false, error: 'no-terminal' };
+    if (handles.length === 1)
+        return { ok: true, handle: handles[0] };
+    let best = null;
+    let bestStamp = 0;
+    for (const h of handles) {
+        const stamp = h.getFocusStamp();
+        if (stamp > 0 && stamp >= bestStamp) {
+            best = h;
+            bestStamp = stamp;
+        }
+    }
+    if (best === null)
+        return { ok: false, error: 'ambiguous' };
+    return { ok: true, handle: best };
+}
+/** Test-only — wipes the registry and id counter between cases. */
+export function __resetTerminalRegistryForTest() {
+    handles.length = 0;
+    nextTerminalId = 0;
+}

package/dist/shell-shard/terminal-registry.test.d.ts

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

package/dist/shell-shard/terminal-registry.test.js

@@ -0,0 +1,88 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { registerTerminalView, listTerminalViews, resolveTargetTerminal, mintTerminalId, __resetTerminalRegistryForTest, } from './terminal-registry';
+function makeHandle(id, focusStamp = 0) {
+    return {
+        id,
+        dispatch: async () => undefined,
+        getFocusStamp: () => focusStamp,
+        getMode: () => ({ id: 'sh3', label: 'sh3', transport: 'none', autoRelocate: false, showCwd: true }),
+    };
+}
+describe('terminal-registry', () => {
+    beforeEach(() => {
+        __resetTerminalRegistryForTest();
+    });
+    describe('registerTerminalView', () => {
+        it('returns a disposer that removes the handle', () => {
+            const h = makeHandle('term-1');
+            const dispose = registerTerminalView(h);
+            expect(listTerminalViews()).toEqual([h]);
+            dispose();
+            expect(listTerminalViews()).toEqual([]);
+        });
+        it('disposer is idempotent', () => {
+            const dispose = registerTerminalView(makeHandle('term-1'));
+            dispose();
+            expect(() => dispose()).not.toThrow();
+            expect(listTerminalViews()).toEqual([]);
+        });
+        it('registers multiple handles in order', () => {
+            const a = makeHandle('term-a');
+            const b = makeHandle('term-b');
+            registerTerminalView(a);
+            registerTerminalView(b);
+            expect(listTerminalViews()).toEqual([a, b]);
+        });
+    });
+    describe('resolveTargetTerminal', () => {
+        it('returns no-terminal when registry is empty', () => {
+            expect(resolveTargetTerminal()).toEqual({ ok: false, error: 'no-terminal' });
+        });
+        it('returns the sole handle when exactly one is registered', () => {
+            const h = makeHandle('term-1');
+            registerTerminalView(h);
+            expect(resolveTargetTerminal()).toEqual({ ok: true, handle: h });
+        });
+        it('returns ambiguous when multiple handles all have stamp 0', () => {
+            registerTerminalView(makeHandle('term-a', 0));
+            registerTerminalView(makeHandle('term-b', 0));
+            expect(resolveTargetTerminal()).toEqual({ ok: false, error: 'ambiguous' });
+        });
+        it('returns the handle with the highest non-zero stamp', () => {
+            const a = makeHandle('term-a', 100);
+            const b = makeHandle('term-b', 200);
+            registerTerminalView(a);
+            registerTerminalView(b);
+            const r = resolveTargetTerminal();
+            expect(r).toEqual({ ok: true, handle: b });
+        });
+        it('returns the highest-stamped handle when one has stamp 0 and the other does not', () => {
+            const a = makeHandle('term-a', 0);
+            const b = makeHandle('term-b', 50);
+            registerTerminalView(a);
+            registerTerminalView(b);
+            expect(resolveTargetTerminal()).toEqual({ ok: true, handle: b });
+        });
+        it('breaks equal non-zero stamps by last-registered', () => {
+            const a = makeHandle('term-a', 100);
+            const b = makeHandle('term-b', 100);
+            registerTerminalView(a);
+            registerTerminalView(b);
+            expect(resolveTargetTerminal()).toEqual({ ok: true, handle: b });
+        });
+    });
+    describe('mintTerminalId', () => {
+        it('produces unique ids on each call', () => {
+            const a = mintTerminalId();
+            const b = mintTerminalId();
+            expect(a).not.toEqual(b);
+            expect(a).toMatch(/^term-\d+$/);
+        });
+        it('is reset by __resetTerminalRegistryForTest', () => {
+            mintTerminalId();
+            mintTerminalId();
+            __resetTerminalRegistryForTest();
+            expect(mintTerminalId()).toBe('term-1');
+        });
+    });
+});

package/dist/shellApi/window.d.ts

@@ -0,0 +1,15 @@
+import { type SatellitePayload } from '../boot/satellitePayload';
+export interface SpawnSatelliteOptions {
+    /** Suggested window title. Defaults to a payload-derived title. */
+    title?: string;
+    /** Initial window inner width in CSS px. */
+    width?: number;
+    /** Initial window inner height in CSS px. */
+    height?: number;
+}
+/**
+ * Open a new native window rendering a satellite slice of SH3.
+ * Returns the unique label assigned to the new window, or an empty
+ * string when called outside Tauri.
+ */
+export declare function spawnSatellite(payload: SatellitePayload, opts?: SpawnSatelliteOptions): Promise<string>;

package/dist/shellApi/window.js

@@ -0,0 +1,43 @@
+/*
+ * shell.window — host-side facade for spawning satellite windows.
+ *
+ * Under Tauri, `spawnSatellite` invokes the `sh3_spawn_satellite` Rust
+ * command which opens a native WebviewWindow pointed at the embedded
+ * sh3-server with the encoded payload in the query string. Outside
+ * Tauri (web builds) the call logs a warning and resolves with an
+ * empty string so callers can no-op gracefully.
+ */
+import { encodePayload } from '../boot/satellitePayload';
+function isTauri() {
+    return typeof globalThis.__TAURI_INTERNALS__ !== 'undefined';
+}
+let labelCounter = 0;
+function nextLabel() {
+    labelCounter += 1;
+    return `sh3-satellite-${Date.now()}-${labelCounter}`;
+}
+/**
+ * Open a new native window rendering a satellite slice of SH3.
+ * Returns the unique label assigned to the new window, or an empty
+ * string when called outside Tauri.
+ */
+export async function spawnSatellite(payload, opts = {}) {
+    var _a, _b, _c, _d;
+    if (!isTauri()) {
+        console.warn('[sh3] shell.window.spawn called outside Tauri — no-op');
+        return '';
+    }
+    const { invoke } = await import('@tauri-apps/api/core');
+    const encoded = encodePayload(payload);
+    const label = nextLabel();
+    const title = (_a = opts.title) !== null && _a !== void 0 ? _a : (payload.kind === 'float' ? ((_b = payload.title) !== null && _b !== void 0 ? _b : 'SH3') : `SH3 — ${payload.appId}`);
+    const width = (_c = opts.width) !== null && _c !== void 0 ? _c : (payload.kind === 'float' ? payload.size.w : 1024);
+    const height = (_d = opts.height) !== null && _d !== void 0 ? _d : (payload.kind === 'float' ? payload.size.h : 768);
+    return invoke('sh3_spawn_satellite', {
+        payload: encoded,
+        label,
+        title,
+        width,
+        height,
+    });
+}

package/dist/shellApi/window.test.d.ts

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

package/dist/shellApi/window.test.js

@@ -0,0 +1,19 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { spawnSatellite } from './window';
+describe('shell.window.spawn (non-Tauri)', () => {
+    beforeEach(() => {
+        delete globalThis.__TAURI_INTERNALS__;
+    });
+    it('returns empty string and warns when called without Tauri', async () => {
+        const warn = vi.spyOn(console, 'warn').mockImplementation(() => { });
+        const payload = {
+            kind: 'app',
+            appId: 'x',
+            activateShards: [],
+        };
+        const result = await spawnSatellite(payload);
+        expect(result).toBe('');
+        expect(warn).toHaveBeenCalled();
+        warn.mockRestore();
+    });
+});

package/dist/shellRuntime.svelte.d.ts

@@ -9,6 +9,7 @@ import type { ConflictsApi } from './conflicts/api';
 import type { ColorApi } from './color/api';
 import { type OpenContextMenuOpts, type OpenPaletteOpts } from './actions/listeners';
 import type { ActiveActionDescriptor } from './actions/types';
+import { type DispatchToTerminalResult } from './shell-shard/dispatch-to-terminal';
 /**
  * The process-wide shell singleton exposed to shards and the shell's own
  * internal code. Provides state zone creation and overlay managers.
@@ -38,6 +39,17 @@ export interface Shell {
     color: ColorApi;
     /** Actions facade — rebind keys, query bindings, open menus/palette. */
     actions: ShellActionsApi;
+    /**
+     * Dispatch `line` through a Terminal view's normal submit path. Used by
+     * views outside a verb context (floating pickers, dialogs) to drive a
+     * terminal as if the user had typed the line. Resolves which terminal:
+     * focused → sole → fail. Returns synchronously with the routing outcome;
+     * the dispatch itself runs fire-and-forget.
+     *
+     * Mirrors `ShellApi.dispatchToTerminal` (the verb-side surface). Both
+     * read the same module-scoped registry of live Terminal.svelte instances.
+     */
+    dispatchToTerminal(line: string): DispatchToTerminalResult;
 }
 /**
  * API for managing action bindings and triggering menus/palette

package/dist/shellRuntime.svelte.js

@@ -27,6 +27,7 @@ import { openContextMenu as listenersOpenContextMenu, openPalette as listenersOp
 import { setUserBindings, getLiveDispatcherState, onActiveChange as onActiveChangeState, __notifyActiveChange, } from './actions/state.svelte';
 import { listActions, onActionsChange } from './actions/registry';
 import { listActiveFromEntries } from './actions/listActive';
+import { makeDispatchToTerminal } from './shell-shard/dispatch-to-terminal';
 const shellActions = {
     async rebind(appId, actionId, shortcut) {
         await saveUserBinding(appId, actionId, shortcut);
@@ -75,4 +76,5 @@ export const shell = {
     conflicts: conflictsApi,
     color: colorApi,
     actions: shellActions,
+    dispatchToTerminal: makeDispatchToTerminal({ headless: false }),
 };

package/dist/shellRuntime.svelte.test.d.ts

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

package/dist/shellRuntime.svelte.test.js

@@ -0,0 +1,46 @@
+/*
+ * Targeted coverage for the `shell` runtime singleton's dispatchToTerminal.
+ *
+ * The wiring is what matters: the singleton must consult the same module-
+ * scoped terminal-registry as ShellApi.dispatchToTerminal so a Svelte view
+ * (which imports `shell`) and a verb (which receives `vctx.shell`) hit the
+ * same set of live Terminal handles. A view import is the only path a
+ * picker has — without this, the dispatchToTerminal API is unreachable
+ * from the place it was designed to be called.
+ */
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { shell } from './shellRuntime.svelte';
+import { registerTerminalView, __resetTerminalRegistryForTest, } from './shell-shard/terminal-registry';
+function makeHandle(id, focusStamp = 0, dispatch = vi.fn(async () => undefined)) {
+    return {
+        id,
+        dispatch,
+        getFocusStamp: () => focusStamp,
+        getMode: () => ({ id: 'sh3', label: 'sh3', transport: 'none', autoRelocate: false, showCwd: true }),
+    };
+}
+describe('shell runtime singleton — dispatchToTerminal', () => {
+    beforeEach(() => {
+        __resetTerminalRegistryForTest();
+    });
+    it('returns no-terminal when registry is empty', () => {
+        const r = shell.dispatchToTerminal('foo');
+        expect(r).toMatchObject({ ok: false, error: 'no-terminal', message: 'no terminal open' });
+    });
+    it('routes through the resolved handle when one is registered', () => {
+        const dispatch = vi.fn(async () => undefined);
+        registerTerminalView(makeHandle('term-1', 0, dispatch));
+        const r = shell.dispatchToTerminal('apps');
+        expect(r).toEqual({ ok: true, terminalId: 'term-1' });
+        expect(dispatch).toHaveBeenCalledWith('apps');
+    });
+    it('shares the registry with ShellApi.dispatchToTerminal (same handles, same routing)', () => {
+        const dispatch = vi.fn(async () => undefined);
+        registerTerminalView(makeHandle('term-shared', 0, dispatch));
+        // The singleton is the surface a Svelte view sees; it must hit the
+        // same registry as the verb-side ShellApi.
+        const r = shell.dispatchToTerminal('hi');
+        expect(r).toEqual({ ok: true, terminalId: 'term-shared' });
+        expect(dispatch).toHaveBeenCalledWith('hi');
+    });
+});

package/dist/verbs/types.d.ts

@@ -2,6 +2,7 @@ import type { Scrollback } from '../shell-shard/scrollback.svelte';
 import type { SessionClient } from '../shell-shard/session-client.svelte';
 import type { TenantFsClient } from '../shell-shard/tenant-fs-client';
 import type { TreeRootRef } from '../layout/types';
+import type { DispatchToTerminalResult } from '../shell-shard/dispatch-to-terminal';
 export interface ShellApi {
     listApps(): Array<{
         id: string;
@@ -86,7 +87,21 @@ export interface ShellApi {
         id: string;
         label: string;
     };
+    /**
+     * Dispatch `line` through a Terminal view's normal submit path. Resolves
+     * which terminal to target: the focused one if any has been focused; the
+     * sole one if exactly one terminal is open; fail otherwise. The dispatch
+     * runs fire-and-forget on the targeted terminal — this method returns
+     * synchronously with the routing outcome.
+     *
+     * Used by views outside a verb context (floating pickers, dialogs) to
+     * drive a terminal as if the user had typed the line. The targeted
+     * terminal's current mode + cwd apply — `line` is resolved against
+     * its verb registry, gating, and history exactly like a typed submit.
+     */
+    dispatchToTerminal(line: string): DispatchToTerminalResult;
 }
+export type { DispatchToTerminalResult } from '../shell-shard/dispatch-to-terminal';
 export interface VerbContext {
     shell: ShellApi;
     scrollback: Scrollback;

package/dist/version.d.ts

@@ -1,2 +1,2 @@
 /** Auto-generated from package.json — do not edit manually. */
-export declare const VERSION = "0.15.2";
+export declare const VERSION = "0.15.4";

package/dist/version.js

@@ -1,2 +1,2 @@
 /** Auto-generated from package.json — do not edit manually. */
-export const VERSION = '0.15.2';
+export const VERSION = '0.15.4';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sh3-core",
-  "version": "0.15.2",
+  "version": "0.15.4",
   "type": "module",
   "files": [
     "dist"