sh3-core 0.16.0 → 0.17.0

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/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 {};

package/dist/host.svelte.test.js

@@ -0,0 +1,92 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { resetFramework } from './__test__/reset';
+import { makeShard, makeShardManifest } from './__test__/fixtures';
+import { bootstrapSatellite } from './host';
+import { registerShard, activeShards, erroredShards, } from './shards/activate.svelte';
+import { getLiveDispatcherState } from './actions/state.svelte';
+import { listActions } from './actions/registry';
+// loadInstalledPackages reads IndexedDB; neutralize it so the satellite
+// boot path can run in happy-dom without a real storage backend.
+vi.mock('./registry/installer', async (orig) => {
+    const real = await orig();
+    return Object.assign(Object.assign({}, real), { loadInstalledPackages: vi.fn(async () => { }) });
+});
+describe('bootstrapSatellite — autostart sweep', () => {
+    beforeEach(resetFramework);
+    it('activates a registered autostart shard even when not in activateShardIds', async () => {
+        const activate = vi.fn();
+        const autostart = vi.fn();
+        const svc = makeShard({
+            manifest: makeShardManifest({ id: 'svc-llm' }),
+            activate,
+            autostart,
+        });
+        registerShard(svc);
+        await bootstrapSatellite({ activateShardIds: [] });
+        expect(activate).toHaveBeenCalledTimes(1);
+        expect(autostart).toHaveBeenCalledTimes(1);
+        expect(activeShards.has('svc-llm')).toBe(true);
+    });
+    it('adds every activated autostart shard to the dispatcher autostart set', async () => {
+        const svc = makeShard({
+            manifest: makeShardManifest({ id: 'svc-llm' }),
+            autostart: () => { },
+        });
+        registerShard(svc);
+        await bootstrapSatellite({ activateShardIds: [] });
+        expect(getLiveDispatcherState().autostartShards.has('svc-llm')).toBe(true);
+    });
+    it('records a throwing autostart shard with phase "autostart" and continues activating the rest', async () => {
+        var _a;
+        const goodActivate = vi.fn();
+        const bad = makeShard({
+            manifest: makeShardManifest({ id: 'svc-bad' }),
+            activate: () => {
+                throw new Error('boom');
+            },
+            autostart: () => { },
+        });
+        const good = makeShard({
+            manifest: makeShardManifest({ id: 'svc-good' }),
+            activate: goodActivate,
+            autostart: () => { },
+        });
+        registerShard(bad);
+        registerShard(good);
+        await bootstrapSatellite({ activateShardIds: [] });
+        expect((_a = erroredShards.get('svc-bad')) === null || _a === void 0 ? void 0 : _a.phase).toBe('autostart');
+        expect(activeShards.has('svc-bad')).toBe(false);
+        expect(goodActivate).toHaveBeenCalledTimes(1);
+        expect(activeShards.has('svc-good')).toBe(true);
+    });
+    it('dedupes — an autostart shard listed in activateShardIds activates exactly once', async () => {
+        const activate = vi.fn();
+        const svc = makeShard({
+            manifest: makeShardManifest({ id: 'svc-llm' }),
+            activate,
+            autostart: () => { },
+        });
+        registerShard(svc);
+        await bootstrapSatellite({ activateShardIds: ['svc-llm'] });
+        expect(activate).toHaveBeenCalledTimes(1);
+    });
+    it('registers sh3.palette.open after bootstrapSatellite completes (palette reachable)', async () => {
+        await bootstrapSatellite({ activateShardIds: [] });
+        const ids = listActions().map((entry) => entry.action.id);
+        expect(ids).toContain('sh3.palette.open');
+    });
+    it('still activates non-autostart shards passed in activateShardIds with phase "satellite"', async () => {
+        var _a;
+        const activate = vi.fn(() => {
+            throw new Error('explicit-fail');
+        });
+        const view = makeShard({
+            manifest: makeShardManifest({ id: 'view-only' }),
+            activate,
+        });
+        registerShard(view);
+        await bootstrapSatellite({ activateShardIds: ['view-only'] });
+        expect(activate).toHaveBeenCalledTimes(1);
+        expect((_a = erroredShards.get('view-only')) === null || _a === void 0 ? void 0 : _a.phase).toBe('satellite');
+    });
+});

package/dist/layout/slotHostPool.svelte.d.ts

@@ -23,6 +23,14 @@ export declare function releaseSlotHost(slotId: string, fromWrapper?: HTMLElemen
  * by HMR boundaries and tests; not part of normal runtime flow.
  */
 export declare function resetSlotHostPool(): void;
+/**
+ * Read-only peek at a pooled host. Returns the live entry without
+ * affecting refcounts. Used by Sh3Api.fields.walk and friends.
+ */
+export declare function peekSlotHost(slotId: string): {
+    host: HTMLElement;
+    refcount: number;
+} | undefined;
 /**
  * Read the current ViewHandle for a slot. Returns undefined if the slot
  * is not in the pool or hasn't finished mounting yet. Used by the close

package/dist/layout/slotHostPool.svelte.js

@@ -36,6 +36,7 @@ import { getView, __addViewRegistrationListener } from '../shards/registry';
 import { locateSlotIn } from './ops';
 import { activeLayout } from './store.svelte';
 import { scopeToString } from '../actions/scope-helpers';
+import { __disposeSlotContributions } from '../contributions';
 const pool = new Map();
 const pendingDestroy = new Set();
 /**
@@ -284,6 +285,7 @@ export function releaseSlotHost(slotId, fromWrapper) {
         if (!current || current.refcount > 0)
             return; // re-acquired, keep
         (_a = current.resizeObserver) === null || _a === void 0 ? void 0 : _a.disconnect();
+        __disposeSlotContributions(slotId);
         (_b = current.handle) === null || _b === void 0 ? void 0 : _b.unmount();
         current.cancelPendingMount();
         current.host.remove();
@@ -299,8 +301,9 @@ export function releaseSlotHost(slotId, fromWrapper) {
 export function resetSlotHostPool() {
     var _a, _b;
     pendingDestroy.clear();
-    for (const entry of pool.values()) {
+    for (const [slotId, entry] of pool.entries()) {
         (_a = entry.resizeObserver) === null || _a === void 0 ? void 0 : _a.disconnect();
+        __disposeSlotContributions(slotId);
         (_b = entry.handle) === null || _b === void 0 ? void 0 : _b.unmount();
         entry.cancelPendingMount();
         entry.host.remove();
@@ -312,6 +315,16 @@ export function resetSlotHostPool() {
         delete closableState[key];
     handleOverrides.clear();
 }
+/**
+ * Read-only peek at a pooled host. Returns the live entry without
+ * affecting refcounts. Used by Sh3Api.fields.walk and friends.
+ */
+export function peekSlotHost(slotId) {
+    const entry = pool.get(slotId);
+    if (!entry)
+        return undefined;
+    return { host: entry.host, refcount: entry.refcount };
+}
 /**
  * Read the current ViewHandle for a slot. Returns undefined if the slot
  * is not in the pool or hasn't finished mounting yet. Used by the close