sh3-core 0.16.0 → 0.17.0

package/dist/sh3Api/headless.js

@@ -8,6 +8,10 @@
  *
  * Mode-related methods (`setMode`, `listModes`) stub to false / [];
  * Terminal.svelte wraps this with mode-aware closures.
+ *
+ * Caller identity (callerKind, callerShardId?) is plumbed through but not
+ * yet consulted — it exists so a future permission gate can be a one-liner
+ * inside this factory without changing the public Sh3Api type.
  */
 import { listRegisteredApps, getActiveApp } from '../apps/registry.svelte';
 import { launchApp } from '../apps/lifecycle';
@@ -16,6 +20,17 @@ import { inspectActiveLayout, focusView, closeTab, popoutView, dockFloat, dockIn
 import { floatManager } from '../overlays/float';
 import { getUser, isAdmin } from '../auth/index';
 import { makeDispatchToTerminal } from '../shell-shard/dispatch-to-terminal';
+import { listVerbsWithShard } from '../shards/registry';
+import { listActionsFromEntries } from '../actions/listActive';
+import { listActions as listActionEntriesFromRegistry } from '../actions/registry';
+import { dispatchActionProgrammatic } from '../actions/listeners';
+import { getLiveDispatcherState } from '../actions/state.svelte';
+import { runVerbProgrammatic } from '../runtime/runVerb';
+import { peekSlotHost } from '../layout/slotHostPool.svelte';
+import { listFields as listFieldsImpl, getField as getFieldImpl, setField as setFieldImpl, walkSlotContainer, writeElement, } from '../fields/dispatch';
+import { attachDecoration as attachDecorationImpl } from '../fields/decoration';
+import { onChange as onContributionsChange } from '../contributions';
+import { FIELD_POINT_ID, WALKER_SHARD_ID } from '../fields/types';
 const KNOWN_ZONES = ['ephemeral', 'session', 'workspace', 'user'];
 function collectTabEntries(node) {
     if (node.type === 'tabs') {
@@ -29,7 +44,123 @@ function collectTabEntries(node) {
     }
     return [];
 }
-export function makeSh3ApiHeadless(zones) {
+export function makeSh3Api(opts) {
+    // Caller identity is plumbed but not yet used by any gate. The arg exists
+    // so future gates can be one-liners inside this factory.
+    void (opts === null || opts === void 0 ? void 0 : opts.callerKind);
+    void (opts === null || opts === void 0 ? void 0 : opts.callerShardId);
+    const zones = opts === null || opts === void 0 ? void 0 : opts.zones;
+    function listViewsImpl() {
+        try {
+            const { root } = inspectActiveLayout();
+            return collectTabEntries(root.docked).map((t) => {
+                var _a;
+                return ({
+                    slotId: t.slotId,
+                    viewId: (_a = t.viewId) !== null && _a !== void 0 ? _a : '',
+                    label: t.label,
+                });
+            });
+        }
+        catch (_a) {
+            return [];
+        }
+    }
+    function resolveWalkerField(addr) {
+        if (!addr.slotId) {
+            throw new Error(`walker field requires slotId: ${addr.shardId}::::${addr.fieldId}`);
+        }
+        const host = peekSlotHost(addr.slotId);
+        if (!(host === null || host === void 0 ? void 0 : host.host)) {
+            throw new Error(`unknown field: ${addr.shardId}::${addr.slotId}::${addr.fieldId}`);
+        }
+        const found = walkSlotContainer(addr.slotId, host.host)
+            .find((f) => f.fieldId === addr.fieldId);
+        if (!found || !found.element) {
+            throw new Error(`unknown field: ${addr.shardId}::${addr.slotId}::${addr.fieldId}`);
+        }
+        return found;
+    }
+    function readWalkerField(addr) {
+        var _a;
+        const field = resolveWalkerField(addr);
+        const el = field.element;
+        if (el instanceof HTMLInputElement && el.type === 'checkbox')
+            return el.checked;
+        if (el instanceof HTMLInputElement ||
+            el instanceof HTMLTextAreaElement ||
+            el instanceof HTMLSelectElement) {
+            return el.value;
+        }
+        // [data-sh3-field] custom element — text content is the closest analogue.
+        return (_a = el.textContent) !== null && _a !== void 0 ? _a : '';
+    }
+    function writeWalkerField(addr, value) {
+        const field = resolveWalkerField(addr);
+        const el = field.element;
+        if (el instanceof HTMLInputElement ||
+            el instanceof HTMLTextAreaElement ||
+            el instanceof HTMLSelectElement) {
+            writeElement(el, value);
+            return;
+        }
+        throw new Error(`walker field "${addr.fieldId}" is a [data-sh3-field] custom element; ` +
+            `the framework cannot write into it. Use an explicit imperative registration with set().`);
+    }
+    const fields = {
+        list(listOpts) {
+            var _a;
+            const all = listFieldsImpl({
+                slotId: listOpts === null || listOpts === void 0 ? void 0 : listOpts.slotId,
+                shardId: listOpts === null || listOpts === void 0 ? void 0 : listOpts.shardId,
+                kind: listOpts === null || listOpts === void 0 ? void 0 : listOpts.kind,
+            });
+            const walkerMode = (_a = listOpts === null || listOpts === void 0 ? void 0 : listOpts.walker) !== null && _a !== void 0 ? _a : 'off';
+            if (walkerMode === 'off')
+                return all;
+            const targetSlots = (listOpts === null || listOpts === void 0 ? void 0 : listOpts.slotId)
+                ? [listOpts.slotId]
+                : Array.from(new Set(all.map((f) => f.slotId).filter((s) => !!s)));
+            let result = all;
+            for (const sid of targetSlots) {
+                const host = peekSlotHost(sid);
+                if (!(host === null || host === void 0 ? void 0 : host.host))
+                    continue;
+                const slotHasContributions = all.some((f) => f.slotId === sid);
+                if (walkerMode === 'fallback' && slotHasContributions)
+                    continue;
+                result = result.concat(walkSlotContainer(sid, host.host));
+            }
+            if (listOpts === null || listOpts === void 0 ? void 0 : listOpts.kind)
+                result = result.filter((f) => f.kind === listOpts.kind);
+            return result;
+        },
+        get(addr) {
+            if (addr.shardId === WALKER_SHARD_ID) {
+                return readWalkerField(addr);
+            }
+            return getFieldImpl(addr);
+        },
+        async set(addr, value) {
+            if (addr.shardId === WALKER_SHARD_ID) {
+                writeWalkerField(addr, value);
+                return;
+            }
+            return setFieldImpl(addr, value);
+        },
+        walk(slotId) {
+            const host = peekSlotHost(slotId);
+            if (!(host === null || host === void 0 ? void 0 : host.host))
+                throw new Error(`unknown slot: ${slotId}`);
+            return walkSlotContainer(slotId, host.host);
+        },
+        onChange(cb) {
+            return onContributionsChange(FIELD_POINT_ID, cb);
+        },
+        attachDecoration(addr, factory) {
+            return attachDecorationImpl(addr, factory);
+        },
+    };
     return {
         listApps() {
             return listRegisteredApps().map((m) => ({ id: m.id, label: m.label }));
@@ -49,20 +180,7 @@ export function makeSh3ApiHeadless(zones) {
             }));
         },
         listViewsInCurrentLayout() {
-            try {
-                const { root } = inspectActiveLayout();
-                return collectTabEntries(root.docked).map((t) => {
-                    var _a;
-                    return ({
-                        slotId: t.slotId,
-                        viewId: (_a = t.viewId) !== null && _a !== void 0 ? _a : '',
-                        label: t.label,
-                    });
-                });
-            }
-            catch (_a) {
-                return [];
-            }
+            return listViewsImpl();
         },
         openViewInCurrentLayout(viewId) {
             try {
@@ -166,8 +284,37 @@ export function makeSh3ApiHeadless(zones) {
         listModes() { return []; },
         getMode() { return { id: 'sh3', label: 'sh3' }; },
         dispatchToTerminal: makeDispatchToTerminal({ headless: true }),
+        listVerbs(verbOpts) {
+            const programmaticOnly = (verbOpts === null || verbOpts === void 0 ? void 0 : verbOpts.programmaticOnly) === true;
+            const out = listVerbsWithShard().map(({ verb, shardId }) => ({
+                shardId,
+                name: verb.name,
+                summary: verb.summary,
+                programmatic: verb.programmatic,
+                schema: verb.schema,
+            }));
+            return programmaticOnly ? out.filter((v) => v.programmatic === true) : out;
+        },
+        async runVerb(shardId, name, args, runOpts) {
+            return runVerbProgrammatic(shardId, name, args, runOpts);
+        },
+        listActions(actionOpts) {
+            const all = listActionsFromEntries(listActionEntriesFromRegistry(), getLiveDispatcherState());
+            return (actionOpts === null || actionOpts === void 0 ? void 0 : actionOpts.activeOnly) ? all.filter((a) => a.active) : all;
+        },
+        runAction(id, runOpts) {
+            return dispatchActionProgrammatic(id, runOpts);
+        },
+        listViews() {
+            return listViewsImpl();
+        },
+        fields,
     };
 }
+/** @deprecated Renamed to makeSh3Api(opts?). Kept for one minor cycle. */
+export function makeSh3ApiHeadless(zones) {
+    return makeSh3Api({ callerKind: 'verb', zones });
+}
 export function makeSh3ApiForTest() {
-    return makeSh3ApiHeadless();
+    return makeSh3Api({ callerKind: 'verb' });
 }

package/dist/sh3Api/headless.svelte.test.js

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { makeSh3ApiHeadless } from './headless';
+import { makeSh3Api } from './headless';
 function makeMockZoneManager() {
     const data = {
         ephemeral: {},
@@ -16,44 +16,44 @@ function makeMockZoneManager() {
 }
 describe('sh3Api listZones', () => {
     it('returns empty when no ZoneManager provided (stub mode)', () => {
-        const api = makeSh3ApiHeadless();
+        const api = makeSh3Api({ callerKind: 'verb' });
         expect(api.listZones()).toEqual([]);
     });
     it('returns one row per shard with the zones it has data in', () => {
         var _a, _b;
-        const api = makeSh3ApiHeadless(makeMockZoneManager());
+        const api = makeSh3Api({ callerKind: 'verb', zones: makeMockZoneManager() });
         const rows = api.listZones();
         const byShard = new Map(rows.map((r) => [r.shardId, r.zones]));
         expect((_a = byShard.get('shard-a')) === null || _a === void 0 ? void 0 : _a.sort()).toEqual(['session', 'workspace']);
         expect((_b = byShard.get('shard-b')) === null || _b === void 0 ? void 0 : _b.sort()).toEqual(['user', 'workspace']);
     });
     it('filters by shardId when provided', () => {
-        const api = makeSh3ApiHeadless(makeMockZoneManager());
+        const api = makeSh3Api({ callerKind: 'verb', zones: makeMockZoneManager() });
         const rows = api.listZones('shard-a');
         expect(rows).toHaveLength(1);
         expect(rows[0].shardId).toBe('shard-a');
         expect(rows[0].zones.sort()).toEqual(['session', 'workspace']);
     });
     it('returns empty array for unknown shardId', () => {
-        const api = makeSh3ApiHeadless(makeMockZoneManager());
+        const api = makeSh3Api({ callerKind: 'verb', zones: makeMockZoneManager() });
         expect(api.listZones('not-a-shard')).toEqual([]);
     });
 });
 describe('sh3Api readZone', () => {
     it('returns null when no ZoneManager provided', () => {
-        const api = makeSh3ApiHeadless();
+        const api = makeSh3Api({ callerKind: 'verb' });
         expect(api.readZone('shard-a', 'workspace')).toBe(null);
     });
     it('returns peeked value via ZoneManager', () => {
-        const api = makeSh3ApiHeadless(makeMockZoneManager());
+        const api = makeSh3Api({ callerKind: 'verb', zones: makeMockZoneManager() });
         expect(api.readZone('shard-a', 'workspace')).toEqual({ bar: 2 });
     });
     it('returns null for unknown zone name', () => {
-        const api = makeSh3ApiHeadless(makeMockZoneManager());
+        const api = makeSh3Api({ callerKind: 'verb', zones: makeMockZoneManager() });
         expect(api.readZone('shard-a', 'bogus')).toBe(null);
     });
     it('returns null for missing shard entry', () => {
-        const api = makeSh3ApiHeadless(makeMockZoneManager());
+        const api = makeSh3Api({ callerKind: 'verb', zones: makeMockZoneManager() });
         expect(api.readZone('not-a-shard', 'workspace')).toBe(null);
     });
 });

package/dist/sh3core-shard/sh3coreShard.svelte.js

@@ -33,6 +33,7 @@ import { resetActivePresetToDefault } from '../layout/store.svelte';
 import { modalManager } from '../overlays/modal';
 import { floatManager } from '../overlays/float';
 import { registerAppActions } from './appActions';
+import { openPalette } from '../actions/listeners';
 /**
  * Build the palette-only float-maximize toggle action. Targets the topmost
  * float (last entry in `floatManager.list()`); disabled when no floats are
@@ -79,8 +80,7 @@ export const sh3coreShard = {
             contextItem: false,
             paletteItem: false,
             run(_dispatchCtx) {
-                // Lazy import to avoid circular module load at boot.
-                import('../actions/listeners').then(({ openPalette }) => openPalette());
+                openPalette();
             },
         });
         ctx.actions.register(buildToggleMaximizeAction());

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

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

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

@@ -0,0 +1,121 @@
+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-runtime.test.js

@@ -41,7 +41,7 @@ describe('ctx.listVerbs / ctx.runVerb (integration)', () => {
         });
         await activateShard('host');
         await activateShard('consumer');
-        const list = consumerCtx.listVerbs();
+        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 });
@@ -64,7 +64,7 @@ describe('ctx.listVerbs / ctx.runVerb (integration)', () => {
         });
         await activateShard('host');
         await activateShard('consumer');
-        const list = consumerCtx.listVerbs({ programmaticOnly: true });
+        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);
@@ -87,7 +87,7 @@ describe('ctx.listVerbs / ctx.runVerb (integration)', () => {
         });
         await activateShard('host');
         await activateShard('consumer');
-        const out = await consumerCtx.runVerb('host', 'host:echo', ['hello']);
+        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' });
     });
@@ -107,7 +107,7 @@ describe('ctx.listVerbs / ctx.runVerb (integration)', () => {
         });
         await activateShard('host');
         await activateShard('consumer');
-        await expect(consumerCtx.runVerb('host', 'host:plain', [])).rejects.toThrow('verb "host:plain" is not programmatic');
+        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;
@@ -128,7 +128,7 @@ describe('ctx.listVerbs / ctx.runVerb (integration)', () => {
         });
         await activateShard('host');
         await activateShard('consumer');
-        await consumerCtx.runVerb('host', 'host:schemaCheck', [], { structured: { foo: 'bar' } });
+        await consumerCtx.sh3.runVerb('host', 'host:schemaCheck', [], { structured: { foo: 'bar' } });
         expect(observed).toEqual({ foo: 'bar' });
     });
     it('runVerb rejects on unknown shardId', async () => {
@@ -140,7 +140,7 @@ describe('ctx.listVerbs / ctx.runVerb (integration)', () => {
             },
         });
         await activateShard('consumer');
-        await expect(consumerCtx.runVerb('missing', 'x', [])).rejects.toThrow('unknown shard: missing');
+        await expect(consumerCtx.sh3.runVerb('missing', 'x', [])).rejects.toThrow('unknown shard: missing');
     });
     it('runVerb rejects on unknown verb', async () => {
         registerShard({
@@ -158,7 +158,7 @@ describe('ctx.listVerbs / ctx.runVerb (integration)', () => {
         });
         await activateShard('host');
         await activateShard('consumer');
-        await expect(consumerCtx.runVerb('host', 'host:absent', [])).rejects.toThrow('unknown verb: host:absent');
+        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({
@@ -188,7 +188,7 @@ describe('ctx.listVerbs / ctx.runVerb (integration)', () => {
         });
         await activateShard('host');
         await activateShard('consumer');
-        const list = consumerCtx.listVerbs();
+        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: {

package/dist/shards/activate.svelte.js

@@ -17,8 +17,8 @@
  *   stays in `registeredShards` — it's still known, just not running.
  */
 import { sh3 } from '../sh3Runtime.svelte';
-import { registerView, unregisterView, registerVerb as fwRegisterVerb, unregisterVerb as fwUnregisterVerb, listVerbsWithShard } from './registry';
-import { runVerbProgrammatic } from '../runtime/runVerb';
+import { registerView, unregisterView, registerVerb as fwRegisterVerb, unregisterVerb as fwUnregisterVerb } from './registry';
+import { makeSh3Api } from '../sh3Api/headless';
 import { createDocumentHandle, getTenantId, getDocumentBackend } from '../documents';
 import { fetchEnvState, putEnvState } from '../env/client';
 import { isAdmin as checkIsAdmin } from '../auth/index';
@@ -30,11 +30,9 @@ import { createShardKeysApi } from '../keys/client';
 import { PERMISSION_KEYS_MINT } from '../keys/types';
 import { subscribe } from '../keys/revocation-bus.svelte';
 import { register as contributionsRegister, list as contributionsList, listPoints as contributionsListPoints, onChange as contributionsOnChange, onAnyChange as contributionsOnAnyChange, } from '../contributions';
-import { registerAction, listActions as listActionsFromRegistry } from '../actions/registry';
+import { registerAction } from '../actions/registry';
 import { makeSelectionApi, clearSelectionForShard } from '../actions/selection.svelte';
-import { openContextMenu as sh3OpenContextMenu, openPalette as sh3OpenPalette, dispatchActionProgrammatic, } from '../actions/listeners';
-import { listActionsFromEntries } from '../actions/listActive';
-import { getLiveDispatcherState } from '../actions/state.svelte';
+import { openContextMenu as sh3OpenContextMenu, openPalette as sh3OpenPalette, } from '../actions/listeners';
 /**
  * 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
@@ -88,7 +86,7 @@ export function registerShard(shard) {
  * @throws If the shard is not registered, if `shard.activate` throws, or if a manifest view has no factory after activation.
  */
 export async function activateShard(id, opts) {
-    var _a, _b, _c, _d, _e, _f;
+    var _a, _b, _c, _d, _e, _f, _g;
     const shard = registeredShards.get(id);
     if (!shard) {
         throw new Error(`Cannot activate shard "${id}": not registered`);
@@ -109,8 +107,20 @@ export async function activateShard(id, opts) {
     // global registry, and its disposer is pushed into entry.cleanupFns
     // so deactivate auto-unregisters.
     const contributions = {
-        register(pointId, descriptor) {
-            const dispose = contributionsRegister(pointId, descriptor);
+        register(pointId, descriptor, contribOpts) {
+            var _a;
+            // Auto-wrap controllable-field descriptors with ownership metadata so
+            // fields/dispatch.ts can route addressed get/set without the user
+            // descriptor needing to know about the framework's wire format.
+            let stored = descriptor;
+            if (pointId === 'sh3.controllable-field') {
+                const owner = { shardId: id };
+                if (((_a = contribOpts === null || contribOpts === void 0 ? void 0 : contribOpts.scope) === null || _a === void 0 ? void 0 : _a.slotId) !== undefined) {
+                    owner.slotId = contribOpts.scope.slotId;
+                }
+                stored = { owner, descriptor };
+            }
+            const dispose = contributionsRegister(pointId, stored, contribOpts);
             entry.cleanupFns.push(async () => dispose());
             return dispose;
         },
@@ -203,29 +213,13 @@ export async function activateShard(id, opts) {
             openContextMenu(opts) { sh3OpenContextMenu(opts); },
             openPalette(opts) { sh3OpenPalette(opts); },
         },
-        listVerbs(opts) {
-            const all = listVerbsWithShard();
-            const filtered = (opts === null || opts === void 0 ? void 0 : opts.programmaticOnly)
-                ? all.filter(({ verb }) => verb.programmatic === true)
-                : all;
-            return filtered.map(({ verb, shardId }) => ({
-                shardId,
-                name: verb.name,
-                summary: verb.summary,
-                programmatic: verb.programmatic,
-                schema: verb.schema,
-            }));
-        },
-        runVerb(shardId, name, args, opts) {
-            return runVerbProgrammatic(shardId, name, args, opts);
-        },
-        listActions(opts) {
-            const all = listActionsFromEntries(listActionsFromRegistry(), getLiveDispatcherState());
-            return (opts === null || opts === void 0 ? void 0 : opts.activeOnly) ? all.filter((a) => a.active) : all;
-        },
-        runAction(actionId, opts) {
-            return dispatchActionProgrammatic(actionId, opts);
-        },
+        sh3: makeSh3Api({
+            callerKind: 'shard',
+            callerShardId: id,
+            zones: ((_e = shard.manifest.permissions) === null || _e === void 0 ? void 0 : _e.includes(PERMISSION_STATE_MANAGE))
+                ? createZoneManager()
+                : undefined,
+        }),
     };
     entry.ctx = ctx;
     // Wire onKeyRevoked hook: subscribe to the revocation bus for this shard.
@@ -271,7 +265,7 @@ export async function activateShard(id, opts) {
             try {
                 void fn();
             }
-            catch (_g) {
+            catch (_h) {
                 // intentionally swallowed: original error is what matters.
             }
         }
@@ -285,7 +279,7 @@ export async function activateShard(id, opts) {
         erroredShards.set(id, {
             id,
             error: err,
-            phase: (_e = opts === null || opts === void 0 ? void 0 : opts.phase) !== null && _e !== void 0 ? _e : 'launch',
+            phase: (_f = opts === null || opts === void 0 ? void 0 : opts.phase) !== null && _f !== void 0 ? _f : 'launch',
             timestamp: Date.now(),
         });
         console.error(`[sh3] Shard "${id}" failed to activate:`, err);
@@ -293,7 +287,7 @@ export async function activateShard(id, opts) {
     }
     // Activation succeeded — clear any prior error record for this shard.
     erroredShards.delete(id);
-    void ((_f = shard.autostart) === null || _f === void 0 ? void 0 : _f.call(shard, ctx));
+    void ((_g = shard.autostart) === null || _g === void 0 ? void 0 : _g.call(shard, ctx));
 }
 /**
  * Deactivate an active shard. Calls `shard.deactivate`, flushes and disposes