sh3-core 0.16.1 → 0.17.2

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

@@ -0,0 +1,75 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { makeSh3Api } from './headless';
+import { acquireSlotHost, resetSlotHostPool, } from '../layout/slotHostPool.svelte';
+import { __resetContributionsForTest } from '../contributions/registry';
+/*
+ * Walker dispatch through the Sh3Api facade.
+ *
+ * Locks in that ctx.sh3.fields.get/set work with walker-produced addresses
+ * (shardId === 'sh3.walker'). The walker synthesizes FieldViews on every
+ * call — facade re-walks the slot's container to resolve the target element,
+ * then routes through the same writeElement helper as element-ref descriptors.
+ */
+describe('Sh3Api fields walker dispatch', () => {
+    beforeEach(() => {
+        __resetContributionsForTest();
+        resetSlotHostPool();
+        document.body.innerHTML = '';
+    });
+    it('set on a walker addr writes the underlying input and dispatches input+change', async () => {
+        const slotId = 'sw1';
+        const host = acquireSlotHost(slotId, 'view', 'lbl');
+        document.body.appendChild(host);
+        host.innerHTML = `<select name="color">
+        <option value="red">Red</option>
+        <option value="blue">Blue</option>
+      </select>`;
+        const select = host.querySelector('select');
+        let inputs = 0;
+        let changes = 0;
+        select.addEventListener('input', () => inputs++);
+        select.addEventListener('change', () => changes++);
+        const api = makeSh3Api({ callerKind: 'verb' });
+        await api.fields.set({ shardId: 'sh3.walker', slotId, fieldId: 'color' }, 'blue');
+        expect(select.value).toBe('blue');
+        expect(inputs).toBe(1);
+        expect(changes).toBe(1);
+    });
+    it('get on a walker addr returns the live value', () => {
+        const slotId = 'sw2';
+        const host = acquireSlotHost(slotId, 'view', 'lbl');
+        document.body.appendChild(host);
+        host.innerHTML = `<input name="title" value="hello" />`;
+        const api = makeSh3Api({ callerKind: 'verb' });
+        expect(api.fields.get({ shardId: 'sh3.walker', slotId, fieldId: 'title' })).toBe('hello');
+    });
+    it('get on a walker addr reads .checked for checkbox', () => {
+        const slotId = 'sw3';
+        const host = acquireSlotHost(slotId, 'view', 'lbl');
+        document.body.appendChild(host);
+        host.innerHTML = `<input type="checkbox" name="published" />`;
+        const cb = host.querySelector('input');
+        cb.checked = true;
+        const api = makeSh3Api({ callerKind: 'verb' });
+        expect(api.fields.get({ shardId: 'sh3.walker', slotId, fieldId: 'published' })).toBe(true);
+    });
+    it('rejects unknown walker addr (slot has no matching field)', () => {
+        const slotId = 'sw4';
+        const host = acquireSlotHost(slotId, 'view', 'lbl');
+        document.body.appendChild(host);
+        const api = makeSh3Api({ callerKind: 'verb' });
+        expect(() => api.fields.get({ shardId: 'sh3.walker', slotId, fieldId: 'absent' })).toThrow(/unknown field/);
+    });
+    it('rejects walker addr without slotId', async () => {
+        const api = makeSh3Api({ callerKind: 'verb' });
+        await expect(api.fields.set({ shardId: 'sh3.walker', fieldId: 'whatever' }, 'x')).rejects.toThrow(/requires slotId/);
+    });
+    it('rejects writing to a [data-sh3-field] custom element', async () => {
+        const slotId = 'sw5';
+        const host = acquireSlotHost(slotId, 'view', 'lbl');
+        document.body.appendChild(host);
+        host.innerHTML = `<div data-sh3-field="custom">x</div>`;
+        const api = makeSh3Api({ callerKind: 'verb' });
+        await expect(api.fields.set({ shardId: 'sh3.walker', slotId, fieldId: 'custom' }, 'y')).rejects.toThrow(/cannot write/);
+    });
+});

package/dist/sh3Api/headless.d.ts

@@ -1,4 +1,13 @@
 import type { Sh3Api } from '../shell-shard/registry';
 import type { ZoneManager } from '../state/types';
+export interface MakeSh3ApiOpts {
+    callerKind: 'shard' | 'verb';
+    /** Present when callerKind === 'shard' (used by future permission gates). */
+    callerShardId?: string;
+    /** Cross-shard zone manager — passed in by ShardContext when permitted. */
+    zones?: ZoneManager;
+}
+export declare function makeSh3Api(opts?: MakeSh3ApiOpts): Sh3Api;
+/** @deprecated Renamed to makeSh3Api(opts?). Kept for one minor cycle. */
 export declare function makeSh3ApiHeadless(zones?: ZoneManager): Sh3Api;
 export declare function makeSh3ApiForTest(): Sh3Api;

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,45 @@ 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());
+            let out = all;
+            if ((actionOpts === null || actionOpts === void 0 ? void 0 : actionOpts.submenuOf) !== undefined) {
+                const parent = actionOpts.submenuOf;
+                out = out.filter((a) => a.submenuOf === parent);
+            }
+            if (actionOpts === null || actionOpts === void 0 ? void 0 : actionOpts.activeOnly) {
+                out = out.filter((a) => a.active);
+            }
+            return out;
+        },
+        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,8 @@
-import { describe, it, expect } from 'vitest';
-import { makeSh3ApiHeadless } from './headless';
+import { describe, it, expect, beforeEach } from 'vitest';
+import { makeSh3Api } from './headless';
+import { registerAction, __resetActionsRegistryForTest, } from '../actions/registry';
+import { __resetContributionsForTest } from '../contributions/registry';
+import { __resetDispatcherStateForTest } from '../actions/state.svelte';
 function makeMockZoneManager() {
     const data = {
         ephemeral: {},
@@ -16,44 +19,85 @@ 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);
     });
 });
+describe('sh3Api listActions submenu filter', () => {
+    beforeEach(() => {
+        __resetContributionsForTest();
+        __resetActionsRegistryForTest();
+        __resetDispatcherStateForTest();
+    });
+    it('returns only children of the named parent when { submenuOf } is set', () => {
+        registerAction({ id: 'theme.set', label: 'Theme', scope: 'home', submenu: true }, 'shard.x');
+        registerAction({
+            id: 'theme.set:dark', label: 'Dark', scope: 'home',
+            submenuOf: 'theme.set', run: () => { },
+        }, 'shard.x');
+        registerAction({
+            id: 'theme.set:light', label: 'Light', scope: 'home',
+            submenuOf: 'theme.set', run: () => { },
+        }, 'shard.x');
+        registerAction({ id: 'unrelated', label: 'U', scope: 'home', run: () => { } }, 'shard.x');
+        const api = makeSh3Api({ callerKind: 'verb' });
+        const ids = api.listActions({ submenuOf: 'theme.set' }).map((d) => d.id);
+        expect(ids.sort()).toEqual(['theme.set:dark', 'theme.set:light']);
+    });
+    it('returns [] when no children match the parent id', () => {
+        registerAction({ id: 'home.go', label: 'Go', scope: 'home', run: () => { } }, 'shard.x');
+        const api = makeSh3Api({ callerKind: 'verb' });
+        expect(api.listActions({ submenuOf: 'nope' })).toEqual([]);
+    });
+    it('combines with { activeOnly } — both predicates must hold', () => {
+        registerAction({ id: 'p', label: 'P', scope: 'home', submenu: true }, 'shard.x');
+        // active child (home is active by default in the test state)
+        registerAction({ id: 'p:a', label: 'A', scope: 'home',
+            submenuOf: 'p', run: () => { } }, 'shard.x');
+        // inactive child (app scope, no active app)
+        registerAction({ id: 'p:b', label: 'B', scope: 'app',
+            submenuOf: 'p', run: () => { } }, 'shard.x');
+        const api = makeSh3Api({ callerKind: 'verb' });
+        const ids = api
+            .listActions({ submenuOf: 'p', activeOnly: true })
+            .map((d) => d.id);
+        expect(ids).toEqual(['p:a']);
+    });
+});

package/dist/sh3Runtime.svelte.d.ts

@@ -10,6 +10,8 @@ import type { ColorApi } from './color/api';
 import { type OpenContextMenuOpts, type OpenPaletteOpts } from './actions/listeners';
 import type { ActiveActionDescriptor } from './actions/types';
 import { type DispatchToTerminalResult } from './shell-shard/dispatch-to-terminal';
+import type { ViewportInfo, ViewportClass } from './viewport/types';
+import type { DrawerAnchor, DrawerStateMap } from './layout/compact/types';
 /**
  * The process-wide sh3 singleton exposed to shards and the sh3's own
  * internal code. Provides state zone creation and overlay managers.
@@ -39,6 +41,17 @@ export interface Sh3 {
     color: ColorApi;
     /** Actions facade — rebind keys, query bindings, open menus/palette. */
     actions: Sh3ActionsApi;
+    /**
+     * Reactive viewport classification. Subscribers fire on class change
+     * (desktop ↔ compact). Use `override(cls)` to pin a class for
+     * playgrounds and debug; pass null to restore auto-derivation.
+     */
+    readonly viewport: Sh3Viewport;
+    /**
+     * Compact-mode drawer surface controls. Inert on desktop — mutating
+     * methods throw rather than silently no-op so misuse is caught early.
+     */
+    readonly drawers: Sh3Drawers;
     /**
      * Dispatch `line` through a Terminal view's normal submit path. Used by
      * views outside a verb context (floating pickers, dialogs) to drive a
@@ -51,6 +64,29 @@ export interface Sh3 {
      */
     dispatchToTerminal(line: string): DispatchToTerminalResult;
 }
+/**
+ * Compact-mode drawer surface controls. Mutating methods throw on desktop
+ * so misuse surfaces as a loud error instead of a silent no-op.
+ */
+export interface Sh3Drawers {
+    readonly state: DrawerStateMap;
+    open(anchor: DrawerAnchor): void;
+    close(anchor: DrawerAnchor): void;
+    toggle(anchor: DrawerAnchor): void;
+    activate(anchor: DrawerAnchor, slotId: string): void;
+}
+/**
+ * Reactive viewport classification surface. See viewport/store.svelte.ts.
+ */
+export interface Sh3Viewport {
+    /** Reactive — read directly inside an effect, or use `subscribe()`. */
+    readonly current: ViewportInfo;
+    subscribe(cb: (i: ViewportInfo) => void): () => void;
+    /** Pin the class. Pass null to restore auto. Debug/playground only. */
+    override(cls: ViewportClass | null): void;
+    /** Currently-pinned override (null = auto). */
+    readonly pinned: ViewportClass | null;
+}
 /**
  * API for managing action bindings and triggering menus/palette
  * programmatically (e.g. from a future settings UI shard).

package/dist/sh3Runtime.svelte.js

@@ -28,6 +28,8 @@ import { setUserBindings, getLiveDispatcherState, onActiveChange as onActiveChan
 import { listActions, onActionsChange } from './actions/registry';
 import { listActiveFromEntries } from './actions/listActive';
 import { makeDispatchToTerminal } from './shell-shard/dispatch-to-terminal';
+import { viewportStore } from './viewport/store.svelte';
+import { drawerStore } from './layout/compact/drawerStore.svelte';
 const sh3Actions = {
     async rebind(appId, actionId, shortcut) {
         await saveUserBinding(appId, actionId, shortcut);
@@ -77,4 +79,35 @@ export const sh3 = {
     color: colorApi,
     actions: sh3Actions,
     dispatchToTerminal: makeDispatchToTerminal({ headless: false }),
+    viewport: {
+        get current() { return viewportStore.current; },
+        subscribe: (cb) => viewportStore.subscribe(cb),
+        override: (cls) => viewportStore.override(cls),
+        get pinned() { return viewportStore.pinned; },
+    },
+    drawers: {
+        get state() { return drawerStore.state; },
+        open: (anchor) => {
+            assertCompact('open');
+            drawerStore.open(anchor);
+        },
+        close: (anchor) => {
+            assertCompact('close');
+            drawerStore.close(anchor);
+        },
+        toggle: (anchor) => {
+            assertCompact('toggle');
+            drawerStore.toggle(anchor);
+        },
+        activate: (anchor, slotId) => {
+            assertCompact('activate');
+            drawerStore.activate(anchor, slotId);
+        },
+    },
 };
+function assertCompact(method) {
+    const cls = viewportStore.current.class;
+    if (cls !== 'compact') {
+        throw new Error(`Sh3.drawers.${method}: viewport class is "${cls}"; drawers exist only on compact`);
+    }
+}

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