sh3-core 0.14.3 → 0.15.0

package/dist/api.d.ts

@@ -46,10 +46,12 @@ export declare const capabilities: {
     readonly hotInstall: boolean;
 };
 export type { ServerShard, ServerShardContext, TenantDocumentAPI } from './server-shard/types';
-export type { Verb, VerbContext, ShellApi } from './verbs/types';
+export type { Verb, VerbContext, ShellApi, VerbSchema, PortableJSONSchema, } from './verbs/types';
 export type { Scrollback } from './shell-shard/scrollback.svelte';
 export type { SessionClient } from './shell-shard/session-client.svelte';
 export { listVerbs } from './shards/registry';
+export { runVerbProgrammatic } from './runtime';
+export type { RunVerbOpts, RunVerbResult } from './runtime';
 export { registerShellMode } from './shell-shard/registerShellMode';
 export type { ShellModeDescriptor, ShellModeOutput, ShellModeDispatchHandler, ShellModeDispatchInput, ShellModeRunsOn, RichEntryHandle, StreamHandle, } from './shell-shard/contract';
 export { SHELL_MODE_CONTRIBUTION_POINT } from './shell-shard/contract';

package/dist/api.js

@@ -56,6 +56,10 @@ export const capabilities = {
     hotInstall: typeof Blob !== 'undefined' && typeof URL.createObjectURL === 'function',
 };
 export { listVerbs } from './shards/registry';
+// Programmatic verb dispatch (ctx.runVerb backing function — exposed for
+// advanced use cases like cross-tab dispatch wrappers; most consumers
+// should call ctx.runVerb).
+export { runVerbProgrammatic } from './runtime';
 // Shell mode contributions (external shards extend the shell with new modes).
 export { registerShellMode } from './shell-shard/registerShellMode';
 export { SHELL_MODE_CONTRIBUTION_POINT } from './shell-shard/contract';

package/dist/contributions/index.d.ts

@@ -1,2 +1,2 @@
 export type { ContributionsApi } from './types';
-export { register, list, listPoints, onChange, __resetContributionsForTest } from './registry';
+export { register, list, listPoints, onChange, onAnyChange, __resetContributionsForTest } from './registry';

package/dist/contributions/index.js

@@ -5,4 +5,4 @@
  * file is internal-only, re-exporting the registry for activate.svelte.ts
  * and for tests.
  */
-export { register, list, listPoints, onChange, __resetContributionsForTest } from './registry';
+export { register, list, listPoints, onChange, onAnyChange, __resetContributionsForTest } from './registry';

package/dist/contributions/registry.d.ts

@@ -14,6 +14,13 @@ export declare function listPoints(): string[];
  * safe no-op.
  */
 export declare function onChange(pointId: string, cb: () => void): () => void;
+/**
+ * Subscribe to registration changes at every contribution point.
+ * The callback receives the `pointId` so consumers can rebuild
+ * incrementally. Returns an unsubscribe; double-unsubscribe is a
+ * safe no-op. Symmetric with `onChange`, but global.
+ */
+export declare function onAnyChange(cb: (pointId: string) => void): () => void;
 /**
  * Test-only reset. Not exported from the barrel; tests import it
  * directly from this module.

package/dist/contributions/registry.js

@@ -12,12 +12,15 @@
  */
 const points = new Map();
 const listeners = new Map();
+const anyListeners = new Set();
 function emit(pointId) {
     const set = listeners.get(pointId);
-    if (!set)
-        return;
-    for (const cb of set)
-        cb();
+    if (set) {
+        for (const cb of set)
+            cb();
+    }
+    for (const cb of anyListeners)
+        cb(pointId);
 }
 /**
  * Register a descriptor under the given point. Returns an unregister
@@ -79,6 +82,22 @@ export function onChange(pointId, cb) {
             listeners.delete(pointId);
     };
 }
+/**
+ * Subscribe to registration changes at every contribution point.
+ * The callback receives the `pointId` so consumers can rebuild
+ * incrementally. Returns an unsubscribe; double-unsubscribe is a
+ * safe no-op. Symmetric with `onChange`, but global.
+ */
+export function onAnyChange(cb) {
+    anyListeners.add(cb);
+    let disposed = false;
+    return () => {
+        if (disposed)
+            return;
+        disposed = true;
+        anyListeners.delete(cb);
+    };
+}
 /**
  * Test-only reset. Not exported from the barrel; tests import it
  * directly from this module.
@@ -86,4 +105,5 @@ export function onChange(pointId, cb) {
 export function __resetContributionsForTest() {
     points.clear();
     listeners.clear();
+    anyListeners.clear();
 }

package/dist/contributions/registry.test.js

@@ -1,5 +1,5 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { register, list, listPoints, onChange, __resetContributionsForTest, } from './registry';
+import { register, list, listPoints, onChange, onAnyChange, __resetContributionsForTest, } from './registry';
 describe('contributions registry', () => {
     beforeEach(() => {
         __resetContributionsForTest();
@@ -106,4 +106,59 @@ describe('contributions registry', () => {
             expect(cb).not.toHaveBeenCalled();
         });
     });
+    describe('onAnyChange', () => {
+        it('fires on register at any point', () => {
+            const cb = vi.fn();
+            onAnyChange(cb);
+            register('p1', { id: 'a' });
+            register('p2', { id: 'b' });
+            expect(cb).toHaveBeenCalledTimes(2);
+            expect(cb).toHaveBeenNthCalledWith(1, 'p1');
+            expect(cb).toHaveBeenNthCalledWith(2, 'p2');
+        });
+        it('fires on unregister at any point', () => {
+            const cb = vi.fn();
+            const u1 = register('p1', { id: 'a' });
+            const u2 = register('p2', { id: 'b' });
+            onAnyChange(cb);
+            u1();
+            u2();
+            expect(cb).toHaveBeenCalledTimes(2);
+            expect(cb).toHaveBeenNthCalledWith(1, 'p1');
+            expect(cb).toHaveBeenNthCalledWith(2, 'p2');
+        });
+        it('supports multiple subscribers', () => {
+            const a = vi.fn();
+            const b = vi.fn();
+            onAnyChange(a);
+            onAnyChange(b);
+            register('p', { id: 'x' });
+            expect(a).toHaveBeenCalledWith('p');
+            expect(b).toHaveBeenCalledWith('p');
+        });
+        it('unsubscribe stops further notifications', () => {
+            const cb = vi.fn();
+            const off = onAnyChange(cb);
+            off();
+            register('p', { id: 'x' });
+            expect(cb).not.toHaveBeenCalled();
+        });
+        it('double-unsubscribe is a no-op', () => {
+            const cb = vi.fn();
+            const off = onAnyChange(cb);
+            off();
+            off();
+            register('p', { id: 'x' });
+            expect(cb).not.toHaveBeenCalled();
+        });
+        it('coexists with per-point onChange (both fire)', () => {
+            const any = vi.fn();
+            const point = vi.fn();
+            onAnyChange(any);
+            onChange('p', point);
+            register('p', { id: 'x' });
+            expect(any).toHaveBeenCalledWith('p');
+            expect(point).toHaveBeenCalledTimes(1);
+        });
+    });
 });

package/dist/contributions/types.d.ts

@@ -21,4 +21,13 @@ export interface ContributionsApi {
      * shard deactivate.
      */
     onChange(pointId: string, cb: () => void): () => void;
+    /**
+     * Subscribe to register/unregister at every contribution point. The
+     * callback receives the `pointId` so consumers can rebuild incrementally.
+     * Returns an unsubscribe; auto-unsubscribed on shard deactivate.
+     *
+     * Diagnostic-class shards (sh3-ai, sh3-diagnostic) use this to keep a
+     * live "everything wired" picture without polling `listPoints`.
+     */
+    onAnyChange(cb: (pointId: string) => void): () => void;
 }

package/dist/runtime/index.d.ts

@@ -0,0 +1,2 @@
+export { runVerbProgrammatic } from './runVerb';
+export type { RunVerbOpts, RunVerbResult } from './runVerb';

package/dist/runtime/index.js

@@ -0,0 +1 @@
+export { runVerbProgrammatic } from './runVerb';

package/dist/runtime/runVerb.d.ts

@@ -0,0 +1,10 @@
+import { type ScrollbackEntry } from '../shell-shard/scrollback.svelte';
+export interface RunVerbOpts {
+    signal?: AbortSignal;
+    structured?: unknown;
+}
+export interface RunVerbResult {
+    result: unknown;
+    scrollback: ScrollbackEntry[];
+}
+export declare function runVerbProgrammatic(shardId: string, name: string, args: string[], opts?: RunVerbOpts): Promise<RunVerbResult>;

package/dist/runtime/runVerb.js

@@ -0,0 +1,97 @@
+/*
+ * runVerbProgrammatic — programmatic verb dispatch with synthesized VerbContext.
+ *
+ * Used by `ctx.runVerb(...)` (see shards/activate.svelte.ts). Builds a
+ * sink scrollback that captures entries into an array, a headless ShellApi
+ * (no terminal-bound state), a stub SessionClient, and a real TenantFsClient.
+ * Verbs that opt in via `programmatic: true` run against this synthesized
+ * context; non-programmatic verbs are rejected.
+ *
+ * Inner `ctx.dispatch(line)` re-enters this function. The inner call
+ * shares the same captured scrollback so the outer caller sees a flat
+ * transcript; the inner result is discarded (matches terminal `dispatch`
+ * fire-and-forget semantics).
+ *
+ * Resolution: prefixed names (`'sh3-store:install'`) look up directly;
+ * unprefixed shell names (`'apps'`) resolve against shardId 'shell'.
+ */
+import { activeShards } from '../shards/activate.svelte';
+import { getVerb, listVerbsWithShard } from '../shards/registry';
+import { makeShellApiHeadless } from '../shell-shard/shellApi';
+import { Scrollback } from '../shell-shard/scrollback.svelte';
+import { SessionClient } from '../shell-shard/session-client.svelte';
+import { TenantFsClient } from '../shell-shard/tenant-fs-client';
+function resolveVerbForDispatch(name) {
+    const verb = getVerb(name);
+    if (!verb)
+        return null;
+    const entries = listVerbsWithShard();
+    const match = entries.find((e) => e.verb === verb);
+    return match ? { verb: match.verb, shardId: match.shardId } : null;
+}
+export async function runVerbProgrammatic(shardId, name, args, opts) {
+    if (!activeShards.has(shardId)) {
+        throw new Error(`unknown shard: ${shardId}`);
+    }
+    const verb = getVerb(name);
+    if (!verb) {
+        throw new Error(`unknown verb: ${name}`);
+    }
+    if (!verb.programmatic) {
+        throw new Error(`verb "${name}" is not programmatic`);
+    }
+    const captured = [];
+    const sinkScrollback = makeSinkScrollback(captured);
+    const ctx = await buildProgrammaticContext({
+        sinkScrollback,
+        captured,
+        opts,
+    });
+    const result = await verb.run(ctx, args);
+    return { result, scrollback: captured };
+}
+async function buildProgrammaticContext(b) {
+    var _a, _b;
+    const ctx = {
+        shell: makeShellApiHeadless(),
+        scrollback: b.sinkScrollback,
+        session: makeStubSession(),
+        cwd: '/',
+        fs: new TenantFsClient(),
+        async dispatch(line) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                return;
+            const space = trimmed.indexOf(' ');
+            const head = space === -1 ? trimmed : trimmed.slice(0, space);
+            const rest = space === -1 ? '' : trimmed.slice(space + 1);
+            const parts = rest.length ? rest.split(/\s+/) : [];
+            const resolved = resolveVerbForDispatch(head);
+            if (!resolved) {
+                throw new Error(`dispatch: unknown verb "${head}"`);
+            }
+            const innerCtx = Object.assign(Object.assign({}, ctx), { structuredArgs: undefined });
+            await resolved.verb.run(innerCtx, parts);
+        },
+        structuredArgs: (_a = b.opts) === null || _a === void 0 ? void 0 : _a.structured,
+        signal: (_b = b.opts) === null || _b === void 0 ? void 0 : _b.signal,
+    };
+    return ctx;
+}
+function makeSinkScrollback(captured) {
+    let nextId = 0;
+    const sink = {
+        entries: captured,
+        push(entry) {
+            const withId = Object.assign(Object.assign({}, entry), { id: `runverb-${++nextId}` });
+            captured.push(withId);
+        },
+        clear() {
+            captured.length = 0;
+        },
+    };
+    return sink;
+}
+function makeStubSession() {
+    return new SessionClient('');
+}

package/dist/runtime/runVerb.test.d.ts

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

package/dist/runtime/runVerb.test.js

@@ -0,0 +1,132 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { MemoryDocumentBackend } from '../documents/backends';
+import { __setDocumentBackend, __setTenantId } from '../documents/config';
+import { registerShard, activateShard, __resetShardRegistryForTest, } from '../shards/activate.svelte';
+import { __resetViewRegistryForTest } from '../shards/registry';
+import { runVerbProgrammatic } from './runVerb';
+function makeVerb(name, programmatic, body = async () => undefined) {
+    return {
+        name,
+        summary: `stub ${name}`,
+        programmatic: programmatic || undefined,
+        async run(ctx, args) {
+            await body(ctx, args);
+        },
+    };
+}
+describe('runVerbProgrammatic', () => {
+    beforeEach(() => {
+        __resetShardRegistryForTest();
+        __resetViewRegistryForTest();
+        __setDocumentBackend(new MemoryDocumentBackend());
+        __setTenantId('tenant-test');
+    });
+    it('rejects on unknown shard', async () => {
+        await expect(runVerbProgrammatic('missing', 'echo', [])).rejects.toThrow('unknown shard: missing');
+    });
+    it('rejects on unknown verb', async () => {
+        registerShard({
+            manifest: { id: 'tester', label: 'T', version: '0.0.0', views: [] },
+            activate(ctx) {
+                ctx.registerVerb(makeVerb('echo', true));
+            },
+        });
+        await activateShard('tester');
+        await expect(runVerbProgrammatic('tester', 'tester:missing', [])).rejects.toThrow(/unknown verb/);
+    });
+    it('rejects when verb is not programmatic', async () => {
+        registerShard({
+            manifest: { id: 'tester', label: 'T', version: '0.0.0', views: [] },
+            activate(ctx) {
+                ctx.registerVerb(makeVerb('plain', false));
+            },
+        });
+        await activateShard('tester');
+        await expect(runVerbProgrammatic('tester', 'tester:plain', [])).rejects.toThrow('verb "tester:plain" is not programmatic');
+    });
+    it('invokes a programmatic verb and resolves with { result, scrollback }', async () => {
+        registerShard({
+            manifest: { id: 'tester', label: 'T', version: '0.0.0', views: [] },
+            activate(ctx) {
+                ctx.registerVerb(makeVerb('echo', true, async (vctx, args) => {
+                    vctx.scrollback.push({
+                        kind: 'status',
+                        text: `echo ${args.join(' ')}`,
+                        level: 'info',
+                        ts: 0,
+                    });
+                }));
+            },
+        });
+        await activateShard('tester');
+        const out = await runVerbProgrammatic('tester', 'tester:echo', ['hello', 'world']);
+        expect(out.scrollback).toHaveLength(1);
+        expect(out.scrollback[0]).toMatchObject({
+            kind: 'status',
+            text: 'echo hello world',
+            level: 'info',
+        });
+    });
+    it('populates ctx.structuredArgs when opts.structured is set', async () => {
+        let observed = undefined;
+        registerShard({
+            manifest: { id: 'tester', label: 'T', version: '0.0.0', views: [] },
+            activate(ctx) {
+                ctx.registerVerb(makeVerb('capture', true, async (vctx) => {
+                    observed = vctx.structuredArgs;
+                }));
+            },
+        });
+        await activateShard('tester');
+        await runVerbProgrammatic('tester', 'tester:capture', [], { structured: { foo: 42 } });
+        expect(observed).toEqual({ foo: 42 });
+    });
+    it('plumbs opts.signal onto ctx.signal', async () => {
+        let received;
+        registerShard({
+            manifest: { id: 'tester', label: 'T', version: '0.0.0', views: [] },
+            activate(ctx) {
+                ctx.registerVerb(makeVerb('peek', true, async (vctx) => {
+                    received = vctx.signal;
+                }));
+            },
+        });
+        await activateShard('tester');
+        const ac = new AbortController();
+        await runVerbProgrammatic('tester', 'tester:peek', [], { signal: ac.signal });
+        expect(received).toBe(ac.signal);
+    });
+    it('inner dispatch re-enters runVerb and merges scrollback into the outer capture', async () => {
+        registerShard({
+            manifest: { id: 'tester', label: 'T', version: '0.0.0', views: [] },
+            activate(ctx) {
+                ctx.registerVerb(makeVerb('inner', true, async (vctx) => {
+                    vctx.scrollback.push({ kind: 'status', text: 'inner-fired', level: 'info', ts: 0 });
+                }));
+                ctx.registerVerb(makeVerb('outer', true, async (vctx) => {
+                    vctx.scrollback.push({ kind: 'status', text: 'outer-before', level: 'info', ts: 0 });
+                    await vctx.dispatch('tester:inner');
+                    vctx.scrollback.push({ kind: 'status', text: 'outer-after', level: 'info', ts: 0 });
+                }));
+            },
+        });
+        await activateShard('tester');
+        const out = await runVerbProgrammatic('tester', 'tester:outer', []);
+        const texts = out.scrollback
+            .filter((e) => e.kind === 'status')
+            .map((e) => e.text);
+        expect(texts).toEqual(['outer-before', 'inner-fired', 'outer-after']);
+    });
+    it('propagates an error thrown by the verb', async () => {
+        registerShard({
+            manifest: { id: 'tester', label: 'T', version: '0.0.0', views: [] },
+            activate(ctx) {
+                ctx.registerVerb(makeVerb('boom', true, async () => {
+                    throw new Error('kaboom');
+                }));
+            },
+        });
+        await activateShard('tester');
+        await expect(runVerbProgrammatic('tester', 'tester:boom', [])).rejects.toThrow('kaboom');
+    });
+});

package/dist/shards/activate-contributions.test.js

@@ -107,4 +107,35 @@ describe('ctx.contributions', () => {
         // Deactivate must not throw when the entry is already gone.
         expect(() => deactivateShard('p')).not.toThrow();
     });
+    it('onAnyChange fires for register/unregister at any point and auto-unsubscribes on deactivate', async () => {
+        const cb = vi.fn();
+        registerShard({
+            manifest: { id: 'watcher', label: 'W', version: '0.0.0', views: [] },
+            activate(ctx) {
+                ctx.contributions.onAnyChange(cb);
+            },
+        });
+        await activateShard('watcher');
+        registerShard({
+            manifest: { id: 'p1', label: 'P1', version: '0.0.0', views: [] },
+            activate(ctx) {
+                ctx.contributions.register('point.a', { id: 'x' });
+                ctx.contributions.register('point.b', { id: 'y' });
+            },
+        });
+        await activateShard('p1');
+        expect(cb).toHaveBeenCalledTimes(2);
+        expect(cb).toHaveBeenCalledWith('point.a');
+        expect(cb).toHaveBeenCalledWith('point.b');
+        deactivateShard('watcher');
+        cb.mockClear();
+        registerShard({
+            manifest: { id: 'p2', label: 'P2', version: '0.0.0', views: [] },
+            activate(ctx) {
+                ctx.contributions.register('point.c', { id: 'z' });
+            },
+        });
+        await activateShard('p2');
+        expect(cb).not.toHaveBeenCalled();
+    });
 });

package/dist/shards/activate-runtime.test.d.ts

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

package/dist/shards/activate-runtime.test.js

@@ -0,0 +1,179 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { MemoryDocumentBackend } from '../documents/backends';
+import { __setDocumentBackend, __setTenantId } from '../documents/config';
+import { registerShard, activateShard, __resetShardRegistryForTest, } from './activate.svelte';
+import { __resetViewRegistryForTest } from './registry';
+function programmaticVerb(name, summary, body) {
+    return {
+        name,
+        summary,
+        programmatic: true,
+        async run(vctx, args) {
+            if (body)
+                await body(vctx, args);
+        },
+    };
+}
+function plainVerb(name, summary) {
+    return { name, summary, async run() { } };
+}
+describe('ctx.listVerbs / ctx.runVerb (integration)', () => {
+    beforeEach(() => {
+        __resetShardRegistryForTest();
+        __resetViewRegistryForTest();
+        __setDocumentBackend(new MemoryDocumentBackend());
+        __setTenantId('tenant-test');
+    });
+    it('listVerbs returns every verb across active shards with shardId', async () => {
+        registerShard({
+            manifest: { id: 'host', label: 'Host', version: '0.0.0', views: [] },
+            activate(ctx) {
+                ctx.registerVerb(programmaticVerb('a', 'first verb'));
+                ctx.registerVerb(plainVerb('b', 'second verb'));
+            },
+        });
+        let consumerCtx = null;
+        registerShard({
+            manifest: { id: 'consumer', label: 'C', version: '0.0.0', views: [] },
+            activate(ctx) {
+                consumerCtx = ctx;
+            },
+        });
+        await activateShard('host');
+        await activateShard('consumer');
+        const list = consumerCtx.listVerbs();
+        const a = list.find((v) => v.name === 'host:a');
+        const b = list.find((v) => v.name === 'host:b');
+        expect(a).toEqual({ shardId: 'host', name: 'host:a', summary: 'first verb', schema: undefined });
+        expect(b).toEqual({ shardId: 'host', name: 'host:b', summary: 'second verb', schema: undefined });
+    });
+    it('runVerb dispatches a programmatic verb and returns captured scrollback', async () => {
+        registerShard({
+            manifest: { id: 'host', label: 'Host', version: '0.0.0', views: [] },
+            activate(ctx) {
+                ctx.registerVerb(programmaticVerb('echo', 'echoes args', async (vctx, args) => {
+                    vctx.scrollback.push({ kind: 'status', text: `echo: ${args.join(' ')}`, level: 'info', ts: 0 });
+                }));
+            },
+        });
+        let consumerCtx = null;
+        registerShard({
+            manifest: { id: 'consumer', label: 'C', version: '0.0.0', views: [] },
+            activate(ctx) {
+                consumerCtx = ctx;
+            },
+        });
+        await activateShard('host');
+        await activateShard('consumer');
+        const out = await consumerCtx.runVerb('host', 'host:echo', ['hello']);
+        expect(out.scrollback).toHaveLength(1);
+        expect(out.scrollback[0]).toMatchObject({ kind: 'status', text: 'echo: hello' });
+    });
+    it('runVerb rejects when the target verb is not programmatic', async () => {
+        registerShard({
+            manifest: { id: 'host', label: 'Host', version: '0.0.0', views: [] },
+            activate(ctx) {
+                ctx.registerVerb(plainVerb('plain', 'no opt-in'));
+            },
+        });
+        let consumerCtx = null;
+        registerShard({
+            manifest: { id: 'consumer', label: 'C', version: '0.0.0', views: [] },
+            activate(ctx) {
+                consumerCtx = ctx;
+            },
+        });
+        await activateShard('host');
+        await activateShard('consumer');
+        await expect(consumerCtx.runVerb('host', 'host:plain', [])).rejects.toThrow('verb "host:plain" is not programmatic');
+    });
+    it('runVerb populates ctx.structuredArgs when opts.structured is set', async () => {
+        let observed = undefined;
+        registerShard({
+            manifest: { id: 'host', label: 'Host', version: '0.0.0', views: [] },
+            activate(ctx) {
+                ctx.registerVerb(programmaticVerb('schemaCheck', 'reads structuredArgs', async (vctx) => {
+                    observed = vctx.structuredArgs;
+                }));
+            },
+        });
+        let consumerCtx = null;
+        registerShard({
+            manifest: { id: 'consumer', label: 'C', version: '0.0.0', views: [] },
+            activate(ctx) {
+                consumerCtx = ctx;
+            },
+        });
+        await activateShard('host');
+        await activateShard('consumer');
+        await consumerCtx.runVerb('host', 'host:schemaCheck', [], { structured: { foo: 'bar' } });
+        expect(observed).toEqual({ foo: 'bar' });
+    });
+    it('runVerb rejects on unknown shardId', async () => {
+        let consumerCtx = null;
+        registerShard({
+            manifest: { id: 'consumer', label: 'C', version: '0.0.0', views: [] },
+            activate(ctx) {
+                consumerCtx = ctx;
+            },
+        });
+        await activateShard('consumer');
+        await expect(consumerCtx.runVerb('missing', 'x', [])).rejects.toThrow('unknown shard: missing');
+    });
+    it('runVerb rejects on unknown verb', async () => {
+        registerShard({
+            manifest: { id: 'host', label: 'Host', version: '0.0.0', views: [] },
+            activate(ctx) {
+                ctx.registerVerb(programmaticVerb('present', 'exists'));
+            },
+        });
+        let consumerCtx = null;
+        registerShard({
+            manifest: { id: 'consumer', label: 'C', version: '0.0.0', views: [] },
+            activate(ctx) {
+                consumerCtx = ctx;
+            },
+        });
+        await activateShard('host');
+        await activateShard('consumer');
+        await expect(consumerCtx.runVerb('host', 'host:absent', [])).rejects.toThrow('unknown verb: host:absent');
+    });
+    it('verbs declaring schema.input expose it via listVerbs', async () => {
+        registerShard({
+            manifest: { id: 'host', label: 'Host', version: '0.0.0', views: [] },
+            activate(ctx) {
+                ctx.registerVerb({
+                    name: 'typed',
+                    summary: 'has schema',
+                    programmatic: true,
+                    schema: {
+                        input: {
+                            type: 'object',
+                            properties: { msg: { type: 'string', description: 'message' } },
+                            required: ['msg'],
+                        },
+                    },
+                    async run() { },
+                });
+            },
+        });
+        let consumerCtx = null;
+        registerShard({
+            manifest: { id: 'consumer', label: 'C', version: '0.0.0', views: [] },
+            activate(ctx) {
+                consumerCtx = ctx;
+            },
+        });
+        await activateShard('host');
+        await activateShard('consumer');
+        const list = consumerCtx.listVerbs();
+        const typed = list.find((v) => v.name === 'host:typed');
+        expect(typed === null || typed === void 0 ? void 0 : typed.schema).toEqual({
+            input: {
+                type: 'object',
+                properties: { msg: { type: 'string', description: 'message' } },
+                required: ['msg'],
+            },
+        });
+    });
+});