sh3-core 0.14.0 → 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/layout/LayoutRenderer.svelte

@@ -230,7 +230,7 @@
   {:else}
     {@const slot = asSlot(node)!}
     <div class="leaf-slot-wrapper">
-      <SlotContainer node={slot} />
+      <SlotContainer node={slot} meta={slot.meta} />
       <SlotDropZone {rootRef} path={path} />
     </div>
   {/if}

package/dist/layout/tree-walk.js

@@ -15,7 +15,12 @@ export function collectSlotRefs(tree) {
     const out = [];
     const walk = (node) => {
         if (node.type === 'slot') {
-            out.push({ slotId: node.slotId, viewId: node.viewId, label: node.viewId || node.slotId });
+            out.push({
+                slotId: node.slotId,
+                viewId: node.viewId,
+                label: node.viewId || node.slotId,
+                meta: node.meta,
+            });
             return;
         }
         if (node.type === 'tabs') {

package/dist/layout/types.d.ts

@@ -86,6 +86,13 @@ export interface SlotNode {
     slotId: string;
     /** View id to mount into this slot, or null for an empty slot. */
     viewId: string | null;
+    /**
+     * Caller-supplied instance data, threaded to `MountContext.meta`.
+     * Ephemeral — not serialized with the layout tree. Mirrors
+     * `TabEntry.meta` for the bare-slot case (e.g. dismissable floats whose
+     * content is a single slot rather than a TabsNode).
+     */
+    meta?: Record<string, unknown>;
 }
 /**
  * Union of all layout node kinds. The recursive tree is composed entirely of

package/dist/overlays/FloatFrame.svelte

@@ -42,14 +42,20 @@
   // stacking context — so a picker opened from inside a modal stacks above
   // that modal without writing any z-index. The Svelte component lifecycle
   // is unaffected; we're only relocating the rendered DOM node.
+  //
+  // The cleanup removes frameEl directly: Svelte's keyed-each iteration
+  // removal walks the anchor range left in FloatLayer to clear the DOM, and
+  // the portal moved frameEl out of that range — re-parenting it back to
+  // FloatLayer would orphan it (Svelte's removal pass clears the empty
+  // anchor range and misses the re-deposited frame). Effect deps are stable
+  // (frameEl, entry.id), so cleanup only fires on destroy.
   $effect(() => {
     if (!frameEl) return;
     const host = getFloatParentHost(entry.id);
     if (!host) return;
-    const original = frameEl.parentNode;
     host.appendChild(frameEl);
     return () => {
-      if (frameEl?.parentNode === host && original) original.appendChild(frameEl);
+      if (frameEl?.parentNode === host) frameEl.remove();
     };
   });
 

package/dist/overlays/float.js

@@ -86,13 +86,16 @@ function openFloat(viewId, options = {}) {
     let content;
     if (options.dismissable) {
         // Picker float: render the view directly as a leaf slot. No tab strip,
-        // no tabs wrapper, no drag-to-dock handle. Note: options.meta cannot
-        // thread through a bare SlotNode — only TabEntry carries meta.
-        content = {
+        // no tabs wrapper, no drag-to-dock handle. SlotNode.meta carries
+        // options.meta through to MountContext, mirroring TabEntry.meta.
+        const slot = {
             type: 'slot',
             slotId,
             viewId,
         };
+        if (options.meta)
+            slot.meta = options.meta;
+        content = slot;
     }
     else {
         const label = (_a = options.title) !== null && _a !== void 0 ? _a : viewId;

package/dist/overlays/float.test.js

@@ -388,6 +388,32 @@ describe('floats — F.7 anchor portals to enclosing overlay host', () => {
         const frame = container.querySelector('[role="dialog"][aria-label="NoAnchor"]');
         expect(frame).toBeTruthy();
     });
+    // Regression: Svelte's keyed-each iteration removal walks the anchor range
+    // left in FloatLayer to clear the DOM. The portal moved frameEl out of that
+    // range, so a re-parent-back-to-original cleanup orphans the empty frame
+    // in FloatLayer when the float is dismissed. Cleanup must remove frameEl
+    // directly.
+    it('removes the portaled frame on dismiss (no orphan in FloatLayer)', async () => {
+        const { container } = renderWithShell(FloatLayer, {});
+        const fakeModalHost = document.createElement('div');
+        fakeModalHost.className = 'fake-modal-host';
+        fakeModalHost.dataset.shellOverlayHost = 'modal';
+        const anchor = document.createElement('button');
+        fakeModalHost.appendChild(anchor);
+        document.body.appendChild(fakeModalHost);
+        const id = floatManager.open('test:view', {
+            dismissable: true,
+            anchor,
+            title: 'Picker',
+        });
+        await tick();
+        expect(fakeModalHost.querySelector('.sh3-float-frame')).not.toBeNull();
+        floatManager.close(id);
+        await tick();
+        const layerDiv = container.querySelector('.sh3-float-layer');
+        expect(layerDiv === null || layerDiv === void 0 ? void 0 : layerDiv.querySelector('.sh3-float-frame')).toBeNull();
+        expect(document.querySelectorAll('.sh3-float-frame').length).toBe(0);
+    });
 });
 // ---------------------------------------------------------------------------
 // F.8 — overlay host marker on FloatFrame
@@ -406,3 +432,48 @@ describe('floats — F.8 overlay host marker', () => {
         expect(frame.dataset.shellOverlayHost).toBe('float');
     });
 });
+// ---------------------------------------------------------------------------
+// F.9 — meta threading from floatManager.open into MountContext
+// ---------------------------------------------------------------------------
+import { registerView } from '../shards/registry';
+describe('floats — F.9 meta threads to MountContext', () => {
+    beforeEach(() => {
+        resetFramework();
+        bindManagerToStore();
+    });
+    it('non-dismissable: ctx.meta receives options.meta on mount', async () => {
+        let captured;
+        registerView('test:meta-view', {
+            mount(_container, ctx) {
+                captured = ctx.meta;
+                return { unmount: () => { } };
+            },
+        });
+        renderWithShell(FloatLayer, {});
+        floatManager.open('test:meta-view', { title: 'M', meta: { kind: 'tab', n: 1 } });
+        await tick();
+        // acquireSlotHost defers factory.mount via queueMicrotask — flush it.
+        await Promise.resolve();
+        await tick();
+        expect(captured).toEqual({ kind: 'tab', n: 1 });
+    });
+    it('dismissable: ctx.meta receives options.meta on mount', async () => {
+        let captured;
+        registerView('test:meta-view', {
+            mount(_container, ctx) {
+                captured = ctx.meta;
+                return { unmount: () => { } };
+            },
+        });
+        renderWithShell(FloatLayer, {});
+        floatManager.open('test:meta-view', {
+            dismissable: true,
+            title: 'P',
+            meta: { kind: 'picker', color: '#abc' },
+        });
+        await tick();
+        await Promise.resolve();
+        await tick();
+        expect(captured).toEqual({ kind: 'picker', color: '#abc' });
+    });
+});

package/dist/primitives/widgets/IconToggleGroup.svelte

@@ -78,7 +78,10 @@
     color: var(--shell-fg);
     filter: none;
   }
-  .sh3-itg__btn--active {
+  /* Selector includes `.sh3-itg button` so specificity (0,2,1) beats the
+     base `.sh3-itg button` rule (0,1,1) — otherwise `background: transparent`
+     and `color: var(--shell-fg-muted)` would shadow the accent fill. */
+  .sh3-itg button.sh3-itg__btn--active {
     background: var(--shell-accent);
     color: var(--shell-fg-on-accent);
     font-weight: 600;

package/dist/primitives/widgets/Segmented.svelte

@@ -75,7 +75,10 @@
     color: var(--shell-fg);
     filter: none;
   }
-  .sh3-seg__btn--active {
+  /* Selector includes `.sh3-seg button` so specificity (0,2,1) beats the
+     base `.sh3-seg button` rule (0,1,1) — otherwise `background: transparent`
+     and `color: var(--shell-fg-muted)` would shadow the accent fill. */
+  .sh3-seg button.sh3-seg__btn--active {
     background: var(--shell-accent);
     color: var(--shell-fg-on-accent);
     font-weight: 600;

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