sh3-core 0.14.0 → 0.15.0

package/dist/sh3core-shard/AppInfoView.svelte

@@ -0,0 +1,154 @@
+<script lang="ts">
+  /*
+   * Read-only details modal for an app, opened by the home-card `app.info`
+   * action. Pulls the manifest from listRegisteredApps() and — when the app
+   * was installed from a registry — augments it with the catalog entry
+   * (description, author) and the InstalledPackage record (source registry,
+   * install date, contract version). Built-in apps show only manifest fields.
+   */
+
+  import type { AppManifest } from '../apps/types';
+  import type { InstalledPackage, PackageEntry } from '../registry/types';
+
+  interface Props {
+    manifest: AppManifest;
+    installed: InstalledPackage | null;
+    catalogEntry: PackageEntry | null;
+    close: () => void;
+  }
+
+  let { manifest, installed, catalogEntry, close }: Props = $props();
+
+  let installedDate = $derived.by(() => {
+    if (!installed) return null;
+    const d = new Date(installed.installedAt);
+    return isNaN(d.getTime()) ? installed.installedAt : d.toLocaleString();
+  });
+</script>
+
+<div class="app-info-modal">
+  <header>
+    <h2>{manifest.label}</h2>
+    <code class="id">{manifest.id}</code>
+  </header>
+
+  <p class="version">
+    <span class="label">Version</span>
+    <code>v{manifest.version}</code>
+    {#if !installed}<span class="badge built-in">built-in</span>{/if}
+  </p>
+
+  {#if catalogEntry?.description}
+    <section class="description">
+      <span class="label">Description</span>
+      <p>{catalogEntry.description}</p>
+    </section>
+  {/if}
+
+  {#if catalogEntry?.author?.name}
+    <p class="row">
+      <span class="label">Author</span>
+      <span>{catalogEntry.author.name}</span>
+    </p>
+  {/if}
+
+  {#if manifest.requiredShards.length > 0}
+    <section class="row">
+      <span class="label">Required shards</span>
+      <ul class="chips">
+        {#each manifest.requiredShards as shard}
+          <li><code>{shard}</code></li>
+        {/each}
+      </ul>
+    </section>
+  {/if}
+
+  {#if manifest.permissions && manifest.permissions.length > 0}
+    <section class="row">
+      <span class="label">Permissions</span>
+      <ul class="chips">
+        {#each manifest.permissions as perm}
+          <li><code>{perm}</code></li>
+        {/each}
+      </ul>
+    </section>
+  {/if}
+
+  {#if installed}
+    <section class="installed">
+      <p class="row"><span class="label">Source registry</span><code>{installed.sourceRegistry}</code></p>
+      {#if installedDate}
+        <p class="row"><span class="label">Installed</span><span>{installedDate}</span></p>
+      {/if}
+      <p class="row"><span class="label">Contract</span><code>v{installed.contractVersion}</code></p>
+    </section>
+  {/if}
+
+  <div class="actions">
+    <button type="button" onclick={close}>Close</button>
+  </div>
+</div>
+
+<style>
+  .app-info-modal {
+    padding: 16px 20px;
+    min-width: 360px;
+    max-width: 520px;
+    color: var(--shell-fg);
+    background: var(--shell-bg);
+    font: inherit;
+  }
+  header { display: flex; align-items: baseline; gap: 10px; margin-bottom: 10px; }
+  header h2 { margin: 0; font-size: 16px; }
+  header .id {
+    font-size: 12px;
+    color: var(--shell-fg-muted);
+  }
+  .version { margin: 4px 0 12px; font-size: 13px; display: flex; align-items: center; gap: 8px; }
+  .description { margin: 8px 0 12px; }
+  .description p {
+    margin: 4px 0 0;
+    font-size: 13px;
+    line-height: 1.5;
+    white-space: pre-wrap;
+  }
+  .row { margin: 6px 0; font-size: 13px; display: flex; align-items: baseline; gap: 8px; flex-wrap: wrap; }
+  .label {
+    color: var(--shell-fg-muted);
+    font-size: 11px;
+    text-transform: uppercase;
+    letter-spacing: 0.04em;
+    flex: 0 0 auto;
+    min-width: 90px;
+  }
+  .chips { list-style: none; margin: 0; padding: 0; display: flex; flex-wrap: wrap; gap: 4px; }
+  .chips code {
+    padding: 1px 6px;
+    border: 1px solid var(--shell-border);
+    border-radius: var(--shell-radius-sm, 3px);
+  }
+  .badge {
+    font-size: 11px;
+    padding: 1px 6px;
+    border-radius: var(--shell-radius-sm, 3px);
+    background: var(--shell-bg-elevated);
+    color: var(--shell-fg-muted);
+    border: 1px solid var(--shell-border);
+  }
+  .installed { margin-top: 12px; padding-top: 10px; border-top: 1px solid var(--shell-border); }
+  code {
+    font-family: var(--shell-font-mono, monospace);
+    background: var(--shell-bg-elevated);
+    padding: 0 4px;
+    border-radius: var(--shell-radius-sm, 3px);
+  }
+  .actions { display: flex; gap: 8px; margin-top: 16px; justify-content: flex-end; }
+  .actions button {
+    background: var(--shell-bg-elevated);
+    color: var(--shell-fg);
+    border: 1px solid var(--shell-border);
+    border-radius: var(--shell-radius-sm, 3px);
+    padding: 6px 14px; font: inherit; cursor: pointer;
+  }
+  .actions button:hover { border-color: var(--shell-accent); }
+</style>

package/dist/sh3core-shard/AppInfoView.svelte.d.ts

@@ -0,0 +1,11 @@
+import type { AppManifest } from '../apps/types';
+import type { InstalledPackage, PackageEntry } from '../registry/types';
+interface Props {
+    manifest: AppManifest;
+    installed: InstalledPackage | null;
+    catalogEntry: PackageEntry | null;
+    close: () => void;
+}
+declare const AppInfoView: import("svelte").Component<Props, {}, "">;
+type AppInfoView = ReturnType<typeof AppInfoView>;
+export default AppInfoView;

package/dist/sh3core-shard/appActions.js

@@ -5,7 +5,8 @@
  * 'app' (see ShellHome.svelte).
  *
  * Three actions are registered here:
- *   - app.info        : info-only row showing "<id> v<version>" (always disabled).
+ *   - app.info        : open the AppInfoView modal with manifest + (when
+ *                       installed) catalog/install metadata. Always enabled.
  *   - app.checkUpdate : refresh catalog, then prompt update or toast up-to-date.
  *   - app.uninstall   : open uninstall confirm dialog.
  *
@@ -25,6 +26,7 @@ import { modalManager } from '../overlays/modal';
 import { toastManager } from '../overlays/toast';
 import AppUpdateAvailableModal from '../app/store/AppUpdateAvailableModal.svelte';
 import UninstallAppDialog from '../app/store/UninstallAppDialog.svelte';
+import AppInfoView from './AppInfoView.svelte';
 export function computeAppActionDisabled(g) {
     return !g.admin || g.builtin;
 }
@@ -50,6 +52,22 @@ function isBuiltin(appId) {
 function gateFor(appId) {
     return { admin: isAdmin(), builtin: isBuiltin(appId) };
 }
+function runShowInfo(_ctx) {
+    var _a, _b, _c;
+    const ref = readSelection();
+    if (!ref)
+        return;
+    const manifest = findApp(ref.appId);
+    if (!manifest)
+        return;
+    const installed = (_a = storeContext.state.ephemeral.installed.find((p) => p.id === ref.appId)) !== null && _a !== void 0 ? _a : null;
+    // Catalog entry only exists for apps fetched from a registry — built-in
+    // apps will fall through to null and the modal will hide registry-only
+    // fields (description, author).
+    const catalogEntry = (_c = (_b = storeContext.state.ephemeral.catalog.find((p) => p.entry.id === ref.appId)) === null || _b === void 0 ? void 0 : _b.entry) !== null && _c !== void 0 ? _c : null;
+    const props = { manifest, installed, catalogEntry };
+    modalManager.open(AppInfoView, props);
+}
 async function runCheckUpdate(_ctx) {
     var _a, _b;
     const ref = readSelection();
@@ -124,11 +142,11 @@ export function registerAppActions(ctx) {
     const infoLabel = () => {
         const ref = readSelection();
         if (!ref)
-            return '';
+            return 'Info…';
         const m = findApp(ref.appId);
         if (!m)
-            return ref.appId;
-        return `${m.id} v${m.version}`;
+            return `Info — ${ref.appId}`;
+        return `Info — ${m.label} v${m.version}`;
     };
     const updateLabel = () => {
         const ref = readSelection();
@@ -155,7 +173,7 @@ export function registerAppActions(ctx) {
             scope: { element: 'app' },
             contextItem: true,
             group: 'info',
-            disabled: true,
+            run: runShowInfo,
         },
         {
             id: 'app.checkUpdate',

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

package/dist/shards/activate.svelte.js

@@ -17,7 +17,8 @@
  *   stays in `registeredShards` — it's still known, just not running.
  */
 import { shell } from '../shellRuntime.svelte';
-import { registerView, unregisterView, registerVerb as fwRegisterVerb, unregisterVerb as fwUnregisterVerb } from './registry';
+import { registerView, unregisterView, registerVerb as fwRegisterVerb, unregisterVerb as fwUnregisterVerb, listVerbsWithShard } from './registry';
+import { runVerbProgrammatic } from '../runtime/runVerb';
 import { createDocumentHandle, getTenantId, getDocumentBackend } from '../documents';
 import { fetchEnvState, putEnvState } from '../env/client';
 import { isAdmin as checkIsAdmin } from '../auth/index';
@@ -28,7 +29,7 @@ import { createBrowseCapability } from '../documents/browse';
 import { createShardKeysApi } from '../keys/client';
 import { PERMISSION_KEYS_MINT } from '../keys/types';
 import { subscribe } from '../keys/revocation-bus.svelte';
-import { register as contributionsRegister, list as contributionsList, listPoints as contributionsListPoints, onChange as contributionsOnChange, } from '../contributions';
+import { register as contributionsRegister, list as contributionsList, listPoints as contributionsListPoints, onChange as contributionsOnChange, onAnyChange as contributionsOnAnyChange, } from '../contributions';
 import { registerAction } from '../actions/registry';
 import { makeSelectionApi, clearSelectionForShard } from '../actions/selection.svelte';
 import { openContextMenu as shellOpenContextMenu, openPalette as shellOpenPalette } from '../actions/listeners';
@@ -122,6 +123,11 @@ export async function activateShard(id, opts) {
             entry.cleanupFns.push(async () => off());
             return off;
         },
+        onAnyChange(cb) {
+            const off = contributionsOnAnyChange(cb);
+            entry.cleanupFns.push(async () => off());
+            return off;
+        },
     };
     const ctx = {
         state: (schema) => shell.state(id, schema),
@@ -131,7 +137,7 @@ export async function activateShard(id, opts) {
         },
         registerVerb: (verb) => {
             const prefixed = id === 'shell' ? verb.name : `${id}:${verb.name}`;
-            fwRegisterVerb(prefixed, Object.assign(Object.assign({}, verb), { name: prefixed }));
+            fwRegisterVerb(prefixed, Object.assign(Object.assign({}, verb), { name: prefixed }), id);
             entry.verbNames.add(prefixed);
         },
         documents: (options) => {
@@ -195,6 +201,17 @@ export async function activateShard(id, opts) {
             openContextMenu(opts) { shellOpenContextMenu(opts); },
             openPalette(opts) { shellOpenPalette(opts); },
         },
+        listVerbs() {
+            return listVerbsWithShard().map(({ verb, shardId }) => ({
+                shardId,
+                name: verb.name,
+                summary: verb.summary,
+                schema: verb.schema,
+            }));
+        },
+        runVerb(shardId, name, args, opts) {
+            return runVerbProgrammatic(shardId, name, args, opts);
+        },
     };
     entry.ctx = ctx;
     // Wire onKeyRevoked hook: subscribe to the revocation bus for this shard.

package/dist/shards/registry.d.ts

@@ -5,9 +5,19 @@ export declare function registerView(viewId: string, factory: ViewFactory): void
 export declare function getView(viewId: string): ViewFactory | undefined;
 export declare function unregisterView(viewId: string): void;
 import type { Verb } from '../verbs/types';
-export declare function registerVerb(name: string, verb: Verb): void;
+export declare function registerVerb(name: string, verb: Verb, shardId: string): void;
 export declare function getVerb(name: string): Verb | undefined;
 export declare function unregisterVerb(name: string): void;
 export declare function listVerbs(): Verb[];
+/**
+ * Like `listVerbs`, but also exposes the `shardId` each verb belongs to.
+ * Used by `ctx.listVerbs()` so callers don't have to parse the
+ * shardId-prefixed verb name. Order is undefined — callers that want
+ * sorted output sort themselves.
+ */
+export declare function listVerbsWithShard(): Array<{
+    verb: Verb;
+    shardId: string;
+}>;
 /** Test-only reset: clear the view and verb registries. */
 export declare function __resetViewRegistryForTest(): void;

package/dist/shards/registry.js

@@ -38,20 +38,32 @@ export function unregisterView(viewId) {
     views.delete(viewId);
 }
 const verbs = new Map();
-export function registerVerb(name, verb) {
+export function registerVerb(name, verb, shardId) {
     if (verbs.has(name)) {
         throw new Error(`Verb "${name}" is already registered`);
     }
-    verbs.set(name, verb);
+    verbs.set(name, { verb, shardId });
 }
 export function getVerb(name) {
-    return verbs.get(name);
+    var _a;
+    return (_a = verbs.get(name)) === null || _a === void 0 ? void 0 : _a.verb;
 }
 export function unregisterVerb(name) {
     verbs.delete(name);
 }
 export function listVerbs() {
-    return Array.from(verbs.values()).sort((a, b) => a.name.localeCompare(b.name));
+    return Array.from(verbs.values())
+        .map((entry) => entry.verb)
+        .sort((a, b) => a.name.localeCompare(b.name));
+}
+/**
+ * Like `listVerbs`, but also exposes the `shardId` each verb belongs to.
+ * Used by `ctx.listVerbs()` so callers don't have to parse the
+ * shardId-prefixed verb name. Order is undefined — callers that want
+ * sorted output sort themselves.
+ */
+export function listVerbsWithShard() {
+    return Array.from(verbs.values()).map((entry) => (Object.assign({}, entry)));
 }
 /** Test-only reset: clear the view and verb registries. */
 export function __resetViewRegistryForTest() {

package/dist/shards/registry.test.js

@@ -1,5 +1,5 @@
 import { describe, it, expect, beforeEach } from 'vitest';
-import { registerVerb, getVerb, unregisterVerb, listVerbs, } from './registry';
+import { registerVerb, getVerb, unregisterVerb, listVerbs, listVerbsWithShard, } from './registry';
 function makeStubVerb(name) {
     return { name, summary: `stub ${name}`, run: async () => { } };
 }
@@ -10,53 +10,61 @@ describe('verb registry', () => {
             unregisterVerb(name);
         registered.length = 0;
     });
-    function trackVerb(name, verb) {
-        registerVerb(name, verb);
+    function trackVerb(name, verb, shardId) {
+        registerVerb(name, verb, shardId);
         registered.push(name);
     }
     it('registers and retrieves a verb by name', () => {
         const verb = makeStubVerb('foo');
-        trackVerb('foo', verb);
+        trackVerb('foo', verb, 'shell');
         expect(getVerb('foo')).toBe(verb);
     });
     it('returns undefined for unknown verb', () => {
         expect(getVerb('nope')).toBeUndefined();
     });
     it('throws on duplicate verb name', () => {
-        trackVerb('dup', makeStubVerb('dup'));
-        expect(() => trackVerb('dup', makeStubVerb('dup'))).toThrowError('Verb "dup" is already registered');
+        trackVerb('dup', makeStubVerb('dup'), 'shell');
+        expect(() => trackVerb('dup', makeStubVerb('dup'), 'shell')).toThrowError('Verb "dup" is already registered');
     });
     it('unregisters a verb', () => {
-        trackVerb('gone', makeStubVerb('gone'));
+        trackVerb('gone', makeStubVerb('gone'), 'shell');
         unregisterVerb('gone');
         registered.pop();
         expect(getVerb('gone')).toBeUndefined();
     });
-    it('lists verbs sorted by name', () => {
-        trackVerb('zeta', makeStubVerb('zeta'));
-        trackVerb('alpha', makeStubVerb('alpha'));
-        trackVerb('mid', makeStubVerb('mid'));
+    it('lists verbs sorted by name (legacy shape)', () => {
+        trackVerb('zeta', makeStubVerb('zeta'), 'shell');
+        trackVerb('alpha', makeStubVerb('alpha'), 'shell');
+        trackVerb('mid', makeStubVerb('mid'), 'shell');
         const names = listVerbs().map((v) => v.name);
         expect(names).toEqual(['alpha', 'mid', 'zeta']);
     });
+    it('listVerbsWithShard returns shardId per entry', () => {
+        trackVerb('apps', makeStubVerb('apps'), 'shell');
+        trackVerb('sh3-store:install', makeStubVerb('sh3-store:install'), 'sh3-store');
+        const result = listVerbsWithShard();
+        const apps = result.find((e) => e.verb.name === 'apps');
+        const install = result.find((e) => e.verb.name === 'sh3-store:install');
+        expect(apps === null || apps === void 0 ? void 0 : apps.shardId).toBe('shell');
+        expect(install === null || install === void 0 ? void 0 : install.shardId).toBe('sh3-store');
+    });
     it('stores prefixed name inside verb object (mirrors activate auto-prefix)', () => {
-        // activate.svelte.ts does: { ...verb, name: prefixed }
         const original = makeStubVerb('install');
         const prefixed = Object.assign(Object.assign({}, original), { name: 'registry:install' });
-        trackVerb('registry:install', prefixed);
+        trackVerb('registry:install', prefixed, 'registry');
         const found = getVerb('registry:install');
         expect(found === null || found === void 0 ? void 0 : found.name).toBe('registry:install');
         expect(found === null || found === void 0 ? void 0 : found.summary).toBe('stub install');
     });
     it('bulk unregister simulates deactivate cleanup', () => {
-        // activate.svelte.ts tracks verbNames and unregisters on deactivate
         const names = ['registry:install', 'registry:search', 'registry:info'];
         for (const name of names)
-            trackVerb(name, makeStubVerb(name));
+            trackVerb(name, makeStubVerb(name), 'registry');
         expect(listVerbs()).toHaveLength(3);
         for (const name of names)
             unregisterVerb(name);
-        registered.length = 0; // already cleaned
+        registered.length = 0;
         expect(listVerbs()).toHaveLength(0);
+        expect(listVerbsWithShard()).toHaveLength(0);
     });
 });