sh3-core 0.22.0 → 0.22.2

package/dist/shards/activate-fields.svelte.test.js

@@ -1,121 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { registerShard, activateShard, __resetShardRegistryForTest, } from './activate.svelte';
-import { __resetViewRegistryForTest } from './registry';
-import { __resetContributionsForTest } from '../contributions/registry';
-import { __resetDecorationLayerForTest } from '../fields/decoration';
-const makeShard = (overrides) => (Object.assign({ activate: () => { } }, overrides));
-describe('ctx.sh3.fields integration', () => {
-    beforeEach(() => {
-        __resetShardRegistryForTest();
-        __resetViewRegistryForTest();
-        __resetContributionsForTest();
-        __resetDecorationLayerForTest();
-        document.body.innerHTML = '';
-    });
-    it('shard-scoped field is visible to a consumer via ctx.sh3.fields.list', async () => {
-        let value = 'dark';
-        registerShard(makeShard({
-            manifest: { id: 'producer', label: 'P', version: '0.0.0', views: [] },
-            activate(ctx) {
-                ctx.contributions.register('sh3.controllable-field', {
-                    shape: 'imperative',
-                    fieldId: 'theme',
-                    label: 'Theme',
-                    kind: 'enum',
-                    enumValues: ['light', 'dark'],
-                    get: () => value,
-                    set: (v) => { value = v; },
-                });
-            },
-        }));
-        let consumerCtx = null;
-        registerShard(makeShard({
-            manifest: { id: 'consumer', label: 'C', version: '0.0.0', views: [] },
-            activate(ctx) { consumerCtx = ctx; },
-        }));
-        await activateShard('producer');
-        await activateShard('consumer');
-        const list = consumerCtx.sh3.fields.list();
-        expect(list).toHaveLength(1);
-        expect(list[0]).toMatchObject({
-            shardId: 'producer',
-            fieldId: 'theme',
-            kind: 'enum',
-            readonly: false,
-            source: 'contributed',
-        });
-        expect(consumerCtx.sh3.fields.get({ shardId: 'producer', fieldId: 'theme' })).toBe('dark');
-        await consumerCtx.sh3.fields.set({ shardId: 'producer', fieldId: 'theme' }, 'light');
-        expect(value).toBe('light');
-    });
-    it('contenteditable-style imperative+element pattern works end-to-end (set, decorate, unmount)', async () => {
-        const editorEl = document.createElement('div');
-        editorEl.contentEditable = 'true';
-        editorEl.textContent = 'initial';
-        document.body.appendChild(editorEl);
-        editorEl.getBoundingClientRect = () => ({ x: 5, y: 5, width: 100, height: 50, top: 5, left: 5, right: 105, bottom: 55 });
-        const set = vi.fn().mockImplementation((v) => { editorEl.textContent = String(v); });
-        registerShard(makeShard({
-            manifest: { id: 'producer', label: 'P', version: '0.0.0', views: [] },
-            activate(ctx) {
-                ctx.contributions.register('sh3.controllable-field', {
-                    shape: 'imperative',
-                    fieldId: 'body',
-                    label: 'Body',
-                    kind: 'string',
-                    get: () => { var _a; return (_a = editorEl.textContent) !== null && _a !== void 0 ? _a : ''; },
-                    set,
-                    element: editorEl,
-                });
-            },
-        }));
-        let consumerCtx = null;
-        registerShard(makeShard({
-            manifest: { id: 'consumer', label: 'C', version: '0.0.0', views: [] },
-            activate(ctx) { consumerCtx = ctx; },
-        }));
-        await activateShard('producer');
-        await activateShard('consumer');
-        await consumerCtx.sh3.fields.set({ shardId: 'producer', fieldId: 'body' }, 'hello');
-        expect(set).toHaveBeenCalledWith('hello');
-        expect(editorEl.textContent).toBe('hello');
-        const off = consumerCtx.sh3.fields.attachDecoration({ shardId: 'producer', fieldId: 'body' }, () => {
-            const badge = document.createElement('span');
-            badge.dataset.kind = 'sh3-ai-badge';
-            return badge;
-        });
-        expect(document.querySelector('[data-kind="sh3-ai-badge"]')).not.toBeNull();
-        off();
-        expect(document.querySelector('[data-kind="sh3-ai-badge"]')).toBeNull();
-    });
-    it('listFields filters by shardId', async () => {
-        registerShard(makeShard({
-            manifest: { id: 'a', label: 'A', version: '0.0.0', views: [] },
-            activate(ctx) {
-                ctx.contributions.register('sh3.controllable-field', {
-                    shape: 'imperative', fieldId: 'x', label: 'X', kind: 'string',
-                    get: () => '1',
-                });
-            },
-        }));
-        registerShard(makeShard({
-            manifest: { id: 'b', label: 'B', version: '0.0.0', views: [] },
-            activate(ctx) {
-                ctx.contributions.register('sh3.controllable-field', {
-                    shape: 'imperative', fieldId: 'y', label: 'Y', kind: 'string',
-                    get: () => '2',
-                });
-            },
-        }));
-        let consumerCtx = null;
-        registerShard(makeShard({
-            manifest: { id: 'c', label: 'C', version: '0.0.0', views: [] },
-            activate(ctx) { consumerCtx = ctx; },
-        }));
-        await activateShard('a');
-        await activateShard('b');
-        await activateShard('c');
-        expect(consumerCtx.sh3.fields.list({ shardId: 'a' }).map((f) => f.fieldId)).toEqual(['x']);
-        expect(consumerCtx.sh3.fields.list({ shardId: 'b' }).map((f) => f.fieldId)).toEqual(['y']);
-    });
-});

package/dist/shards/activate-on-key-revoked.test.d.ts

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

package/dist/shards/activate-on-key-revoked.test.js

@@ -1,60 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import { MemoryDocumentBackend } from '../documents/backends';
-import { __setDocumentBackend, __setActiveScope } from '../documents/config';
-import { registerShard, activateShard, deactivateShard, __resetShardRegistryForTest } from './activate.svelte';
-import { emit } from '../keys/revocation-bus.svelte';
-describe('onKeyRevoked hook wiring', () => {
-    beforeEach(() => {
-        __resetShardRegistryForTest();
-        __setDocumentBackend(new MemoryDocumentBackend());
-        __setActiveScope('tenant-a');
-    });
-    it('fires onKeyRevoked when the bus emits for the shard', async () => {
-        const received = [];
-        registerShard({
-            manifest: { id: 'hook-shard', label: 'h', version: '0.0.0', views: [] },
-            activate() { },
-            onKeyRevoked(id) { received.push(id); },
-        });
-        await activateShard('hook-shard');
-        emit('hook-shard', 'key-abc');
-        // Handler is async; give microtasks a chance to flush.
-        await Promise.resolve();
-        expect(received).toEqual(['key-abc']);
-    });
-    it('does not fire for a different shardId', async () => {
-        const received = [];
-        registerShard({
-            manifest: { id: 'shard-x', label: 'x', version: '0.0.0', views: [] },
-            activate() { },
-            onKeyRevoked(id) { received.push(id); },
-        });
-        await activateShard('shard-x');
-        emit('shard-y', 'key-other');
-        await Promise.resolve();
-        expect(received).toHaveLength(0);
-    });
-    it('does not fire after deactivation', async () => {
-        const received = [];
-        registerShard({
-            manifest: { id: 'shard-deact', label: 'd', version: '0.0.0', views: [] },
-            activate() { },
-            onKeyRevoked(id) { received.push(id); },
-        });
-        await activateShard('shard-deact');
-        deactivateShard('shard-deact');
-        emit('shard-deact', 'key-gone');
-        await Promise.resolve();
-        expect(received).toHaveLength(0);
-    });
-    it('does not subscribe when onKeyRevoked is absent', async () => {
-        // Should not throw — just silently skips subscribing.
-        registerShard({
-            manifest: { id: 'no-hook', label: 'n', version: '0.0.0', views: [] },
-            activate() { },
-        });
-        await expect(activateShard('no-hook')).resolves.toBeUndefined();
-        // Emitting for a shard with no listener is a no-op.
-        expect(() => emit('no-hook', 'k')).not.toThrow();
-    });
-});

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

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

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

@@ -1,344 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { MemoryDocumentBackend } from '../documents/backends';
-import { __setDocumentBackend, __setActiveScope } 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());
-        __setActiveScope('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.sh3.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', programmatic: true, schema: undefined });
-        expect(b).toEqual({ shardId: 'host', name: 'host:b', summary: 'second verb', programmatic: undefined, schema: undefined });
-    });
-    it('listVerbs({ programmaticOnly: true }) returns only verbs that opted in', 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.sh3.listVerbs({ programmaticOnly: true });
-        expect(list.find((v) => v.name === 'host:a')).toBeDefined();
-        expect(list.find((v) => v.name === 'host:b')).toBeUndefined();
-        expect(list.every((v) => v.programmatic === true)).toBe(true);
-    });
-    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.sh3.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.sh3.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.sh3.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.sh3.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.sh3.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.sh3.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'],
-            },
-        });
-    });
-    it('verbNamespace overrides the shard-id prefix', async () => {
-        registerShard({
-            manifest: {
-                id: 'sh3-dirt-viewer',
-                label: 'Dirt',
-                version: '0.0.0',
-                views: [],
-                verbNamespace: 'dirt',
-            },
-            activate(ctx) {
-                ctx.registerVerb(plainVerb('publish', 'publish runtime'));
-            },
-        });
-        let consumerCtx = null;
-        registerShard({
-            manifest: { id: 'consumer', label: 'C', version: '0.0.0', views: [] },
-            activate(ctx) { consumerCtx = ctx; },
-        });
-        await activateShard('sh3-dirt-viewer');
-        await activateShard('consumer');
-        const names = consumerCtx.sh3.listVerbs().map((v) => v.name);
-        expect(names).toContain('dirt:publish');
-        expect(names.find((n) => n.startsWith('sh3-dirt-viewer:'))).toBeUndefined();
-    });
-    it('verbNamespace collision across shards: first wins, second warns', async () => {
-        var _a;
-        registerShard({
-            manifest: {
-                id: 'shard-a',
-                label: 'A',
-                version: '0.0.0',
-                views: [],
-                verbNamespace: 'shared',
-            },
-            activate(ctx) {
-                ctx.registerVerb(plainVerb('go', 'A go'));
-            },
-        });
-        registerShard({
-            manifest: {
-                id: 'shard-b',
-                label: 'B',
-                version: '0.0.0',
-                views: [],
-                verbNamespace: 'shared',
-            },
-            activate(ctx) {
-                // Collides with shard-a's 'shared:go'; should be skipped.
-                ctx.registerVerb(plainVerb('go', 'B go'));
-                // Distinct name in same namespace should still register.
-                ctx.registerVerb(plainVerb('only-b', 'B-only verb'));
-            },
-        });
-        let consumerCtx = null;
-        registerShard({
-            manifest: { id: 'consumer', label: 'C', version: '0.0.0', views: [] },
-            activate(ctx) { consumerCtx = ctx; },
-        });
-        await activateShard('shard-a');
-        const warn = vi.spyOn(console, 'warn').mockImplementation(() => { });
-        await activateShard('shard-b');
-        await activateShard('consumer');
-        expect(warn).toHaveBeenCalled();
-        expect(warn.mock.calls.some((c) => /shared:go/.test(String(c[0])))).toBe(true);
-        warn.mockRestore();
-        const list = consumerCtx.sh3.listVerbs();
-        const shared = list.find((v) => v.name === 'shared:go');
-        // The losing registration must not have been tracked; deactivating
-        // shard-b later (covered elsewhere) would otherwise remove A's verb.
-        expect(shared === null || shared === void 0 ? void 0 : shared.summary).toBe('A go');
-        expect(shared === null || shared === void 0 ? void 0 : shared.shardId).toBe('shard-a');
-        expect((_a = list.find((v) => v.name === 'shared:only-b')) === null || _a === void 0 ? void 0 : _a.shardId).toBe('shard-b');
-    });
-    it('shell shard registers bare names regardless of verbNamespace setting', async () => {
-        registerShard({
-            manifest: {
-                id: 'shell',
-                label: 'Shell',
-                version: '0.0.0',
-                views: [],
-                // Intentionally set — should be ignored for the shell shard.
-                verbNamespace: 'ignored',
-            },
-            activate(ctx) {
-                ctx.registerVerb(plainVerb('clear', 'clear scrollback'));
-            },
-        });
-        let consumerCtx = null;
-        registerShard({
-            manifest: { id: 'consumer', label: 'C', version: '0.0.0', views: [] },
-            activate(ctx) { consumerCtx = ctx; },
-        });
-        await activateShard('shell');
-        await activateShard('consumer');
-        const names = consumerCtx.sh3.listVerbs().map((v) => v.name);
-        expect(names).toContain('clear');
-        expect(names.find((n) => n.startsWith('ignored:'))).toBeUndefined();
-    });
-});
-// ─── registerContributions ────────────────────────────────────────────────────
-describe('registerContributions hook', () => {
-    beforeEach(() => {
-        __resetShardRegistryForTest();
-        __resetViewRegistryForTest();
-        __setDocumentBackend(new MemoryDocumentBackend());
-        __setActiveScope('tenant-test');
-    });
-    it('is called after activate() with the same ShardContext', async () => {
-        const order = [];
-        let activateCtx = null;
-        let registerCtx = null;
-        registerShard({
-            manifest: { id: 'rc-shard', label: 'RC', version: '0.0.0', views: [] },
-            activate(ctx) {
-                activateCtx = ctx;
-                order.push('activate');
-            },
-            registerContributions(ctx) {
-                registerCtx = ctx;
-                order.push('registerContributions');
-            },
-        });
-        await activateShard('rc-shard');
-        expect(order).toEqual(['activate', 'registerContributions']);
-        expect(registerCtx).toBe(activateCtx);
-    });
-    it('is not called when the hook is absent', async () => {
-        registerShard({
-            manifest: { id: 'no-rc', label: 'NoRC', version: '0.0.0', views: [] },
-            activate() { },
-        });
-        await expect(activateShard('no-rc')).resolves.toBeUndefined();
-    });
-    it('is not called when activate() throws', async () => {
-        const registerContributions = vi.fn();
-        registerShard({
-            manifest: { id: 'fail-rc', label: 'FailRC', version: '0.0.0', views: [] },
-            activate() { throw new Error('boom'); },
-            registerContributions,
-        });
-        await expect(activateShard('fail-rc')).rejects.toThrow('boom');
-        expect(registerContributions).not.toHaveBeenCalled();
-    });
-});

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

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

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

@@ -1,21 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import { MemoryDocumentBackend } from '../documents/backends';
-import { __setDocumentBackend, __setActiveScope } from '../documents/config';
-import { registerShard, activateShard, __resetShardRegistryForTest } from './activate.svelte';
-describe('ctx.tenantId reflects active scope', () => {
-    beforeEach(() => {
-        __resetShardRegistryForTest();
-        __setDocumentBackend(new MemoryDocumentBackend());
-        __setActiveScope('scope-a');
-    });
-    it('is present unconditionally on ctx', async () => {
-        let captured = null;
-        const shard = {
-            manifest: { id: 'test-scopeid', label: 't', version: '0.0.0', views: [] },
-            activate(ctx) { captured = ctx; },
-        };
-        registerShard(shard);
-        await activateShard('test-scopeid');
-        expect(captured.tenantId).toBe('scope-a');
-    });
-});

package/dist/shards/activate.svelte.d.ts

@@ -1,102 +0,0 @@
-import type { Shard, ShardContext } from './types';
-/**
- * Reactive registry of every shard known to the host. Keys are shard ids.
- * Populated once at boot by the glob-discovery loop in main.ts (through
- * `registerShard`); a future runtime loader appends late without touching
- * the rest of the framework. Callers that need a live list subscribe via
- * Svelte reactivity (e.g. sh3 home listing apps cross-references this
- * map to show which shards they require).
- */
-export declare const registeredShards: Map<string, Shard>;
-export declare const activeShards: Map<string, Shard>;
-/**
- * Reactive map of shard ids that failed to activate. Populated by
- * `activateShard`'s catch block; cleared when the shard is successfully
- * re-registered or activated. Read-only for shards; intended for diagnostic
- * and admin tooling that wants to surface broken shards to the user.
- */
-export interface ShardErrorEntry {
-    id: string;
-    error: unknown;
-    phase: 'autostart' | 'launch' | 'satellite';
-    timestamp: number;
-}
-export declare const erroredShards: Map<string, ShardErrorEntry>;
-/** Host-only. Register a callback that resolves whether the current scope
- *  is a personal tenant or an active project. Wired by createShell after
- *  bootstrap. Avoids circular dependencies with session-state. */
-export declare function __setScopeResolver(resolver: (() => 'tenant' | 'project') | null): void;
-/**
- * Register (or re-register) a shard with the framework so it can later be
- * activated. Records the shard in `registeredShards` but does not run
- * `activate` — that happens at app launch (or for self-starting shards).
- *
- * If a shard with the same id already exists it is silently replaced,
- * which is the expected path during package updates. If the old shard was
- * active it is deactivated first so the new version can be cleanly
- * activated on next launch.
- */
-export declare function registerShard(shard: Shard): void;
-export interface ActivateShardOpts {
-    /**
-     * Where this activation was initiated from. Determines the `phase` field
-     * recorded in `erroredShards` if activation fails. Defaults to 'launch'
-     * (the common case — required by an app being launched).
-     */
-    phase?: 'autostart' | 'launch' | 'satellite';
-}
-/**
- * Activate a registered shard. Builds a `ShardContext`, calls `shard.activate`,
- * verifies that every view declared in the manifest received a factory, then
- * calls `shard.autostart` if defined. Idempotent — calling on an already-active
- * shard is a no-op.
- *
- * If `shard.activate` throws, partial state (registered views, verbs,
- * contributions, document handles, actions, env subscription) is unwound
- * and the failure is recorded in `erroredShards` before the error is
- * re-thrown. Callers in `host.ts` (autostart loop) and `launchApp`
- * (required-shard loop) decide how to react.
- *
- * @param id - The `ShardManifest.id` of the shard to activate. Must be registered.
- * @param opts - Optional. `phase` is recorded in `erroredShards` on failure (default 'launch').
- * @throws If the shard is not registered, if `shard.activate` throws, or if a manifest view has no factory after activation.
- */
-export declare function activateShard(id: string, opts?: ActivateShardOpts): Promise<void>;
-/**
- * Deactivate an active shard. Calls `shard.deactivate`, flushes and disposes
- * all document handles, unregisters all view factories, and removes the shard
- * from `activeShards`. The shard remains in `registeredShards` and can be
- * re-activated. No-op if the shard is not currently active.
- *
- * @param id - The `ShardManifest.id` of the shard to deactivate.
- */
-export declare function deactivateShard(id: string): void;
-/**
- * Return true if the shard with the given id is currently active.
- *
- * @param id - The `ShardManifest.id` to check.
- */
-export declare function isActive(id: string): boolean;
-/**
- * Return the ShardContext for an active shard, or undefined if not active.
- * Used by lifecycle.ts to pass context to `shard.resume()`.
- */
-export declare function getShardContext(id: string): ShardContext | undefined;
-/**
- * Enumerate every view declared as `standalone` across the currently
- * active shards. Intended for the `views --standalone` verb and any
- * launcher UI that wants to surface "summonable" primitives. Only
- * pulls from `activeShards` — registered-but-inactive shards aren't
- * ready to mount.
- */
-export declare function listStandaloneViews(): Array<{
-    shardId: string;
-    viewId: string;
-    label: string;
-}>;
-/**
- * Test-only reset. Tears down any active shard entries (without running
- * deactivate hooks — tests should run deactivate explicitly if they care)
- * and clears both registered and active maps.
- */
-export declare function __resetShardRegistryForTest(): void;