sh3-core 0.13.4 → 0.14.3

package/dist/shell-shard/dispatch-invoke.test.js

@@ -0,0 +1,214 @@
+import { describe, it, expect, vi } from 'vitest';
+import { makeDispatch } from './dispatch';
+const openVerb = {
+    name: 'open',
+    summary: '',
+    async run(ctx, args) {
+        var _a;
+        ctx.scrollback.push({ kind: 'status', text: `opened:${(_a = args[0]) !== null && _a !== void 0 ? _a : ''}`, level: 'info', ts: 0 });
+    },
+};
+function scaffold(opts) {
+    const sent = [];
+    const pushed = [];
+    const connectSpy = vi.fn();
+    const scrollback = { push: (e) => pushed.push(e), clear: () => { } };
+    const session = {
+        history: { push: vi.fn() },
+        send: (m) => sent.push(m),
+        cwd: '/',
+        connect: connectSpy,
+    };
+    const fs = {};
+    const shell = {};
+    const resolver = {
+        resolve: (line, _opts = {}) => {
+            const head = line.trim().split(/\s+/)[0];
+            const rest = line.trim().split(/\s+/).slice(1);
+            if (head === 'open')
+                return { kind: 'local', verb: openVerb, args: rest, line };
+            return { kind: 'forward', line };
+        },
+    };
+    const { dispatch } = makeDispatch({
+        mode: () => opts.current,
+        role: () => opts.role,
+        resolver,
+        scrollback,
+        session,
+        shell,
+        fs,
+        cwd: () => '/',
+        busy: () => () => { },
+        customMode: (id) => { var _a, _b; return (_b = (_a = opts.customs) === null || _a === void 0 ? void 0 : _a.find((d) => d.id === id)) !== null && _b !== void 0 ? _b : null; },
+    });
+    return { dispatch, sent, pushed, connectSpy };
+}
+const customMode = (id) => ({ id, label: id, transport: 'custom', autoRelocate: false });
+describe('output.invoke — sh3 target', () => {
+    it('runs an sh3 verb when invoked from a custom mode', async () => {
+        const captured = [];
+        const customs = [{
+                id: 'gemini',
+                label: 'Gemini',
+                runsOn: 'client',
+                dispatch: async (_input, output) => {
+                    await output.invoke('sh3', 'open foo.md');
+                    captured.push('after-invoke');
+                },
+            }];
+        const { dispatch, pushed } = scaffold({
+            current: customMode('gemini'),
+            role: 'user',
+            customs,
+        });
+        await dispatch('hello');
+        expect(pushed.some((e) => e.kind === 'status' && e.text === 'opened:foo.md')).toBe(true);
+        expect(captured).toEqual(['after-invoke']);
+    });
+    it('throws for unknown sh3 verb', async () => {
+        let caught;
+        const customs = [{
+                id: 'gemini',
+                label: 'Gemini',
+                runsOn: 'client',
+                dispatch: async (_input, output) => {
+                    try {
+                        await output.invoke('sh3', 'nonexistent');
+                    }
+                    catch (e) {
+                        caught = e;
+                    }
+                },
+            }];
+        const { dispatch } = scaffold({ current: customMode('gemini'), role: 'user', customs });
+        await dispatch('hello');
+        expect(caught).toBeInstanceOf(Error);
+        expect(caught.message).toMatch(/unknown sh3 verb/);
+    });
+});
+describe('output.invoke — bash target', () => {
+    it('admin invocation lazy-connects and forwards', async () => {
+        const customs = [{
+                id: 'gemini',
+                label: 'Gemini',
+                runsOn: 'client',
+                dispatch: async (_input, output) => {
+                    await output.invoke('bash', 'ls');
+                },
+            }];
+        const { dispatch, sent, connectSpy } = scaffold({
+            current: customMode('gemini'),
+            role: 'admin',
+            customs,
+        });
+        await dispatch('hello');
+        expect(connectSpy).toHaveBeenCalledTimes(1);
+        expect(sent.some((m) => m.t === 'submit' && m.line === 'ls')).toBe(true);
+    });
+    it('lazy-connect only fires once across multiple invokes', async () => {
+        const customs = [{
+                id: 'gemini',
+                label: 'Gemini',
+                runsOn: 'client',
+                dispatch: async (_input, output) => {
+                    await output.invoke('bash', 'ls');
+                    await output.invoke('bash', 'pwd');
+                },
+            }];
+        const { dispatch, connectSpy } = scaffold({
+            current: customMode('gemini'),
+            role: 'admin',
+            customs,
+        });
+        await dispatch('hello');
+        expect(connectSpy).toHaveBeenCalledTimes(1);
+    });
+    it('non-admin invoking bash throws', async () => {
+        let caught;
+        const customs = [{
+                id: 'gemini',
+                label: 'Gemini',
+                runsOn: 'client',
+                dispatch: async (_input, output) => {
+                    try {
+                        await output.invoke('bash', 'ls');
+                    }
+                    catch (e) {
+                        caught = e;
+                    }
+                },
+            }];
+        const { dispatch } = scaffold({ current: customMode('gemini'), role: 'user', customs });
+        await dispatch('hello');
+        expect(caught).toBeInstanceOf(Error);
+        expect(caught.message).toMatch(/admin role/);
+    });
+});
+describe('output.invoke — guards', () => {
+    it('self-invoke throws', async () => {
+        let caught;
+        const customs = [{
+                id: 'gemini',
+                label: 'Gemini',
+                runsOn: 'client',
+                dispatch: async (_input, output) => {
+                    try {
+                        await output.invoke('gemini', 'foo');
+                    }
+                    catch (e) {
+                        caught = e;
+                    }
+                },
+            }];
+        const { dispatch } = scaffold({ current: customMode('gemini'), role: 'user', customs });
+        await dispatch('hello');
+        expect(caught).toBeInstanceOf(Error);
+        expect(caught.message).toMatch(/cannot invoke own mode/);
+    });
+    it('unknown custom mode throws', async () => {
+        let caught;
+        const customs = [{
+                id: 'gemini',
+                label: 'Gemini',
+                runsOn: 'client',
+                dispatch: async (_input, output) => {
+                    try {
+                        await output.invoke('claude', 'foo');
+                    }
+                    catch (e) {
+                        caught = e;
+                    }
+                },
+            }];
+        const { dispatch } = scaffold({ current: customMode('gemini'), role: 'user', customs });
+        await dispatch('hello');
+        expect(caught).toBeInstanceOf(Error);
+        expect(caught.message).toMatch(/unknown mode/);
+    });
+});
+describe('output.invoke — custom target', () => {
+    it('routes through the target descriptor dispatch with the same scrollback', async () => {
+        const customs = [
+            {
+                id: 'gemini',
+                label: 'Gemini',
+                runsOn: 'client',
+                dispatch: async (_input, output) => {
+                    await output.invoke('claude', 'hi');
+                },
+            },
+            {
+                id: 'claude',
+                label: 'Claude',
+                runsOn: 'client',
+                dispatch: async (input, output) => {
+                    output.text('stdout', `claude:${input.line}\n`);
+                },
+            },
+        ];
+        const { dispatch, pushed } = scaffold({ current: customMode('gemini'), role: 'user', customs });
+        await dispatch('hello');
+        expect(pushed.some((e) => { var _a, _b; return e.kind === 'text' && ((_b = (_a = e.chunks) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.includes('claude:hi')); })).toBe(true);
+    });
+});

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

@@ -2,14 +2,35 @@ import type { VerbRegistry, ShellApi } from './registry';
 import type { Scrollback } from './scrollback.svelte';
 import type { SessionClient } from './session-client.svelte';
 import type { TenantFsClient } from './tenant-fs-client';
-import type { ShellMode } from './modes/types';
+import type { ShellMode, ShellRole } from './modes/types';
+import type { ShellModeDescriptor } from './contract';
 export interface DispatchDeps {
     mode: () => ShellMode;
+    /** Current shell role — used by invoke() role-gating. */
+    role: () => ShellRole;
     resolver: VerbRegistry;
     scrollback: Scrollback;
     session: SessionClient;
     shell: ShellApi;
     fs: TenantFsClient;
     cwd: () => string;
+    /**
+     * Acquire a busy indicator. Returns a clear handle. Calling clear()
+     * multiple times is safe (idempotent). Used internally to auto-spawn
+     * a spinner around custom-mode dispatch and exposed via output.busy().
+     */
+    busy: (label?: string) => () => void;
+    /**
+     * Look up a contributed mode descriptor by id. Called only when the active
+     * mode has `transport: 'custom'`. Returns null if the descriptor has been
+     * unloaded (rare race; the active-mode-fallback effect in Terminal.svelte
+     * handles this on the next tick — dispatch surfaces an error in the meantime).
+     */
+    customMode?: (id: string) => ShellModeDescriptor | null;
 }
-export declare function makeDispatch(deps: DispatchDeps): (line: string) => Promise<void>;
+export interface DispatchHandle {
+    dispatch: (line: string) => Promise<void>;
+    /** Abort any in-flight custom-mode dispatch. Safe to call repeatedly. */
+    cancel: () => void;
+}
+export declare function makeDispatch(deps: DispatchDeps): DispatchHandle;

package/dist/shell-shard/dispatch.js

@@ -4,10 +4,80 @@
  * Pure function (no Svelte reactivity) so it can be unit-tested independently.
  * The mode is passed as a getter so the dispatch closure always sees the
  * current mode without being reconstructed on every mode change.
+ *
+ * Returns a `{ dispatch, cancel }` handle so the caller can abort an
+ * in-flight custom-mode dispatch (e.g. when the user switches mode mid-stream).
  */
+import { makeShellModeOutput } from './output';
 export function makeDispatch(deps) {
-    return async function dispatch(line) {
-        var _a;
+    let activeController = null;
+    /**
+     * Programmatic cross-mode dispatch. Validates target id, role gate, and
+     * self-invoke; routes to sh3 (full local resolution), bash (WS forward
+     * with lazy connect), or a custom descriptor (recursive desc.dispatch).
+     *
+     * sh3 path bypasses mode gating: a verb's globalVerb flag is irrelevant
+     * because the caller is a trusted mode shard, not user input from a
+     * different mode.
+     */
+    let bashConnected = false;
+    async function invoke(modeId, line) {
+        var _a, _b, _c, _d;
+        const current = deps.mode();
+        if (modeId === current.id) {
+            throw new Error(`invoke: cannot invoke own mode '${modeId}'`);
+        }
+        if (modeId === 'sh3') {
+            const resolution = deps.resolver.resolve(line, { globalOnly: false });
+            if (resolution.kind === 'forward') {
+                const head = (_a = line.trim().split(/\s+/)[0]) !== null && _a !== void 0 ? _a : '';
+                throw new Error(`invoke: unknown sh3 verb '${head}'`);
+            }
+            await resolution.verb.run({
+                shell: deps.shell,
+                scrollback: deps.scrollback,
+                session: deps.session,
+                cwd: deps.cwd(),
+                dispatch,
+                fs: deps.fs,
+            }, resolution.args);
+            return;
+        }
+        if (modeId === 'bash') {
+            if (deps.role() !== 'admin') {
+                throw new Error("invoke: 'bash' requires admin role");
+            }
+            if (!bashConnected) {
+                bashConnected = true;
+                deps.session.connect();
+            }
+            deps.session.send({ t: 'submit', line });
+            return;
+        }
+        // Custom mode
+        const desc = (_c = (_b = deps.customMode) === null || _b === void 0 ? void 0 : _b.call(deps, modeId)) !== null && _c !== void 0 ? _c : null;
+        if (!desc) {
+            throw new Error(`invoke: unknown mode '${modeId}'`);
+        }
+        if (desc.requiresRole && desc.requiresRole !== deps.role()) {
+            throw new Error(`invoke: mode '${modeId}' requires ${desc.requiresRole} role`);
+        }
+        if (desc.runsOn === 'server') {
+            throw new Error('invoke: server-side modes are not yet supported');
+        }
+        const subOutput = makeShellModeOutput({
+            scrollback: deps.scrollback,
+            busy: deps.busy,
+            invoke,
+        });
+        await desc.dispatch({ line, cwd: deps.cwd(), signal: (_d = activeController === null || activeController === void 0 ? void 0 : activeController.signal) !== null && _d !== void 0 ? _d : new AbortController().signal }, subOutput);
+    }
+    async function dispatch(line) {
+        var _a, _b, _c, _d;
+        // Abort any in-flight custom dispatch when a new line is submitted.
+        activeController === null || activeController === void 0 ? void 0 : activeController.abort();
+        const controller = new AbortController();
+        activeController = controller;
         const mode = deps.mode();
         deps.session.history.push(line);
         // User-mode $ escape: block server-shell access
@@ -16,7 +86,9 @@ export function makeDispatch(deps) {
             deps.scrollback.push({ kind: 'status', text: 'shell: server shell not available in user mode', level: 'error', ts: Date.now() });
             return;
         }
-        const resolution = deps.resolver.resolve(line);
+        const resolution = deps.resolver.resolve(line, {
+            globalOnly: mode.id !== 'sh3',
+        });
         if (resolution.kind === 'local') {
             // Log locally-dispatched verbs for shared history (ws only)
             if (mode.transport === 'ws') {
@@ -46,11 +118,63 @@ export function makeDispatch(deps) {
         // forward path
         if (mode.transport === 'ws') {
             deps.session.send({ t: 'submit', line: resolution.line });
+            return;
         }
-        else {
-            const firstToken = (_a = resolution.line.split(/\s+/)[0]) !== null && _a !== void 0 ? _a : '';
+        if (mode.transport === 'custom') {
             deps.scrollback.push({ kind: 'prompt', cwd: deps.cwd(), line: resolution.line, ts: Date.now() });
-            deps.scrollback.push({ kind: 'status', text: `unknown verb: ${firstToken}`, level: 'error', ts: Date.now() });
+            const desc = (_b = (_a = deps.customMode) === null || _a === void 0 ? void 0 : _a.call(deps, mode.id)) !== null && _b !== void 0 ? _b : null;
+            if (!desc) {
+                deps.scrollback.push({
+                    kind: 'status',
+                    text: `mode '${mode.id}' is no longer available`,
+                    level: 'error',
+                    ts: Date.now(),
+                });
+                return;
+            }
+            if (desc.runsOn === 'server') {
+                deps.scrollback.push({
+                    kind: 'status',
+                    text: 'server-side modes are not yet supported (planned for a future release)',
+                    level: 'error',
+                    ts: Date.now(),
+                });
+                return;
+            }
+            const output = makeShellModeOutput({
+                scrollback: deps.scrollback,
+                busy: deps.busy,
+                invoke,
+            });
+            const clearBusy = deps.busy();
+            try {
+                await desc.dispatch({ line: resolution.line, cwd: deps.cwd(), signal: controller.signal }, output);
+            }
+            catch (err) {
+                if ((err === null || err === void 0 ? void 0 : err.name) === 'AbortError') {
+                    deps.scrollback.push({ kind: 'status', text: 'mode dispatch aborted', level: 'info', ts: Date.now() });
+                }
+                else {
+                    deps.scrollback.push({
+                        kind: 'status',
+                        text: `mode '${mode.id}' threw — ${(_c = err === null || err === void 0 ? void 0 : err.message) !== null && _c !== void 0 ? _c : String(err)}`,
+                        level: 'error',
+                        ts: Date.now(),
+                    });
+                }
+            }
+            finally {
+                clearBusy();
+            }
+            return;
         }
+        // 'none' transport, unknown verb: print error
+        const firstToken = (_d = resolution.line.split(/\s+/)[0]) !== null && _d !== void 0 ? _d : '';
+        deps.scrollback.push({ kind: 'prompt', cwd: deps.cwd(), line: resolution.line, ts: Date.now() });
+        deps.scrollback.push({ kind: 'status', text: `unknown verb: ${firstToken}`, level: 'error', ts: Date.now() });
+    }
+    return {
+        dispatch,
+        cancel: () => activeController === null || activeController === void 0 ? void 0 : activeController.abort(),
     };
 }

package/dist/shell-shard/modes/builtin.d.ts

@@ -1,5 +1,5 @@
 import { ShellModeRegistry } from './registry';
 import type { ShellMode } from './types';
-export declare const DEV_MODE: ShellMode;
-export declare const USER_MODE: ShellMode;
+export declare const BASH_MODE: ShellMode;
+export declare const SH3_MODE: ShellMode;
 export declare function registerBuiltinModes(reg: ShellModeRegistry): void;

package/dist/shell-shard/modes/builtin.js

@@ -1,18 +1,18 @@
 import { ShellModeRegistry } from './registry';
-export const DEV_MODE = {
-    id: 'dev',
-    label: 'Dev',
+export const BASH_MODE = {
+    id: 'bash',
+    label: 'Bash',
     requiresRole: 'admin',
     transport: 'ws',
     autoRelocate: false,
 };
-export const USER_MODE = {
-    id: 'user',
-    label: 'User',
+export const SH3_MODE = {
+    id: 'sh3',
+    label: 'SH3',
     transport: 'none',
     autoRelocate: true,
 };
 export function registerBuiltinModes(reg) {
-    reg.register(DEV_MODE);
-    reg.register(USER_MODE);
+    reg.register(BASH_MODE);
+    reg.register(SH3_MODE);
 }

package/dist/shell-shard/modes/prefs.js

@@ -26,6 +26,6 @@ export function resolveInitialMode(reg, userId, role) {
         if (m && (!m.requiresRole || m.requiresRole === role))
             return m;
     }
-    const fallback = role === 'admin' ? 'dev' : 'user';
+    const fallback = role === 'admin' ? 'bash' : 'sh3';
     return reg.get(fallback);
 }

package/dist/shell-shard/modes/prefs.test.js

@@ -15,8 +15,8 @@ beforeEach(() => {
 });
 describe('readLastMode / writeLastMode', () => {
     it('round-trips a mode id for a user', () => {
-        writeLastMode('alice', 'user');
-        expect(readLastMode('alice')).toBe('user');
+        writeLastMode('alice', 'sh3');
+        expect(readLastMode('alice')).toBe('sh3');
     });
     it('returns null when nothing persisted', () => {
         expect(readLastMode('bob')).toBeNull();
@@ -25,22 +25,22 @@ describe('readLastMode / writeLastMode', () => {
 describe('resolveInitialMode', () => {
     const reg = new ShellModeRegistry();
     registerBuiltinModes(reg);
-    it('admin with no pref → dev', () => {
-        expect(resolveInitialMode(reg, 'alice', 'admin').id).toBe('dev');
+    it('admin with no pref → bash', () => {
+        expect(resolveInitialMode(reg, 'alice', 'admin').id).toBe('bash');
     });
-    it('user with no pref → user', () => {
-        expect(resolveInitialMode(reg, 'alice', 'user').id).toBe('user');
+    it('user with no pref → sh3', () => {
+        expect(resolveInitialMode(reg, 'alice', 'user').id).toBe('sh3');
     });
-    it('admin with persisted user → user', () => {
-        writeLastMode('alice', 'user');
-        expect(resolveInitialMode(reg, 'alice', 'admin').id).toBe('user');
+    it('admin with persisted sh3 → sh3', () => {
+        writeLastMode('alice', 'sh3');
+        expect(resolveInitialMode(reg, 'alice', 'admin').id).toBe('sh3');
     });
-    it('user with persisted dev (not allowed) → falls back to user', () => {
-        writeLastMode('alice', 'dev');
-        expect(resolveInitialMode(reg, 'alice', 'user').id).toBe('user');
+    it('user with persisted bash (not allowed) → falls back to sh3', () => {
+        writeLastMode('alice', 'bash');
+        expect(resolveInitialMode(reg, 'alice', 'user').id).toBe('sh3');
     });
     it('persisted unknown id → role default', () => {
         writeLastMode('alice', 'nonsense');
-        expect(resolveInitialMode(reg, 'alice', 'admin').id).toBe('dev');
+        expect(resolveInitialMode(reg, 'alice', 'admin').id).toBe('bash');
     });
 });

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

@@ -1,7 +1,7 @@
 import { describe, it, expect, beforeEach } from 'vitest';
 import { ShellModeRegistry } from './registry';
-const dev = { id: 'dev', label: 'Dev', requiresRole: 'admin', transport: 'ws', autoRelocate: false };
-const user = { id: 'user', label: 'User', transport: 'none', autoRelocate: true };
+const bash = { id: 'bash', label: 'Bash', requiresRole: 'admin', transport: 'ws', autoRelocate: false };
+const sh3 = { id: 'sh3', label: 'SH3', transport: 'none', autoRelocate: true };
 const ssh = { id: 'ssh', label: 'SSH', requiresRole: 'admin', transport: 'custom', autoRelocate: false };
 describe('ShellModeRegistry', () => {
     let reg;
@@ -9,27 +9,27 @@ describe('ShellModeRegistry', () => {
         reg = new ShellModeRegistry();
     });
     it('registers and retrieves modes', () => {
-        reg.register(dev);
-        expect(reg.get('dev')).toEqual(dev);
+        reg.register(bash);
+        expect(reg.get('bash')).toEqual(bash);
     });
     it('list(user) excludes admin-only modes', () => {
-        reg.register(dev);
-        reg.register(user);
+        reg.register(bash);
+        reg.register(sh3);
         reg.register(ssh);
         const ids = reg.list('user').map((m) => m.id);
-        expect(ids).toEqual(['user']);
+        expect(ids).toEqual(['sh3']);
     });
     it('list(admin) includes all modes', () => {
-        reg.register(dev);
-        reg.register(user);
+        reg.register(bash);
+        reg.register(sh3);
         reg.register(ssh);
         const ids = reg.list('admin').map((m) => m.id).sort();
-        expect(ids).toEqual(['dev', 'ssh', 'user']);
+        expect(ids).toEqual(['bash', 'sh3', 'ssh']);
     });
     it('re-registering same id replaces the mode', () => {
         var _a;
-        reg.register(dev);
-        reg.register(Object.assign(Object.assign({}, dev), { label: 'Dev+' }));
-        expect((_a = reg.get('dev')) === null || _a === void 0 ? void 0 : _a.label).toBe('Dev+');
+        reg.register(bash);
+        reg.register(Object.assign(Object.assign({}, bash), { label: 'Bash+' }));
+        expect((_a = reg.get('bash')) === null || _a === void 0 ? void 0 : _a.label).toBe('Bash+');
     });
 });

package/dist/shell-shard/output.d.ts

@@ -0,0 +1,10 @@
+import type { Scrollback } from './scrollback.svelte';
+import type { ShellModeOutput } from './contract';
+export interface ShellModeOutputDeps {
+    scrollback: Scrollback;
+    /** Acquire a busy indicator; returns a clear handle. */
+    busy: (label?: string) => () => void;
+    /** Programmatically dispatch a line through another mode's resolution path. */
+    invoke: (modeId: string, line: string) => Promise<void>;
+}
+export declare function makeShellModeOutput(deps: ShellModeOutputDeps): ShellModeOutput;

package/dist/shell-shard/output.js

@@ -0,0 +1,91 @@
+/*
+ * makeShellModeOutput — wraps a Scrollback in the typed ShellModeOutput
+ * surface external mode shards consume. The framework is the only writer to
+ * scrollback shapes; mode authors talk to this handle.
+ *
+ * Streaming entries carry a `__streamState` prop set to 'streaming' on push,
+ * 'complete' on complete(), 'error' on error(). The entry's component is
+ * expected to read this prop (or ignore it — it's optional).
+ */
+function findRich(sb, entryId) {
+    return sb.entries.find((e) => e.kind === 'rich' && e.id === entryId);
+}
+function makeRichHandle(sb, entryId) {
+    return {
+        update(patch) {
+            const entry = findRich(sb, entryId);
+            if (!entry)
+                return;
+            Object.assign(entry.props, patch);
+        },
+    };
+}
+function lastRichId(sb) {
+    const last = sb.entries[sb.entries.length - 1];
+    return last.id;
+}
+export function makeShellModeOutput(deps) {
+    const sb = deps.scrollback;
+    return {
+        text(stream, chunk) {
+            sb.push({ kind: 'text', stream, chunks: [chunk], ts: Date.now() });
+        },
+        status(level, msg) {
+            sb.push({ kind: 'status', text: msg, level, ts: Date.now() });
+        },
+        rich(component, props) {
+            sb.push({ kind: 'rich', component, props: Object.assign({}, props), ts: Date.now() });
+            return makeRichHandle(sb, lastRichId(sb));
+        },
+        stream(component, initialProps) {
+            sb.push({
+                kind: 'rich',
+                component,
+                props: Object.assign(Object.assign({}, initialProps), { __streamState: 'streaming' }),
+                ts: Date.now(),
+            });
+            const id = lastRichId(sb);
+            return {
+                append(patch) {
+                    const entry = findRich(sb, id);
+                    if (!entry)
+                        return;
+                    Object.assign(entry.props, patch);
+                },
+                complete() {
+                    const entry = findRich(sb, id);
+                    if (!entry)
+                        return;
+                    entry.props.__streamState = 'complete';
+                },
+                error(err) {
+                    var _a;
+                    const entry = findRich(sb, id);
+                    if (entry)
+                        entry.props.__streamState = 'error';
+                    sb.push({
+                        kind: 'status',
+                        text: `mode: ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : String(err)}`,
+                        level: 'error',
+                        ts: Date.now(),
+                    });
+                },
+            };
+        },
+        busy(label) {
+            const clearController = deps.busy(label);
+            let cleared = false;
+            return {
+                clear() {
+                    if (cleared)
+                        return;
+                    cleared = true;
+                    clearController();
+                },
+            };
+        },
+        invoke(modeId, line) {
+            return deps.invoke(modeId, line);
+        },
+    };
+}

package/dist/shell-shard/output.test.d.ts

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