sh3-core 0.21.2 → 0.22.1

package/dist/shards/activate-error-isolation.test.js

@@ -1,98 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import { MemoryDocumentBackend } from '../documents/backends';
-import { __setDocumentBackend, __setActiveScope } from '../documents/config';
-import { registerShard, activateShard, registeredShards, activeShards, __resetShardRegistryForTest, erroredShards, } from './activate.svelte';
-describe('erroredShards map', () => {
-    beforeEach(() => {
-        __resetShardRegistryForTest();
-        __setDocumentBackend(new MemoryDocumentBackend());
-        __setActiveScope('tenant-a');
-    });
-    it('is empty after reset', () => {
-        expect(erroredShards.size).toBe(0);
-    });
-    it('supports the Map read API used by callers', () => {
-        expect(typeof erroredShards.has).toBe('function');
-        expect(typeof erroredShards.get).toBe('function');
-        expect(erroredShards.has('anything')).toBe(false);
-    });
-});
-describe('activateShard — unwind on activation failure', () => {
-    beforeEach(() => {
-        __resetShardRegistryForTest();
-        __setDocumentBackend(new MemoryDocumentBackend());
-        __setActiveScope('tenant-a');
-    });
-    it('unwinds partial state and records the error when activate throws', async () => {
-        const shard = {
-            manifest: {
-                id: 'broken',
-                label: 'Broken',
-                version: '0.0.0',
-                views: [],
-            },
-            activate(ctx) {
-                ctx.registerView('broken:view', { mount: () => ({ unmount() { } }) });
-                throw new Error('dependency missing');
-            },
-        };
-        registerShard(shard);
-        await expect(activateShard('broken')).rejects.toThrow('dependency missing');
-        expect(activeShards.has('broken')).toBe(false);
-        expect(registeredShards.has('broken')).toBe(true);
-        const entry = erroredShards.get('broken');
-        expect(entry).toBeDefined();
-        expect(entry === null || entry === void 0 ? void 0 : entry.id).toBe('broken');
-        expect(entry === null || entry === void 0 ? void 0 : entry.phase).toBe('launch');
-        expect(entry === null || entry === void 0 ? void 0 : entry.error).toBeInstanceOf(Error);
-        expect(typeof (entry === null || entry === void 0 ? void 0 : entry.timestamp)).toBe('number');
-        const { getView } = await import('./registry');
-        expect(getView('broken:view')).toBeUndefined();
-    });
-    it('records phase "autostart" when called with that option', async () => {
-        var _a;
-        const shard = {
-            manifest: { id: 'broken-auto', label: 'B', version: '0.0.0', views: [] },
-            activate() {
-                throw new Error('no');
-            },
-        };
-        registerShard(shard);
-        await expect(activateShard('broken-auto', { phase: 'autostart' })).rejects.toThrow('no');
-        expect((_a = erroredShards.get('broken-auto')) === null || _a === void 0 ? void 0 : _a.phase).toBe('autostart');
-    });
-    it('clears the error entry when the shard is re-registered', async () => {
-        const broken = {
-            manifest: { id: 'reborn', label: 'R', version: '0.0.0', views: [] },
-            activate() {
-                throw new Error('first try');
-            },
-        };
-        registerShard(broken);
-        await expect(activateShard('reborn')).rejects.toThrow('first try');
-        expect(erroredShards.has('reborn')).toBe(true);
-        const fixed = {
-            manifest: { id: 'reborn', label: 'R', version: '0.0.1', views: [] },
-            activate() { },
-        };
-        registerShard(fixed);
-        expect(erroredShards.has('reborn')).toBe(false);
-    });
-    it('clears the error entry when activation eventually succeeds', async () => {
-        let shouldFail = true;
-        const shard = {
-            manifest: { id: 'flaky', label: 'F', version: '0.0.0', views: [] },
-            activate() {
-                if (shouldFail)
-                    throw new Error('first try');
-            },
-        };
-        registerShard(shard);
-        await expect(activateShard('flaky')).rejects.toThrow('first try');
-        expect(erroredShards.has('flaky')).toBe(true);
-        shouldFail = false;
-        await activateShard('flaky');
-        expect(erroredShards.has('flaky')).toBe(false);
-        expect(activeShards.has('flaky')).toBe(true);
-    });
-});

package/dist/shards/activate-fields.svelte.test.d.ts

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

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,299 +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();
-    });
-});

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