sh3-core 0.16.1 → 0.17.2

package/dist/fields/dispatch.test.js

@@ -0,0 +1,175 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { __resetContributionsForTest, register, } from '../contributions/registry';
+import { listFields, getField, setField, } from './dispatch';
+import { FIELD_POINT_ID } from './types';
+function registerField(entry) {
+    return register(FIELD_POINT_ID, entry);
+}
+describe('fields dispatch', () => {
+    beforeEach(() => {
+        __resetContributionsForTest();
+    });
+    describe('listFields', () => {
+        it('returns [] when no fields are registered', () => {
+            expect(listFields()).toEqual([]);
+        });
+        it('lists imperative fields with readonly=false when set is present', () => {
+            registerField({
+                owner: { shardId: 'a' },
+                descriptor: {
+                    shape: 'imperative',
+                    fieldId: 'theme',
+                    label: 'Theme',
+                    kind: 'string',
+                    get: () => 'dark',
+                    set: () => undefined,
+                },
+            });
+            const out = listFields();
+            expect(out).toHaveLength(1);
+            expect(out[0]).toMatchObject({
+                shardId: 'a',
+                fieldId: 'theme',
+                label: 'Theme',
+                kind: 'string',
+                readonly: false,
+                source: 'contributed',
+            });
+            expect(out[0].slotId).toBeUndefined();
+            expect(out[0].element).toBeUndefined();
+        });
+        it('lists imperative fields without set as readonly=true', () => {
+            registerField({
+                owner: { shardId: 'a' },
+                descriptor: {
+                    shape: 'imperative',
+                    fieldId: 'count',
+                    label: 'Count',
+                    kind: 'integer',
+                    get: () => 7,
+                },
+            });
+            expect(listFields()[0].readonly).toBe(true);
+        });
+        it('lists readonly fields as readonly=true', () => {
+            registerField({
+                owner: { shardId: 'a' },
+                descriptor: {
+                    shape: 'readonly',
+                    fieldId: 'now',
+                    label: 'Now',
+                    kind: 'integer',
+                    get: () => Date.now(),
+                },
+            });
+            expect(listFields()[0].readonly).toBe(true);
+        });
+        it('passes the element ref through to FieldView when present', () => {
+            const fakeEl = { tagName: 'DIV' };
+            registerField({
+                owner: { shardId: 'a' },
+                descriptor: {
+                    shape: 'imperative',
+                    fieldId: 'rich',
+                    label: 'Rich',
+                    kind: 'string',
+                    get: () => 'x',
+                    element: fakeEl,
+                },
+            });
+            expect(listFields()[0].element).toBe(fakeEl);
+        });
+        it('filters by shardId', () => {
+            registerField({ owner: { shardId: 'a' }, descriptor: { shape: 'imperative', fieldId: 'x', label: 'X', kind: 'string', get: () => 1 } });
+            registerField({ owner: { shardId: 'b' }, descriptor: { shape: 'imperative', fieldId: 'y', label: 'Y', kind: 'string', get: () => 2 } });
+            expect(listFields({ shardId: 'a' }).map((f) => f.fieldId)).toEqual(['x']);
+        });
+        it('filters by slotId', () => {
+            registerField({ owner: { shardId: 'a', slotId: 's1' }, descriptor: { shape: 'imperative', fieldId: 'x', label: 'X', kind: 'string', get: () => 1 } });
+            registerField({ owner: { shardId: 'a', slotId: 's2' }, descriptor: { shape: 'imperative', fieldId: 'y', label: 'Y', kind: 'string', get: () => 2 } });
+            expect(listFields({ slotId: 's1' }).map((f) => f.fieldId)).toEqual(['x']);
+        });
+        it('filters by kind', () => {
+            registerField({ owner: { shardId: 'a' }, descriptor: { shape: 'imperative', fieldId: 'n', label: 'N', kind: 'number', get: () => 1 } });
+            registerField({ owner: { shardId: 'a' }, descriptor: { shape: 'imperative', fieldId: 's', label: 'S', kind: 'string', get: () => 'a' } });
+            expect(listFields({ kind: 'number' }).map((f) => f.fieldId)).toEqual(['n']);
+        });
+    });
+    describe('getField', () => {
+        it('throws on unknown address', () => {
+            expect(() => getField({ shardId: 'a', fieldId: 'x' })).toThrow(/unknown field/);
+        });
+        it('returns the imperative descriptor get() value', () => {
+            registerField({
+                owner: { shardId: 'a' },
+                descriptor: {
+                    shape: 'imperative', fieldId: 'x', label: 'X', kind: 'string', get: () => 'hello',
+                },
+            });
+            expect(getField({ shardId: 'a', fieldId: 'x' })).toBe('hello');
+        });
+        it('returns readonly descriptor get() value', () => {
+            registerField({
+                owner: { shardId: 'a' },
+                descriptor: {
+                    shape: 'readonly', fieldId: 'r', label: 'R', kind: 'integer', get: () => 42,
+                },
+            });
+            expect(getField({ shardId: 'a', fieldId: 'r' })).toBe(42);
+        });
+        it('matches on slot-scoped addresses', () => {
+            registerField({
+                owner: { shardId: 'a', slotId: 's1' },
+                descriptor: {
+                    shape: 'imperative', fieldId: 'x', label: 'X', kind: 'string', get: () => 'slot',
+                },
+            });
+            expect(getField({ shardId: 'a', slotId: 's1', fieldId: 'x' })).toBe('slot');
+        });
+    });
+    describe('setField', () => {
+        it('rejects on unknown address', async () => {
+            await expect(setField({ shardId: 'a', fieldId: 'x' }, 'v')).rejects.toThrow(/unknown field/);
+        });
+        it('rejects when imperative field has no set', async () => {
+            registerField({
+                owner: { shardId: 'a' },
+                descriptor: {
+                    shape: 'imperative', fieldId: 'x', label: 'X', kind: 'string', get: () => 'r',
+                },
+            });
+            await expect(setField({ shardId: 'a', fieldId: 'x' }, 'v')).rejects.toThrow(/read-only/);
+        });
+        it('rejects when shape is readonly', async () => {
+            registerField({
+                owner: { shardId: 'a' },
+                descriptor: {
+                    shape: 'readonly', fieldId: 'x', label: 'X', kind: 'string', get: () => 'r',
+                },
+            });
+            await expect(setField({ shardId: 'a', fieldId: 'x' }, 'v')).rejects.toThrow(/read-only/);
+        });
+        it('invokes imperative set and awaits a promise', async () => {
+            const set = vi.fn().mockResolvedValue(undefined);
+            registerField({
+                owner: { shardId: 'a' },
+                descriptor: {
+                    shape: 'imperative', fieldId: 'x', label: 'X', kind: 'string',
+                    get: () => 'r', set,
+                },
+            });
+            await setField({ shardId: 'a', fieldId: 'x' }, 'v');
+            expect(set).toHaveBeenCalledWith('v');
+        });
+        it('propagates errors from the set callback', async () => {
+            registerField({
+                owner: { shardId: 'a' },
+                descriptor: {
+                    shape: 'imperative', fieldId: 'x', label: 'X', kind: 'string',
+                    get: () => 'r', set: () => { throw new Error('boom'); },
+                },
+            });
+            await expect(setField({ shardId: 'a', fieldId: 'x' }, 'v')).rejects.toThrow('boom');
+        });
+    });
+});

package/dist/fields/types.d.ts

@@ -0,0 +1,101 @@
+export type FieldKind = 'string' | 'number' | 'integer' | 'boolean' | 'enum' | 'json';
+export interface FieldBase {
+    /** Stable, unique within the (shardId, slotId?) tuple. */
+    fieldId: string;
+    /** Human-readable label; passed to AI tool descriptions and debug UIs. */
+    label: string;
+    kind: FieldKind;
+    /** Optional one-line description (passed to AI tool callers). */
+    description?: string;
+    /** For kind: 'enum' — the allowed values. */
+    enumValues?: readonly unknown[];
+}
+export interface ImperativeFieldDescriptor extends FieldBase {
+    shape: 'imperative';
+    get(): unknown;
+    /** Omit to make the field read-only. */
+    set?: (value: unknown) => void | Promise<void>;
+    /** Optional value-change subscription. Caller passes a value-snapshot cb. */
+    onChange?: (cb: (value: unknown) => void) => () => void;
+    /**
+     * Optional visual locator. Set when the field has a DOM presence even
+     * though I/O goes through callbacks (contenteditable rich-text editors,
+     * ARIA-roled custom widgets, custom elements). The framework NEVER writes
+     * to this element directly — exposed only to visual decorators and to
+     * FieldView.element for highlighting / anchoring overlays.
+     */
+    element?: HTMLElement;
+}
+export interface ElementRefFieldDescriptor extends FieldBase {
+    shape: 'element';
+    /** Framework reads/writes .value and dispatches 'input' + 'change'. */
+    element: HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement;
+}
+export interface ReadonlyFieldDescriptor extends FieldBase {
+    shape: 'readonly';
+    get(): unknown;
+    /** Optional visual locator (same semantics as ImperativeFieldDescriptor.element). */
+    element?: HTMLElement;
+}
+export type ControllableFieldDescriptor = ImperativeFieldDescriptor | ElementRefFieldDescriptor | ReadonlyFieldDescriptor;
+/**
+ * Address tuple for ctx.sh3.fields.get/set. shardId 'sh3.walker' identifies
+ * walker-produced fields. slotId is present iff the field is slot-scoped or
+ * walker-produced.
+ */
+export interface FieldAddress {
+    shardId: string;
+    slotId?: string;
+    fieldId: string;
+}
+/**
+ * Read-shape returned by ctx.sh3.fields.list() / walk(). Intentionally omits
+ * I/O handlers (get/set/onChange) so the gating chokepoint at
+ * ctx.sh3.fields.get/set works. Direct DOM access via `element` is fine —
+ * any shard could already do document.querySelector.
+ */
+export interface FieldView {
+    shardId: string;
+    slotId?: string;
+    fieldId: string;
+    label: string;
+    kind: FieldKind;
+    description?: string;
+    enumValues?: readonly unknown[];
+    readonly: boolean;
+    source: 'contributed' | 'walker';
+    element?: HTMLElement;
+}
+/**
+ * Returned (or constructed) by an attachDecoration factory.
+ * - element:       the consumer's content; mounted into the SH3 overlay layer.
+ * - update?(rect): called when the field's bounding rect changes.
+ * - dispose?():    called at decoration teardown (field unregister or explicit dispose).
+ */
+export interface DecorationHandle {
+    element: HTMLElement;
+    update?(rect: DOMRect): void;
+    dispose?(): void;
+}
+/**
+ * The Sh3Api.fields surface. See packages/sh3-core/src/fields/dispatch.ts and
+ * packages/sh3-core/src/fields/decoration.ts for implementations.
+ */
+export interface FieldsApi {
+    list(opts?: {
+        slotId?: string;
+        shardId?: string;
+        walker?: 'off' | 'fallback' | 'always';
+        kind?: FieldKind;
+    }): FieldView[];
+    get(addr: FieldAddress): unknown;
+    set(addr: FieldAddress, value: unknown): Promise<void>;
+    walk(slotId: string): FieldView[];
+    onChange(cb: () => void): () => void;
+    attachDecoration(addr: FieldAddress, factory: (target: {
+        element: HTMLElement;
+        rect: DOMRect;
+    }) => HTMLElement | DecorationHandle): () => void;
+}
+export declare const FIELD_POINT_ID = "sh3.controllable-field";
+export declare const WALKER_SHARD_ID = "sh3.walker";

package/dist/fields/types.js

@@ -0,0 +1,16 @@
+/*
+ * Controllable-field type definitions.
+ *
+ * Fields are stored as contributions under pointId 'sh3.controllable-field'.
+ * Three registration shapes:
+ *   - 'imperative': caller-supplied get/set callbacks; optional element ref
+ *                   for visual locator (contenteditable / ARIA / custom widget).
+ *   - 'element':    framework drives an HTMLInputElement / HTMLTextAreaElement /
+ *                   HTMLSelectElement directly (.value + dispatched events).
+ *   - 'readonly':   caller-supplied get only; optional element ref.
+ *
+ * `Sh3Api.fields` exposes the read+invoke surface; FieldView is the
+ * read-shape returned by list() / walk().
+ */
+export const FIELD_POINT_ID = 'sh3.controllable-field';
+export const WALKER_SHARD_ID = 'sh3.walker';

package/dist/fields/walker.svelte.test.d.ts

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

package/dist/fields/walker.svelte.test.js

@@ -0,0 +1,138 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { __resetContributionsForTest, register, } from '../contributions/registry';
+import { walkSlotContainer, listFields } from './dispatch';
+import { FIELD_POINT_ID } from './types';
+function makeContainer(html) {
+    const c = document.createElement('div');
+    c.innerHTML = html;
+    document.body.appendChild(c);
+    return c;
+}
+describe('field walker', () => {
+    beforeEach(() => {
+        __resetContributionsForTest();
+        document.body.innerHTML = '';
+    });
+    it('returns [] for an empty container', () => {
+        const c = makeContainer('');
+        expect(walkSlotContainer('s1', c)).toEqual([]);
+    });
+    it('matches native input, textarea, select', () => {
+        const c = makeContainer(`
+      <input name="title" />
+      <textarea name="body"></textarea>
+      <select name="color"><option value="red">Red</option><option value="blue">Blue</option></select>
+    `);
+        const out = walkSlotContainer('s1', c);
+        expect(out.map((f) => f.fieldId).sort()).toEqual(['body', 'color', 'title']);
+    });
+    it('skips submit/button/reset/file/hidden inputs', () => {
+        const c = makeContainer(`
+      <input type="submit" name="x" />
+      <input type="button" name="y" />
+      <input type="reset" name="z" />
+      <input type="file" name="f" />
+      <input type="hidden" name="h" />
+      <input type="text" name="ok" />
+    `);
+        expect(walkSlotContainer('s1', c).map((f) => f.fieldId)).toEqual(['ok']);
+    });
+    it('matches [data-sh3-field] elements', () => {
+        const c = makeContainer(`<div data-sh3-field="custom">x</div>`);
+        expect(walkSlotContainer('s1', c).map((f) => f.fieldId)).toEqual(['custom']);
+    });
+    it('infers kind from input type', () => {
+        const c = makeContainer(`
+      <input type="number" name="n" />
+      <input type="checkbox" name="b" />
+      <input type="text" name="s" />
+    `);
+        const byId = Object.fromEntries(walkSlotContainer('s1', c).map((f) => [f.fieldId, f.kind]));
+        expect(byId).toEqual({ n: 'number', b: 'boolean', s: 'string' });
+    });
+    it('infers enum from select options', () => {
+        const c = makeContainer(`
+      <select name="c"><option value="red">Red</option><option value="blue">Blue</option></select>
+    `);
+        const out = walkSlotContainer('s1', c);
+        expect(out[0].kind).toBe('enum');
+        expect(out[0].enumValues).toEqual(['red', 'blue']);
+    });
+    it('id strategy: data-sh3-field > name > id > label > placeholder > field-N', () => {
+        const c = makeContainer(`
+      <input data-sh3-field="data-id" />
+      <input name="name-id" />
+      <input id="dom-id" />
+      <label for="lbl">My Label</label><input id="lbl" />
+      <input placeholder="The Hint" />
+      <input />
+    `);
+        const ids = walkSlotContainer('s1', c).map((f) => f.fieldId);
+        expect(ids).toContain('data-id');
+        expect(ids).toContain('name-id');
+        expect(ids).toContain('dom-id');
+        expect(ids).toContain('my-label');
+        expect(ids).toContain('the-hint');
+        expect(ids.some((i) => /^field-\d+$/.test(i))).toBe(true);
+    });
+    it('walker fields use shardId "sh3.walker" and slotId of the call', () => {
+        const c = makeContainer(`<input name="x" />`);
+        const out = walkSlotContainer('slotABC', c);
+        expect(out[0]).toMatchObject({
+            shardId: 'sh3.walker',
+            slotId: 'slotABC',
+            source: 'walker',
+        });
+    });
+    it('exposes the matched element on FieldView.element', () => {
+        const c = makeContainer(`<input name="x" />`);
+        const input = c.querySelector('input');
+        expect(walkSlotContainer('s1', c)[0].element).toBe(input);
+    });
+    it('writeElement on a native input dispatches input + change', async () => {
+        const { writeElement } = await import('./dispatch');
+        const input = document.createElement('input');
+        input.type = 'text';
+        document.body.appendChild(input);
+        let inputCount = 0, changeCount = 0;
+        input.addEventListener('input', () => inputCount++);
+        input.addEventListener('change', () => changeCount++);
+        writeElement(input, 'hello');
+        expect(input.value).toBe('hello');
+        expect(inputCount).toBe(1);
+        expect(changeCount).toBe(1);
+    });
+    it('writeElement on a checkbox toggles .checked', async () => {
+        const { writeElement } = await import('./dispatch');
+        const input = document.createElement('input');
+        input.type = 'checkbox';
+        document.body.appendChild(input);
+        writeElement(input, true);
+        expect(input.checked).toBe(true);
+        writeElement(input, false);
+        expect(input.checked).toBe(false);
+    });
+    describe('listFields walker integration', () => {
+        it('walker: "off" (default) ignores walker', () => {
+            makeContainer(`<input name="x" />`);
+            expect(listFields({ slotId: 's1' })).toEqual([]);
+        });
+        it('walker: "always" appends walker fields when a container is registered', () => {
+            const c = makeContainer(`<input name="x" />`);
+            expect(walkSlotContainer('s1', c)[0].fieldId).toBe('x');
+        });
+        it('walker dedup: skips elements already covered by an element-ref contribution', () => {
+            const c = makeContainer(`<input name="x" /><input name="y" />`);
+            const xInput = c.querySelector('input[name="x"]');
+            register(FIELD_POINT_ID, {
+                owner: { shardId: 'tester', slotId: 's1' },
+                descriptor: {
+                    shape: 'element', fieldId: 'titled-x', label: 'Titled X', kind: 'string', element: xInput,
+                },
+            });
+            const out = walkSlotContainer('s1', c);
+            const ids = out.map((f) => f.fieldId);
+            expect(ids).toEqual(['y']);
+        });
+    });
+});

package/dist/handheld.browser.test.d.ts

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

package/dist/handheld.browser.test.js

@@ -0,0 +1,90 @@
+/*
+ * Handheld flip e2e — verifies slot survival across viewport flips
+ * using the real browser's re-parent semantics + slot host pool.
+ *
+ * The proof rides on slot id stability: if the same slot id is requested
+ * by both the docked LayoutRenderer (desktop) and the compact-mode
+ * DrawerSurface, the host pool keeps the host alive across the swap and
+ * the same DOM element is reused. We stamp a unique data attribute on
+ * the mounted view DOM, flip viewport classes, and assert the same
+ * element is still findable after each flip.
+ */
+import { describe, it, expect, beforeEach } from 'vitest';
+import { tick } from 'svelte';
+import { resetFramework } from './__test__/reset';
+import { renderWithShell } from './__test__/render';
+import { registerApp } from './apps/registry.svelte';
+import { launchApp } from './apps/lifecycle';
+import { registerView } from './shards/registry';
+import { makeApp, makeAppManifest } from './__test__/fixtures';
+import { sh3 } from './sh3Runtime.svelte';
+import Sh3 from './Sh3.svelte';
+function settle(ms = 50) {
+    return new Promise((r) => setTimeout(r, ms));
+}
+function cleanupDOM() {
+    document.querySelectorAll('.sh3-sh3-host').forEach((h) => h.remove());
+}
+describe('handheld viewport flip e2e', () => {
+    beforeEach(() => {
+        cleanupDOM();
+        resetFramework();
+        sh3.viewport.override(null);
+    });
+    it('viewport override flips chrome and body branches', async () => {
+        // Stable per-mount stamp so we can recognise the same DOM element.
+        let stampedEl = null;
+        registerView('test:body', {
+            mount: (el) => {
+                el.dataset.testStamp = 'body-' + Math.random().toString(36).slice(2);
+                stampedEl = el;
+                return { unmount: () => { } };
+            },
+        });
+        registerView('test:sb', {
+            mount: (el) => {
+                el.dataset.testStamp = 'sb-' + Math.random().toString(36).slice(2);
+                return { unmount: () => { } };
+            },
+        });
+        registerApp(makeApp({
+            manifest: makeAppManifest({ id: 'flip-app', label: 'Flip' }),
+            initialLayout: {
+                type: 'split', direction: 'horizontal', sizes: [0.3, 0.7],
+                children: [
+                    { type: 'slot', slotId: 'sb', viewId: 'test:sb', role: 'sidebar' },
+                    { type: 'slot', slotId: 'body', viewId: 'test:body', role: 'body' },
+                ],
+            },
+        }));
+        // Pin desktop before mounting so the gate's first render is desktop.
+        sh3.viewport.override('desktop');
+        renderWithShell(Sh3, {});
+        await launchApp('flip-app');
+        await tick();
+        await settle();
+        expect(document.querySelector('[data-sh3-region="tabbar"]')).not.toBeNull();
+        expect(document.querySelector('[data-sh3-region="compact-chrome"]')).toBeNull();
+        expect(stampedEl).not.toBeNull();
+        const initialStamp = stampedEl.dataset.testStamp;
+        // Flip to compact.
+        sh3.viewport.override('compact');
+        await tick();
+        await settle();
+        expect(document.querySelector('[data-sh3-region="compact-chrome"]')).not.toBeNull();
+        expect(document.querySelector('[data-sh3-region="tabbar"]')).toBeNull();
+        expect(document.querySelector('[data-sh3-region="compact-body"]')).not.toBeNull();
+        // Body slot host survived the swap — query the test stamp.
+        const survivors = document.querySelectorAll('[data-test-stamp]');
+        const compactStamps = Array.from(survivors).map((el) => el.dataset.testStamp);
+        expect(compactStamps).toContain(initialStamp);
+        // Flip back to desktop.
+        sh3.viewport.override('desktop');
+        await tick();
+        await settle();
+        expect(document.querySelector('[data-sh3-region="tabbar"]')).not.toBeNull();
+        const finalStamps = Array.from(document.querySelectorAll('[data-test-stamp]')).map((el) => el.dataset.testStamp);
+        // Slot was not remounted across two flips — original stamp survives.
+        expect(finalStamps).toContain(initialStamp);
+    });
+});

package/dist/host.js

@@ -39,6 +39,7 @@ import { returnToHome } from './apps/lifecycle';
 export { __setBackend };
 export { setLocalOwner };
 export { __setActiveScope, __setTenantId, __setDocumentBackend } from './documents/config';
+import { getActiveScopeId } from './documents/config';
 export function registerShard(shard) {
     registerShardInternal(shard);
 }
@@ -66,7 +67,6 @@ export async function bootstrap(config) {
         // Per ADR-002 amendment, app workspace state is keyed by (scopeId, appId).
         // Rewrite legacy unkeyed entries to the personal scope namespace.
         const { migrateLegacyWorkspaceKeys } = await import('./apps/workspace-rekey');
-        const { getActiveScopeId } = await import('./documents/config');
         migrateLegacyWorkspaceKeys(getActiveScopeId());
     }
     const exShards = new Set(config === null || config === void 0 ? void 0 : config.excludeShards);
@@ -143,8 +143,33 @@ export async function bootstrapSatellite(config) {
     }
     // 3. Load any packages installed in a previous session from IndexedDB
     await loadInstalledPackages();
-    // 4. Activate exactly the requested shards.
+    // 4. Autostart sweep — mirror host bootstrap. Every shard with an
+    //    `autostart` hook runs in satellites too: services (LLM providers),
+    //    ambient action hosts (`__sh3core__` provides the command palette
+    //    via `sh3.palette.open`), and any user-installed self-starter.
+    //    `addAutostartShard` keeps action scoping consistent with the host
+    //    so palette/global actions remain ambient inside `'app'` scope.
+    const autostartActivated = new Set();
+    for (const [id, shard] of registeredShards) {
+        if (shard.autostart) {
+            addAutostartShard(id);
+            try {
+                await activateShard(id, { phase: 'autostart' });
+                autostartActivated.add(id);
+            }
+            catch (_a) {
+                // Already logged + recorded in erroredShards by activateShard.
+                // One bad self-starting shard must not prevent the satellite from booting.
+            }
+        }
+    }
+    // 5. Activate explicit satellite shards (those carried by activateShards
+    //    in the payload — typically view-providing shards walked from the
+    //    layout). Skip ids already activated by the autostart sweep so the
+    //    diagnostic phase stays correct and we do no redundant work.
     for (const id of config.activateShardIds) {
+        if (autostartActivated.has(id))
+            continue;
         if (registeredShards.has(id)) {
             try {
                 await activateShard(id, { phase: 'satellite' });

package/dist/host.svelte.test.d.ts

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