@deepseek-insight/container-base 0.0.0-stage → 0.1.0

package/dist/interaction/chord-machine.d.ts

@@ -0,0 +1,108 @@
+/**
+ * chord-machine — the armed two-stroke keyboard chord reducer (ADR-0006a
+ * port; container-base W5, ADR-0062 D5: the MACHINE moves, the PREFIX
+ * TABLES stay consumer config).
+ *
+ * A PURE reducer: every transition is (state, event, facts) -> { state,
+ * action }. No DOM, no stores, no timers — the caller owns the clock
+ * (now) and the wiring (which element heard the key).
+ *
+ * Grammar: press-and-release the arming key within CHORD_WINDOW_MS; a
+ * digit fires { apply, n }; a verb letter fires { verb } through the
+ * consumer's table; any other key or the expiring window disarms.
+ *
+ * D5 (the consumer-table rule): the machine never learns WHICH letters
+ * are verbs or what a terminal prefix maps to — the consumer passes
+ * ChordTables. The arming prefixes (Alt+first / Alt+second) and the
+ * digit lanes are machine semantics; "the arming key names the prefix;
+ * the prefix owns the follow-up table" is the ADR-0052 D1 rule the
+ * tables express.
+ */
+export declare const CHORD_WINDOW_MS = 2000;
+export type ChordPrefix = 's' | 't';
+export interface ChordState {
+    /** True between the arming release and the digit / disarm. */
+    armed: boolean;
+    /** Date.now() of the arming keyup — the window clock. */
+    since: number;
+    /** Which prefix owns this chord — the prefix names the follow-up table. */
+    prefix: ChordPrefix;
+}
+export declare const IDLE_CHORD: ChordState;
+export interface ChordOptionRow {
+    key: string;
+    label: string;
+}
+export type ChordAction = {
+    type: 'none';
+} | {
+    type: 'disarm';
+} | {
+    type: 'apply';
+    n: number;
+} | {
+    type: 'verb';
+    verb: string;
+    prefix: ChordPrefix;
+};
+/** Minimal key shape the wiring feeds in (a real KeyboardEvent fits). */
+export interface ChordKey {
+    key: string;
+    /** PHYSICAL key identity — the layout-independent match site. Holding
+     *  Alt remaps letters on macOS (Option+S types key='ß'), so e.key
+     *  matching never arms on a real keyboard. Match e.code; key stays as
+     *  the no-code fallback. */
+    code?: string;
+    altKey: boolean;
+    ctrlKey: boolean;
+    metaKey: boolean;
+    /** string, not the union — a real KeyboardEvent.type IS a string and
+     *  the wiring passes the event whole (no lossy adapter). */
+    type: string;
+}
+/** The consumer's chord tables (D5): WHICH letters are verbs under the
+ *  plain prefix, and what the terminal prefix's letters map to. Absence
+ *  of a letter in the terminal map disarms; a letter outside `verbs`
+ *  disarms. An empty default table keeps the machine neutral — the
+ *  consumer's config module owns the real table. */
+export interface ChordTables {
+    /** Letters that fire `{ type: 'verb', verb: letter }` under the
+     *  plain (first) prefix. */
+    verbs: string;
+    /** The terminal prefix's letter → verb-name map (a verb name the
+     *  host dispatches; the machine never interprets it). */
+    terminal?: Record<string, string>;
+    /** Which prefix is the terminal one (default 't'). */
+    terminalPrefix?: ChordPrefix;
+}
+/** True when the chord can arm at all — any preset slot on any lane. */
+export declare function hasAnyPreset(p: {
+    agent: Record<number, unknown>;
+    glass: Record<number, unknown>;
+    sidebar: Record<number, unknown>;
+    zoom?: Record<number, unknown>;
+}): boolean;
+/** Is the event target an editable surface? The wiring calls this FIRST —
+ *  typing "1" in a composer must never fire a preset. */
+export declare function isEditableTarget(t: unknown): boolean;
+/** One key event through the machine. now is injectable for tests.
+ *
+ *  ARM ON KEYDOWN — keyup is unreachable through window keydown wiring,
+ *  and an arm-on-keyup rule would eat the chord it just armed: keyups
+ *  pass through untouched. */
+export declare function chordKey(state: ChordState, ev: ChordKey, canArm: boolean, now?: number, tables?: ChordTables): {
+    state: ChordState;
+    action: ChordAction;
+};
+/** The capture-first decision as a PURE function so the route adapter
+ *  stays three lines and the capture rules unit-test without DOM.
+ *  Ordering IS the contract: (1) a clean arming keydown captures
+ *  everywhere; (2) an armed chord captures the next keydown everywhere;
+ *  (3) anything else — including an un-armed digit on an editable
+ *  target — passes. preventDefault is the swallowing the composer must
+ *  never see. */
+export declare function decideChordKeydown(state: ChordState, ev: ChordKey, canArm: boolean, now?: number, tables?: ChordTables): {
+    state: ChordState;
+    action: ChordAction;
+    preventDefault: boolean;
+};

package/dist/interaction/chord-machine.js

@@ -0,0 +1,121 @@
+/**
+ * chord-machine — the armed two-stroke keyboard chord reducer (ADR-0006a
+ * port; container-base W5, ADR-0062 D5: the MACHINE moves, the PREFIX
+ * TABLES stay consumer config).
+ *
+ * A PURE reducer: every transition is (state, event, facts) -> { state,
+ * action }. No DOM, no stores, no timers — the caller owns the clock
+ * (now) and the wiring (which element heard the key).
+ *
+ * Grammar: press-and-release the arming key within CHORD_WINDOW_MS; a
+ * digit fires { apply, n }; a verb letter fires { verb } through the
+ * consumer's table; any other key or the expiring window disarms.
+ *
+ * D5 (the consumer-table rule): the machine never learns WHICH letters
+ * are verbs or what a terminal prefix maps to — the consumer passes
+ * ChordTables. The arming prefixes (Alt+first / Alt+second) and the
+ * digit lanes are machine semantics; "the arming key names the prefix;
+ * the prefix owns the follow-up table" is the ADR-0052 D1 rule the
+ * tables express.
+ */
+export const CHORD_WINDOW_MS = 2_000;
+export const IDLE_CHORD = { armed: false, since: 0, prefix: 's' };
+const NO_TABLES = { verbs: '' };
+/** True when the chord can arm at all — any preset slot on any lane. */
+export function hasAnyPreset(p) {
+    return (Object.keys(p.agent).length > 0 ||
+        Object.keys(p.glass).length > 0 ||
+        Object.keys(p.sidebar).length > 0 ||
+        Object.keys(p.zoom ?? {}).length > 0);
+}
+/** Is the event target an editable surface? The wiring calls this FIRST —
+ *  typing "1" in a composer must never fire a preset. */
+export function isEditableTarget(t) {
+    const el = t;
+    if (!el || typeof el.closest !== 'function')
+        return false;
+    return el.closest('input, textarea, select, [contenteditable="true"], [contenteditable=""]') != null;
+}
+/** One key event through the machine. now is injectable for tests.
+ *
+ *  ARM ON KEYDOWN — keyup is unreachable through window keydown wiring,
+ *  and an arm-on-keyup rule would eat the chord it just armed: keyups
+ *  pass through untouched. */
+export function chordKey(state, ev, canArm, now = Date.now(), tables = NO_TABLES) {
+    const key = ev.key.toLowerCase();
+    if (ev.type === 'keyup')
+        return { state, action: { type: 'none' } };
+    // PHYSICAL identity: code='KeyS'/'KeyT' survives the macOS Alt remap;
+    // key==='s'/'t' stays as the fallback for code-less events. The
+    // arming key NAMES the prefix; the prefix owns the follow-up table.
+    const terminalPrefix = tables.terminalPrefix ?? 't';
+    const prefix = ev.code === 'KeyS' || (key === 's' && !ev.code)
+        ? 's'
+        : ev.code === 'KeyT' || (key === 't' && !ev.code)
+            ? 't'
+            : null;
+    // Digits: Digit1..9 first (matches even with Alt still held), key
+    // fallback. Digits are the FIRST prefix's lanes — under the terminal
+    // prefix they disarm (the table is truthful).
+    const digit = state.prefix === 's'
+        ? (/^Digit([1-9])$/.exec(ev.code ?? '')?.[1] ?? (/^[1-9]$/.test(ev.key) ? ev.key : null))
+        : null;
+    // Arming: a clean Alt+<prefix key> keydown (no ctrl/meta — browser verbs).
+    if (prefix && ev.altKey && !ev.ctrlKey && !ev.metaKey) {
+        if (!canArm)
+            return { state, action: { type: 'none' } };
+        // last prefix wins — an armed chord re-arms cleanly.
+        return { state: { armed: true, since: now, prefix }, action: { type: 'none' } };
+    }
+    if (!state.armed)
+        return { state, action: { type: 'none' } };
+    // The window expired on this keypress: disarm first, key never counts.
+    if (now - state.since > CHORD_WINDOW_MS) {
+        return { state: IDLE_CHORD, action: { type: 'disarm' } };
+    }
+    // A digit fires the preset (the operator taps; we don't grade the phase).
+    if (digit) {
+        return { state: IDLE_CHORD, action: { type: 'apply', n: Number(digit) } };
+    }
+    // A verb letter fires its table action — code first (the same
+    // physical-identity rule as arming), key fallback after. The LETTER
+    // SETS are the consumer's tables (D5), never this module's.
+    const letter = (/^[a-z]$/.test(ev.key) ? ev.key : undefined) ??
+        (/^Key([A-Z])$/.exec(ev.code ?? '')?.[1]?.toLowerCase());
+    if (letter) {
+        if (state.prefix === terminalPrefix && tables.terminal) {
+            const verb = tables.terminal[letter];
+            if (verb === undefined)
+                return { state: IDLE_CHORD, action: { type: 'disarm' } };
+            return { state: IDLE_CHORD, action: { type: 'verb', verb, prefix: state.prefix } };
+        }
+        if (tables.verbs.includes(letter)) {
+            return { state: IDLE_CHORD, action: { type: 'verb', verb: letter, prefix: state.prefix } };
+        }
+        return { state: IDLE_CHORD, action: { type: 'disarm' } };
+    }
+    // Any other key disarms.
+    return { state: IDLE_CHORD, action: { type: 'disarm' } };
+}
+/** The capture-first decision as a PURE function so the route adapter
+ *  stays three lines and the capture rules unit-test without DOM.
+ *  Ordering IS the contract: (1) a clean arming keydown captures
+ *  everywhere; (2) an armed chord captures the next keydown everywhere;
+ *  (3) anything else — including an un-armed digit on an editable
+ *  target — passes. preventDefault is the swallowing the composer must
+ *  never see. */
+export function decideChordKeydown(state, ev, canArm, now = Date.now(), tables = NO_TABLES) {
+    const k = ev.key.toLowerCase();
+    const isArm = ((ev.code === 'KeyS' || (k === 's' && !ev.code)) ||
+        (ev.code === 'KeyT' || (k === 't' && !ev.code))) &&
+        ev.altKey &&
+        !ev.ctrlKey &&
+        !ev.metaKey;
+    if (ev.type === 'keydown' && isArm) {
+        return { ...chordKey(state, ev, canArm, now, tables), preventDefault: true };
+    }
+    if (state.armed && ev.type === 'keydown') {
+        return { ...chordKey(state, ev, canArm, now, tables), preventDefault: true };
+    }
+    return { state, action: { type: 'none' }, preventDefault: false };
+}

package/dist/interaction/gutter-resize.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Gutter resize — the SINGLE sidebar-style drag machine (SSC#2 extraction,
+ * 2026-11-14): one width, snapshot on gutter mousedown, clamped delta per
+ * window mousemove, settle on window mouseup. Both consumers DSI has run
+ * byte-similar copies of this skeleton (route `startSidebarResize` +
+ * playground page drag vars); this module is now its only home.
+ *
+ * The machine OWNS: the window-listener lifecycle (attached on a
+ * successful start, released on settle), the delta arithmetic, the
+ * candidate width (snapshot + delta), and the clamp pass. The host OWNS:
+ * the bounds (clamp fn — DSI's are config-driven), the apply (write the
+ * width wherever it lives), and the settle (persistence, afterglow).
+ *
+ * A mousedown that returns null from `onStart` arms nothing — a host with
+ * collapsed/ignored states uses that instead of pre-gating the gutter.
+ */
+export interface GutterResizeMachine {
+    /** Gutter mousedown — arms the machine and attaches the window
+     *  listeners when `onStart` returns a snapshot width (null = ignore). */
+    start: (e: MouseEvent) => void;
+    /** True while dragging (start succeeded, settle not yet fired). */
+    readonly active: boolean;
+    /** Release the window listeners without settling (page teardown). */
+    destroy: () => void;
+}
+export declare function createGutterResize(handlers: {
+    /** Gutter mousedown: return the SNAPSHOT width (the width the drag
+     *  moves away from), or null to ignore this gesture. */
+    onStart: (e: MouseEvent) => number | null;
+    /** The host's bounds — a pure width -> width clamp. */
+    clamp: (width: number) => number;
+    /** Apply the clamped width — called per window mousemove while armed. */
+    onResize: (width: number, e: MouseEvent) => void;
+    /** Settle on window mouseup: persist, arm afterglow, etc. The final
+     *  clamped width is the one the last resize produced. */
+    onSettle?: (width: number) => void;
+}): GutterResizeMachine;

package/dist/interaction/gutter-resize.js

@@ -0,0 +1,41 @@
+export function createGutterResize(handlers) {
+    let armed = false;
+    let snapshot = 0;
+    let lastWidth = 0;
+    function onMove(e) {
+        if (!armed)
+            return;
+        lastWidth = handlers.clamp(snapshot + (e.clientX - lastStartX));
+        handlers.onResize(lastWidth, e);
+    }
+    function onUp(e) {
+        if (!armed)
+            return;
+        armed = false;
+        window.removeEventListener('mousemove', onMove);
+        window.removeEventListener('mouseup', onUp);
+        handlers.onSettle?.(lastWidth);
+    }
+    let lastStartX = 0;
+    return {
+        start(e) {
+            const snap = handlers.onStart(e);
+            if (snap === null)
+                return;
+            snapshot = snap;
+            lastStartX = e.clientX;
+            lastWidth = handlers.clamp(snap);
+            armed = true;
+            window.addEventListener('mousemove', onMove);
+            window.addEventListener('mouseup', onUp);
+        },
+        get active() {
+            return armed;
+        },
+        destroy() {
+            armed = false;
+            window.removeEventListener('mousemove', onMove);
+            window.removeEventListener('mouseup', onUp);
+        }
+    };
+}

package/dist/layout/floor-math.d.ts

@@ -0,0 +1,48 @@
+/**
+ * floor-math — the drag/resize/order math of a one-row pane floor
+ * (generalized from DSI's floor-math.ts, ADR-0062 W3 / D8). PURE functions
+ * over plain structural inputs; no DOM, no stores, no consumer vocabulary.
+ *
+ * GENERIC over the pane type: a consumer's own pane interface (union,
+ * discriminated kinds, extra fields) flows through UNCHANGED — every
+ * function returns the same pane type it took. Only the structural core
+ * (id + width, optional kind) is required.
+ *
+ * The width bound is INJECTED (the clamp): the generic module cannot know
+ * a consumer's config-driven bounds, so every resize entry takes an
+ * optional clamp — the consumer's single bound site (DSI passes
+ * clampPanelWidth). Behavior is byte-identical to the pre-move DSI file
+ * when the consumer passes its clamp.
+ */
+/** The structural core every pane must expose (satisfied by any consumer
+ *  pane with an id and a width; the kind tag rides through opaquely). */
+export interface PaneCore {
+    id: string;
+    width: number;
+    /** Opaque kind tag — passed through to the injected clamp only. */
+    kind?: unknown;
+}
+/** A consumer's single width bound site (load-side sanitize AND drags). */
+export type WidthClamp = (width: number, kind?: string) => number;
+/** Move direction, named in the INVOKING surface's geometry: horizontal
+ *  header chevrons vs vertical rows. The floor owner maps both pairs onto
+ *  one array operation — left/up toward the start, right/down toward the
+ *  end. */
+export type PaneMoveDir = 'left' | 'right' | 'up' | 'down';
+/** Plain drag: ONLY the pane left of the dragged gutter changes — its
+ *  snapshot width plus delta, passed through the injected clamp. Other
+ *  panes keep their widths untouched (the row's total grows/shrinks; the
+ *  floor viewport scrolls when the widened row overflows it). */
+export declare function resizeOne<P extends PaneCore>(panels: readonly P[], snapshots: readonly number[], index: number, delta: number, clamp?: WidthClamp): P[];
+/** Shift+drag: EVERY pane scales by its snapshot share of the row — ratios
+ *  are preserved (new_i/new_j = snap_i/snap_j) until a pane saturates at a
+ *  bound; an extreme drag clamps the row. A degenerate row (total <= 0)
+ *  returns the input order untouched. */
+export declare function scaleProportionally<P extends PaneCore>(panels: readonly P[], snapshots: readonly number[], delta: number, clamp?: WidthClamp): P[];
+/** Honest-slider check: a row is uniform when every width equals the
+ *  first (an empty row is not — nothing to sync the preset to). */
+export declare function isUniformRow<P extends PaneCore>(panels: readonly P[]): boolean;
+/** Move one pane one slot toward the direction's edge — left/up swap with
+ *  the predecessor, right/down with the successor. A no-op returning the
+ *  input order at either edge or for an unknown pane id. */
+export declare function movePanelWithin<P extends PaneCore>(panels: readonly P[], panelId: string, dir: PaneMoveDir): P[];

package/dist/layout/floor-math.js

@@ -0,0 +1,60 @@
+/**
+ * floor-math — the drag/resize/order math of a one-row pane floor
+ * (generalized from DSI's floor-math.ts, ADR-0062 W3 / D8). PURE functions
+ * over plain structural inputs; no DOM, no stores, no consumer vocabulary.
+ *
+ * GENERIC over the pane type: a consumer's own pane interface (union,
+ * discriminated kinds, extra fields) flows through UNCHANGED — every
+ * function returns the same pane type it took. Only the structural core
+ * (id + width, optional kind) is required.
+ *
+ * The width bound is INJECTED (the clamp): the generic module cannot know
+ * a consumer's config-driven bounds, so every resize entry takes an
+ * optional clamp — the consumer's single bound site (DSI passes
+ * clampPanelWidth). Behavior is byte-identical to the pre-move DSI file
+ * when the consumer passes its clamp.
+ */
+const identityClamp = (width) => width;
+/** Plain drag: ONLY the pane left of the dragged gutter changes — its
+ *  snapshot width plus delta, passed through the injected clamp. Other
+ *  panes keep their widths untouched (the row's total grows/shrinks; the
+ *  floor viewport scrolls when the widened row overflows it). */
+export function resizeOne(panels, snapshots, index, delta, clamp = identityClamp) {
+    const target = clamp(snapshots[index] + delta, panels[index]?.kind);
+    return panels.map((p, i) => (i === index ? { ...p, width: target } : p));
+}
+/** Shift+drag: EVERY pane scales by its snapshot share of the row — ratios
+ *  are preserved (new_i/new_j = snap_i/snap_j) until a pane saturates at a
+ *  bound; an extreme drag clamps the row. A degenerate row (total <= 0)
+ *  returns the input order untouched. */
+export function scaleProportionally(panels, snapshots, delta, clamp = identityClamp) {
+    const total = snapshots.reduce((sum, w) => sum + w, 0);
+    if (total <= 0)
+        return [...panels];
+    return panels.map((p, i) => ({
+        ...p,
+        width: clamp(snapshots[i] + (snapshots[i] / total) * delta, panels[i]?.kind)
+    }));
+}
+/** Honest-slider check: a row is uniform when every width equals the
+ *  first (an empty row is not — nothing to sync the preset to). */
+export function isUniformRow(panels) {
+    if (panels.length === 0)
+        return false;
+    const first = panels[0].width;
+    return panels.every((p) => p.width === first);
+}
+/** Move one pane one slot toward the direction's edge — left/up swap with
+ *  the predecessor, right/down with the successor. A no-op returning the
+ *  input order at either edge or for an unknown pane id. */
+export function movePanelWithin(panels, panelId, dir) {
+    const idx = panels.findIndex((p) => p.id === panelId);
+    if (idx === -1)
+        return [...panels];
+    const target = dir === 'left' || dir === 'up' ? idx - 1 : idx + 1;
+    if (target < 0 || target >= panels.length)
+        return [...panels];
+    const next = [...panels];
+    [next[idx], next[target]] = [next[target], next[idx]];
+    return next;
+}

package/dist/layout/placement.d.ts

@@ -0,0 +1,18 @@
+/**
+ * placement — the generic order/anchor math of a pane floor (ADR-0062 W3,
+ * D8: split from DSI's panel-placement; the kind-tagged request union and
+ * DSI-specific branches stay in the consumer). PURE, list-shaped only.
+ */
+/** The slot directly BELOW an anchor pane — anchor + 1 — or the caller's
+ *  fallback when no pane carries the anchor (anchorIndex < 0). The
+ *  fork-child / below-the-explorer slot rule. */
+export declare function slotAfter(anchorIndex: number, fallback: number): number;
+/** Insert ONE item at an anchor index. Boundary anchors clamp: an empty
+ *  list (or an anchor past the end) appends; a negative anchor inserts at
+ *  the front. Ordering is stable — existing members never reorder. */
+export declare function insertAtAnchor<T>(list: readonly T[], anchorIndex: number, item: T): T[];
+/** The focused-slot rule: a fresh item lands at the FOCUSED index —
+ *  immediately before it. 0 when nothing is focused (negative or past the
+ *  end) — front-add stays the fallback; Math.max keeps splice's
+ *  negative-index semantics out of the no-selection case. */
+export declare function focusedSlot(selectedIndex: number, listLength: number): number;

package/dist/layout/placement.js

@@ -0,0 +1,27 @@
+/**
+ * placement — the generic order/anchor math of a pane floor (ADR-0062 W3,
+ * D8: split from DSI's panel-placement; the kind-tagged request union and
+ * DSI-specific branches stay in the consumer). PURE, list-shaped only.
+ */
+/** The slot directly BELOW an anchor pane — anchor + 1 — or the caller's
+ *  fallback when no pane carries the anchor (anchorIndex < 0). The
+ *  fork-child / below-the-explorer slot rule. */
+export function slotAfter(anchorIndex, fallback) {
+    return anchorIndex >= 0 ? anchorIndex + 1 : fallback;
+}
+/** Insert ONE item at an anchor index. Boundary anchors clamp: an empty
+ *  list (or an anchor past the end) appends; a negative anchor inserts at
+ *  the front. Ordering is stable — existing members never reorder. */
+export function insertAtAnchor(list, anchorIndex, item) {
+    const at = Math.max(0, Math.min(anchorIndex, list.length));
+    const next = [...list];
+    next.splice(at, 0, item);
+    return next;
+}
+/** The focused-slot rule: a fresh item lands at the FOCUSED index —
+ *  immediately before it. 0 when nothing is focused (negative or past the
+ *  end) — front-add stays the fallback; Math.max keeps splice's
+ *  negative-index semantics out of the no-selection case. */
+export function focusedSlot(selectedIndex, listLength) {
+    return selectedIndex >= 0 && selectedIndex < listLength ? selectedIndex : 0;
+}

package/dist/registry/action-registry.d.ts

@@ -0,0 +1,30 @@
+/**
+ * action-registry — the generic leaf-to-root action channel (ADR-0062 W3,
+ * D8: split from DSI's panel-registry; the payload unions stay in the
+ * consumer). Shape follows the OCI ControlRail precedent: register(name,
+ * fn | null) slots owned by the host's mount/destroy lifecycle, invoke
+ * returning boolean (false = no handler, graceful no-op — never a crash
+ * in a leaf). Payload-agnostic: actions are string-keyed, arguments
+ * variadic, the table never inspects a payload.
+ */
+type AnyHandler = (...args: never[]) => unknown;
+export interface ActionTable {
+    /** Set (or overwrite) an action's handler; null unregisters. */
+    register(action: string, handler: AnyHandler | null): void;
+    /** True when a handler is currently registered for the action. */
+    has(action: string): boolean;
+    /** Run the action's handler if registered.
+     *  @returns true when a handler ran; false otherwise. */
+    invoke(action: string, ...args: unknown[]): boolean;
+    /** Like invoke, but returns the HANDLER'S OWN return value — undefined
+     *  when no handler is registered. For result-carrying actions (e.g. a
+     *  handler that reports a miss) where 'did it run' and 'what did it
+     *  say' are different questions. */
+    invokeForResult(action: string, ...args: unknown[]): unknown;
+    /** True when ANY handler is registered (a host is mounted). */
+    isActive(): boolean;
+    /** Clear every slot (isolation between tests / host destroy). */
+    reset(): void;
+}
+export declare function createActionTable(): ActionTable;
+export {};

package/dist/registry/action-registry.js

@@ -0,0 +1,44 @@
+/**
+ * action-registry — the generic leaf-to-root action channel (ADR-0062 W3,
+ * D8: split from DSI's panel-registry; the payload unions stay in the
+ * consumer). Shape follows the OCI ControlRail precedent: register(name,
+ * fn | null) slots owned by the host's mount/destroy lifecycle, invoke
+ * returning boolean (false = no handler, graceful no-op — never a crash
+ * in a leaf). Payload-agnostic: actions are string-keyed, arguments
+ * variadic, the table never inspects a payload.
+ */
+export function createActionTable() {
+    const slots = new Map();
+    return {
+        register(action, handler) {
+            if (handler === null)
+                slots.delete(action);
+            else
+                slots.set(action, handler);
+        },
+        has(action) {
+            return slots.has(action);
+        },
+        invoke(action, ...args) {
+            const handler = slots.get(action);
+            if (handler === undefined)
+                return false;
+            // The table is payload-agnostic by construction; the consumer's
+            // register-time types are the contract, invoke erases shape.
+            handler(...args);
+            return true;
+        },
+        invokeForResult(action, ...args) {
+            const handler = slots.get(action);
+            if (handler === undefined)
+                return undefined;
+            return handler(...args);
+        },
+        isActive() {
+            return slots.size > 0;
+        },
+        reset() {
+            slots.clear();
+        }
+    };
+}

package/dist/storage/create-prefs-store.d.ts

@@ -0,0 +1,25 @@
+export interface PrefsStoreOptions<T> {
+    /** The un-suffixed localStorage key (namespaced per profile). */
+    key: string;
+    /** Persisted defaults — a factory, so callers never share object state. */
+    defaults: () => T;
+    /** Parse a parsed-JSON value into prefs; return null to reject the blob
+     *  as junk (load falls back to defaults). */
+    revive: (raw: unknown) => T | null;
+    /** Optional bound pass, applied to the revived value (after revive). */
+    clamp?: (prefs: T) => T;
+    /** Opt-in `{v, data}` envelope — new consumers only (D4); read-side
+     *  still accepts a bare (legacy) blob so adoption is one-way safe. */
+    envelope?: {
+        version: number;
+    };
+}
+export interface PrefsStore<T> {
+    /** Read from localStorage; defaults on SSR, absence, junk, or error. */
+    load(profile?: string | null): T;
+    /** Write to localStorage (best-effort; no-op under SSR). */
+    save(prefs: T, profile?: string | null): void;
+    /** The exact key this store reads/writes for a profile. */
+    key(profile?: string | null): string;
+}
+export declare function createPrefsStore<T>(options: PrefsStoreOptions<T>): PrefsStore<T>;

package/dist/storage/create-prefs-store.js

@@ -0,0 +1,67 @@
+/**
+ * createPrefsStore — the survival-layer primitive (ADR-0062 D4).
+ *
+ * Nine consumer modules hand-rolled one pattern: SSR guard → revive with
+ * junk fallback → clamp → best-effort write. This is that pattern, once:
+ *
+ *   const store = createPrefsStore<MyPrefs>({
+ *     key: 'my-key',
+ *     defaults: () => ({ ... }),
+ *     revive: (raw) => sanitize(raw),   // return null ⇒ junk ⇒ defaults
+ *     clamp: (v) => bound(v)
+ *   });
+ *
+ * Semantics (pinned by tests/storage/create-prefs-store.test.ts):
+ * - SSR (`typeof localStorage === 'undefined'`): load → defaults, save → no-op.
+ * - junk / truncated / unparseable blob → defaults, never throws.
+ * - clamp runs AFTER revive, on every load.
+ * - writes are best-effort: a full or blocked store never throws.
+ * - blob shapes are consumer-owned: the stored text is exactly
+ *   JSON.stringify(prefs) unless the consumer opts into the `{v, data}`
+ *   envelope (new consumers only — existing blobs never migrate, D4).
+ */
+import { storageKey } from './namespace';
+/** True when the parsed JSON carries the envelope wrapper. */
+function isEnvelope(raw) {
+    if (raw === null || typeof raw !== 'object')
+        return false;
+    const rec = raw;
+    return 'v' in rec && 'data' in rec;
+}
+export function createPrefsStore(options) {
+    const { key, defaults, revive, clamp, envelope } = options;
+    const keyFor = (profile) => storageKey(key, profile);
+    const finalize = (prefs) => (clamp ? clamp(prefs) : prefs);
+    return {
+        key: keyFor,
+        load(profile) {
+            if (typeof localStorage === 'undefined')
+                return defaults();
+            try {
+                const raw = localStorage.getItem(keyFor(profile));
+                if (!raw)
+                    return defaults();
+                const parsed = JSON.parse(raw);
+                const body = envelope !== undefined && isEnvelope(parsed) ? parsed.data : parsed;
+                const revived = revive(body);
+                if (revived === null)
+                    return defaults();
+                return finalize(revived);
+            }
+            catch {
+                return defaults();
+            }
+        },
+        save(prefs, profile) {
+            if (typeof localStorage === 'undefined')
+                return;
+            try {
+                const payload = envelope !== undefined ? { v: envelope.version, data: prefs } : prefs;
+                localStorage.setItem(keyFor(profile), JSON.stringify(payload));
+            }
+            catch {
+                // Store full or blocked — persistence is lost, the app is not.
+            }
+        }
+    };
+}