@pie-players/pie-assessment-toolkit 0.3.30 → 0.3.32

package/dist/runtime/adapter/framework-error-bridge.js

@@ -0,0 +1,47 @@
+/**
+ * Framework-error bridge for the section runtime engine adapter (M7 —
+ * Variant C, layered).
+ *
+ * Routes `framework-error` engine outputs into a `FrameworkErrorBus`
+ * (write side: `FrameworkErrorReporter`). The bus is the single
+ * fan-out point shared with the toolkit CE's banner, the coordinator's
+ * canonical `onFrameworkError` lifecycle hook, and any direct host
+ * subscribers via `subscribeFrameworkErrors`. See
+ * `packages/assessment-toolkit/src/services/framework-error-bus.ts`
+ * for the full bus contract.
+ *
+ * **Why a separate bridge.** The dom-event-bridge dispatches the
+ * `framework-error` DOM event on the host. The framework-error-bridge
+ * routes the same model into the in-process bus so listeners that
+ * subscribe via `coordinator.subscribeFrameworkErrors(...)` see the
+ * same fan-out with byte-identical payloads. Splitting the
+ * responsibilities lets a host opt out of either side (DOM-only or
+ * bus-only) without re-implementing the other.
+ *
+ * **Bus ownership.** The bridge does not construct the bus; the
+ * adapter receives one externally so the toolkit CE can keep sharing
+ * its bus with the coordinator (matching today's
+ * `PieAssessmentToolkit.svelte` lifetime model). This avoids the
+ * "second bus" pitfall — a dual-bus topology would silently fragment
+ * fan-out.
+ */
+export function createFrameworkErrorBridge(options) {
+    const { bus } = options;
+    function dispatch(output) {
+        switch (output.kind) {
+            case "framework-error":
+                bus.reportFrameworkError(output.error);
+                return;
+            case "stage-change":
+            case "loading-complete":
+                return;
+            default: {
+                const exhaustive = output;
+                void exhaustive;
+                return;
+            }
+        }
+    }
+    return { dispatch };
+}
+//# sourceMappingURL=framework-error-bridge.js.map

package/dist/runtime/adapter/framework-error-bridge.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"framework-error-bridge.js","sourceRoot":"","sources":["../../../src/runtime/adapter/framework-error-bridge.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAaH,MAAM,UAAU,0BAA0B,CACzC,OAAoC;IAEpC,MAAM,EAAE,GAAG,EAAE,GAAG,OAAO,CAAC;IAExB,SAAS,QAAQ,CAAC,MAA2B;QAC5C,QAAQ,MAAM,CAAC,IAAI,EAAE,CAAC;YACrB,KAAK,iBAAiB;gBACrB,GAAG,CAAC,oBAAoB,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;gBACvC,OAAO;YACR,KAAK,cAAc,CAAC;YACpB,KAAK,kBAAkB;gBACtB,OAAO;YACR,OAAO,CAAC,CAAC,CAAC;gBACT,MAAM,UAAU,GAAU,MAAM,CAAC;gBACjC,KAAK,UAAU,CAAC;gBAChB,OAAO;YACR,CAAC;QACF,CAAC;IACF,CAAC;IAED,OAAO,EAAE,QAAQ,EAAE,CAAC;AACrB,CAAC"}

package/dist/runtime/adapter/instrumentation-bridge.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Instrumentation bridge for the section runtime engine adapter (M7 —
+ * Variant C, layered).
+ *
+ * Forwards every `SectionEngineOutput` to an optional observability
+ * hook the host injects (telemetry, debug logger, e2e probe). The
+ * bridge is intentionally thin: it does not buffer, transform, or
+ * filter. Hosts that need a different shape can run their own subscriber
+ * via the adapter's public `subscribe(...)` channel.
+ *
+ * **Why a dedicated bridge instead of a generic subscriber.** The
+ * subscriber-fanout channel is host-shaped — listeners receive batched
+ * arrays of outputs per `core.dispatch` call so they can reason about
+ * "what happened in this transition." The instrumentation hook is
+ * per-output: telemetry pipelines want one record per stage change,
+ * one record per readiness flip, etc. Splitting the channels keeps
+ * both shapes ergonomic.
+ *
+ * The bridge **must not** import `svelte` per the M7 layering
+ * constraint.
+ */
+import type { SectionEngineOutput } from "../core/engine-output.js";
+export type InstrumentationHook = (output: SectionEngineOutput) => void;
+export interface InstrumentationBridgeOptions {
+    hook?: InstrumentationHook;
+}
+export interface InstrumentationBridgeHandle {
+    dispatch(output: SectionEngineOutput): void;
+    setHook(hook: InstrumentationHook | undefined): void;
+}
+export declare function createInstrumentationBridge(options?: InstrumentationBridgeOptions): InstrumentationBridgeHandle;
+//# sourceMappingURL=instrumentation-bridge.d.ts.map

package/dist/runtime/adapter/instrumentation-bridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instrumentation-bridge.d.ts","sourceRoot":"","sources":["../../../src/runtime/adapter/instrumentation-bridge.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAEpE,MAAM,MAAM,mBAAmB,GAAG,CAAC,MAAM,EAAE,mBAAmB,KAAK,IAAI,CAAC;AAExE,MAAM,WAAW,4BAA4B;IAC5C,IAAI,CAAC,EAAE,mBAAmB,CAAC;CAC3B;AAED,MAAM,WAAW,2BAA2B;IAC3C,QAAQ,CAAC,MAAM,EAAE,mBAAmB,GAAG,IAAI,CAAC;IAC5C,OAAO,CAAC,IAAI,EAAE,mBAAmB,GAAG,SAAS,GAAG,IAAI,CAAC;CACrD;AAED,wBAAgB,2BAA2B,CAC1C,OAAO,GAAE,4BAAiC,GACxC,2BAA2B,CAiB7B"}

package/dist/runtime/adapter/instrumentation-bridge.js

@@ -0,0 +1,39 @@
+/**
+ * Instrumentation bridge for the section runtime engine adapter (M7 —
+ * Variant C, layered).
+ *
+ * Forwards every `SectionEngineOutput` to an optional observability
+ * hook the host injects (telemetry, debug logger, e2e probe). The
+ * bridge is intentionally thin: it does not buffer, transform, or
+ * filter. Hosts that need a different shape can run their own subscriber
+ * via the adapter's public `subscribe(...)` channel.
+ *
+ * **Why a dedicated bridge instead of a generic subscriber.** The
+ * subscriber-fanout channel is host-shaped — listeners receive batched
+ * arrays of outputs per `core.dispatch` call so they can reason about
+ * "what happened in this transition." The instrumentation hook is
+ * per-output: telemetry pipelines want one record per stage change,
+ * one record per readiness flip, etc. Splitting the channels keeps
+ * both shapes ergonomic.
+ *
+ * The bridge **must not** import `svelte` per the M7 layering
+ * constraint.
+ */
+export function createInstrumentationBridge(options = {}) {
+    let hook = options.hook;
+    function dispatch(output) {
+        if (!hook)
+            return;
+        try {
+            hook(output);
+        }
+        catch (error) {
+            console.warn("[InstrumentationBridge] hook failed:", error);
+        }
+    }
+    function setHook(next) {
+        hook = next;
+    }
+    return { dispatch, setHook };
+}
+//# sourceMappingURL=instrumentation-bridge.js.map

package/dist/runtime/adapter/instrumentation-bridge.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"instrumentation-bridge.js","sourceRoot":"","sources":["../../../src/runtime/adapter/instrumentation-bridge.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAeH,MAAM,UAAU,2BAA2B,CAC1C,UAAwC,EAAE;IAE1C,IAAI,IAAI,GAAoC,OAAO,CAAC,IAAI,CAAC;IAEzD,SAAS,QAAQ,CAAC,MAA2B;QAC5C,IAAI,CAAC,IAAI;YAAE,OAAO;QAClB,IAAI,CAAC;YACJ,IAAI,CAAC,MAAM,CAAC,CAAC;QACd,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YAChB,OAAO,CAAC,IAAI,CAAC,sCAAsC,EAAE,KAAK,CAAC,CAAC;QAC7D,CAAC;IACF,CAAC;IAED,SAAS,OAAO,CAAC,IAAqC;QACrD,IAAI,GAAG,IAAI,CAAC;IACb,CAAC;IAED,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAC;AAC9B,CAAC"}

package/dist/runtime/adapter/subscriber-fanout.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Subscriber fan-out for the section runtime engine adapter (M7 — Variant
+ * C, layered).
+ *
+ * The adapter exposes a single `subscribe(listener)` channel for hosts
+ * that want a synchronous stream of `SectionEngineOutput[]` batches —
+ * one batch per `core.dispatch(input)` call.
+ *
+ * **Why not reuse `SectionEngineCore.subscribe` directly.** The core
+ * channel is the engine's internal contract. The fan-out is the
+ * adapter's public channel: it is the single seam every facade method
+ * goes through, and the only seam that ever sees host-side errors. The
+ * separation lets us swap the core implementation (or skip it for
+ * tests) without changing the public subscriber shape.
+ *
+ * **Subscriber contract.** Mirrors `SectionEngineCore.subscribe`:
+ *   - Listeners are invoked synchronously, in registration order.
+ *   - A listener that throws is caught and `console.warn`-logged. Fan-out
+ *     is not interrupted — same isolation guarantee as
+ *     `FrameworkErrorBus`.
+ *   - The disposer returned from `subscribe` is idempotent.
+ *   - Listeners receive a frozen, defensively-copied output array.
+ *   - There is no replay; subscribe at adapter construction time if you
+ *     need every output from `idle` onward.
+ */
+import type { SectionEngineOutput } from "../core/engine-output.js";
+export type EngineOutputListener = (outputs: readonly SectionEngineOutput[]) => void;
+export interface SubscriberFanoutHandle {
+    emit(outputs: readonly SectionEngineOutput[]): void;
+    subscribe(listener: EngineOutputListener): () => void;
+    dispose(): void;
+    getListenerCount(): number;
+}
+export declare function createSubscriberFanout(): SubscriberFanoutHandle;
+//# sourceMappingURL=subscriber-fanout.d.ts.map

package/dist/runtime/adapter/subscriber-fanout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subscriber-fanout.d.ts","sourceRoot":"","sources":["../../../src/runtime/adapter/subscriber-fanout.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAEpE,MAAM,MAAM,oBAAoB,GAAG,CAClC,OAAO,EAAE,SAAS,mBAAmB,EAAE,KACnC,IAAI,CAAC;AAEV,MAAM,WAAW,sBAAsB;IACtC,IAAI,CAAC,OAAO,EAAE,SAAS,mBAAmB,EAAE,GAAG,IAAI,CAAC;IACpD,SAAS,CAAC,QAAQ,EAAE,oBAAoB,GAAG,MAAM,IAAI,CAAC;IACtD,OAAO,IAAI,IAAI,CAAC;IAChB,gBAAgB,IAAI,MAAM,CAAC;CAC3B;AAED,wBAAgB,sBAAsB,IAAI,sBAAsB,CAmC/D"}

package/dist/runtime/adapter/subscriber-fanout.js

@@ -0,0 +1,60 @@
+/**
+ * Subscriber fan-out for the section runtime engine adapter (M7 — Variant
+ * C, layered).
+ *
+ * The adapter exposes a single `subscribe(listener)` channel for hosts
+ * that want a synchronous stream of `SectionEngineOutput[]` batches —
+ * one batch per `core.dispatch(input)` call.
+ *
+ * **Why not reuse `SectionEngineCore.subscribe` directly.** The core
+ * channel is the engine's internal contract. The fan-out is the
+ * adapter's public channel: it is the single seam every facade method
+ * goes through, and the only seam that ever sees host-side errors. The
+ * separation lets us swap the core implementation (or skip it for
+ * tests) without changing the public subscriber shape.
+ *
+ * **Subscriber contract.** Mirrors `SectionEngineCore.subscribe`:
+ *   - Listeners are invoked synchronously, in registration order.
+ *   - A listener that throws is caught and `console.warn`-logged. Fan-out
+ *     is not interrupted — same isolation guarantee as
+ *     `FrameworkErrorBus`.
+ *   - The disposer returned from `subscribe` is idempotent.
+ *   - Listeners receive a frozen, defensively-copied output array.
+ *   - There is no replay; subscribe at adapter construction time if you
+ *     need every output from `idle` onward.
+ */
+export function createSubscriberFanout() {
+    const listeners = new Set();
+    function emit(outputs) {
+        if (outputs.length === 0)
+            return;
+        const snapshot = Array.from(listeners);
+        const frozen = Object.freeze(outputs.slice());
+        for (const listener of snapshot) {
+            try {
+                listener(frozen);
+            }
+            catch (error) {
+                console.warn("[SubscriberFanout] listener failed:", error);
+            }
+        }
+    }
+    function subscribe(listener) {
+        listeners.add(listener);
+        let attached = true;
+        return () => {
+            if (!attached)
+                return;
+            attached = false;
+            listeners.delete(listener);
+        };
+    }
+    function dispose() {
+        listeners.clear();
+    }
+    function getListenerCount() {
+        return listeners.size;
+    }
+    return { emit, subscribe, dispose, getListenerCount };
+}
+//# sourceMappingURL=subscriber-fanout.js.map

package/dist/runtime/adapter/subscriber-fanout.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"subscriber-fanout.js","sourceRoot":"","sources":["../../../src/runtime/adapter/subscriber-fanout.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAeH,MAAM,UAAU,sBAAsB;IACrC,MAAM,SAAS,GAAG,IAAI,GAAG,EAAwB,CAAC;IAElD,SAAS,IAAI,CAAC,OAAuC;QACpD,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO;QACjC,MAAM,QAAQ,GAAG,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QACvC,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC,CAAC;QAC9C,KAAK,MAAM,QAAQ,IAAI,QAAQ,EAAE,CAAC;YACjC,IAAI,CAAC;gBACJ,QAAQ,CAAC,MAAM,CAAC,CAAC;YAClB,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBAChB,OAAO,CAAC,IAAI,CAAC,qCAAqC,EAAE,KAAK,CAAC,CAAC;YAC5D,CAAC;QACF,CAAC;IACF,CAAC;IAED,SAAS,SAAS,CAAC,QAA8B;QAChD,SAAS,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QACxB,IAAI,QAAQ,GAAG,IAAI,CAAC;QACpB,OAAO,GAAG,EAAE;YACX,IAAI,CAAC,QAAQ;gBAAE,OAAO;YACtB,QAAQ,GAAG,KAAK,CAAC;YACjB,SAAS,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QAC5B,CAAC,CAAC;IACH,CAAC;IAED,SAAS,OAAO;QACf,SAAS,CAAC,KAAK,EAAE,CAAC;IACnB,CAAC;IAED,SAAS,gBAAgB;QACxB,OAAO,SAAS,CAAC,IAAI,CAAC;IACvB,CAAC;IAED,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,gBAAgB,EAAE,CAAC;AACvD,CAAC"}

package/dist/runtime/core/SectionEngineCore.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Section runtime engine — pure core (M7 — Variant C, layered).
+ *
+ * `SectionEngineCore` is a thin object oriented wrapper over the pure
+ * `transition()` function. It owns the current `SectionEngineState`,
+ * applies inputs serially, and fans out the resulting
+ * `SectionEngineOutput[]` to subscribers. There is no DOM, Svelte,
+ * coordinator, or timing dependency in this module — all I/O lives in
+ * the adapter layer (PR 2).
+ *
+ * Lifetime model:
+ *   - One instance per cohort logical lifetime. Cohort changes happen
+ *     through `dispatch({ kind: "cohort-change" })`, not through
+ *     re-construction.
+ *   - After a `dispose` input, additional inputs are no-ops (the
+ *     transition handles this), but subscribers stay attached so the
+ *     adapter can still deliver final cleanup outputs.
+ *
+ * Subscriber contract:
+ *   - Listeners are invoked synchronously, in registration order.
+ *   - A throwing listener is caught and `console.warn`-logged. Fan-out
+ *     is not interrupted — same isolation guarantee as
+ *     `FrameworkErrorBus`.
+ *   - The disposer returned from `subscribe` is idempotent.
+ *   - Listeners receive only the output array. State snapshots are
+ *     read via `getState()` for callers that need them.
+ */
+import type { SectionEngineInput } from "./engine-input.js";
+import type { SectionEngineOutput } from "./engine-output.js";
+import { type SectionEngineState } from "./engine-state.js";
+export type SectionEngineCoreListener = (outputs: readonly SectionEngineOutput[]) => void;
+export declare class SectionEngineCore {
+    private state;
+    private readonly listeners;
+    /** Read-only state snapshot. Callers must not mutate the returned object. */
+    getState(): Readonly<SectionEngineState>;
+    /**
+     * Apply one input. Returns the outputs that resulted from the
+     * transition; subscribers also receive them.
+     */
+    dispatch(input: SectionEngineInput): readonly SectionEngineOutput[];
+    /**
+     * Subscribe to engine outputs. Returns an idempotent disposer.
+     * Listeners do not receive a replay of past outputs; subscribe at
+     * construction time if you need every output from `idle` onward.
+     */
+    subscribe(listener: SectionEngineCoreListener): () => void;
+    /** Test-only: detach every listener. */
+    disposeListeners(): void;
+    private fanOut;
+}
+//# sourceMappingURL=SectionEngineCore.d.ts.map

package/dist/runtime/core/SectionEngineCore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SectionEngineCore.d.ts","sourceRoot":"","sources":["../../../src/runtime/core/SectionEngineCore.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAC5D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAC9D,OAAO,EAEN,KAAK,kBAAkB,EACvB,MAAM,mBAAmB,CAAC;AAG3B,MAAM,MAAM,yBAAyB,GAAG,CACvC,OAAO,EAAE,SAAS,mBAAmB,EAAE,KACnC,IAAI,CAAC;AAEV,qBAAa,iBAAiB;IAC7B,OAAO,CAAC,KAAK,CAAkD;IAC/D,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAwC;IAElE,6EAA6E;IAC7E,QAAQ,IAAI,QAAQ,CAAC,kBAAkB,CAAC;IAIxC;;;OAGG;IACH,QAAQ,CAAC,KAAK,EAAE,kBAAkB,GAAG,SAAS,mBAAmB,EAAE;IASnE;;;;OAIG;IACH,SAAS,CAAC,QAAQ,EAAE,yBAAyB,GAAG,MAAM,IAAI;IAU1D,wCAAwC;IACxC,gBAAgB,IAAI,IAAI;IAIxB,OAAO,CAAC,MAAM;CAWd"}

package/dist/runtime/core/SectionEngineCore.js

@@ -0,0 +1,81 @@
+/**
+ * Section runtime engine — pure core (M7 — Variant C, layered).
+ *
+ * `SectionEngineCore` is a thin object oriented wrapper over the pure
+ * `transition()` function. It owns the current `SectionEngineState`,
+ * applies inputs serially, and fans out the resulting
+ * `SectionEngineOutput[]` to subscribers. There is no DOM, Svelte,
+ * coordinator, or timing dependency in this module — all I/O lives in
+ * the adapter layer (PR 2).
+ *
+ * Lifetime model:
+ *   - One instance per cohort logical lifetime. Cohort changes happen
+ *     through `dispatch({ kind: "cohort-change" })`, not through
+ *     re-construction.
+ *   - After a `dispose` input, additional inputs are no-ops (the
+ *     transition handles this), but subscribers stay attached so the
+ *     adapter can still deliver final cleanup outputs.
+ *
+ * Subscriber contract:
+ *   - Listeners are invoked synchronously, in registration order.
+ *   - A throwing listener is caught and `console.warn`-logged. Fan-out
+ *     is not interrupted — same isolation guarantee as
+ *     `FrameworkErrorBus`.
+ *   - The disposer returned from `subscribe` is idempotent.
+ *   - Listeners receive only the output array. State snapshots are
+ *     read via `getState()` for callers that need them.
+ */
+import { createInitialEngineState, } from "./engine-state.js";
+import { transition } from "./engine-transition.js";
+export class SectionEngineCore {
+    state = createInitialEngineState();
+    listeners = new Set();
+    /** Read-only state snapshot. Callers must not mutate the returned object. */
+    getState() {
+        return this.state;
+    }
+    /**
+     * Apply one input. Returns the outputs that resulted from the
+     * transition; subscribers also receive them.
+     */
+    dispatch(input) {
+        const result = transition(this.state, input);
+        this.state = result.state;
+        if (result.outputs.length > 0) {
+            this.fanOut(result.outputs);
+        }
+        return result.outputs;
+    }
+    /**
+     * Subscribe to engine outputs. Returns an idempotent disposer.
+     * Listeners do not receive a replay of past outputs; subscribe at
+     * construction time if you need every output from `idle` onward.
+     */
+    subscribe(listener) {
+        this.listeners.add(listener);
+        let attached = true;
+        return () => {
+            if (!attached)
+                return;
+            attached = false;
+            this.listeners.delete(listener);
+        };
+    }
+    /** Test-only: detach every listener. */
+    disposeListeners() {
+        this.listeners.clear();
+    }
+    fanOut(outputs) {
+        const snapshot = Array.from(this.listeners);
+        const frozen = Object.freeze(outputs.slice());
+        for (const listener of snapshot) {
+            try {
+                listener(frozen);
+            }
+            catch (error) {
+                console.warn("[SectionEngineCore] listener failed:", error);
+            }
+        }
+    }
+}
+//# sourceMappingURL=SectionEngineCore.js.map

package/dist/runtime/core/SectionEngineCore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SectionEngineCore.js","sourceRoot":"","sources":["../../../src/runtime/core/SectionEngineCore.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAIH,OAAO,EACN,wBAAwB,GAExB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAMpD,MAAM,OAAO,iBAAiB;IACrB,KAAK,GAAuB,wBAAwB,EAAE,CAAC;IAC9C,SAAS,GAAG,IAAI,GAAG,EAA6B,CAAC;IAElE,6EAA6E;IAC7E,QAAQ;QACP,OAAO,IAAI,CAAC,KAAK,CAAC;IACnB,CAAC;IAED;;;OAGG;IACH,QAAQ,CAAC,KAAyB;QACjC,MAAM,MAAM,GAAG,UAAU,CAAC,IAAI,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;QAC7C,IAAI,CAAC,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC;QAC1B,IAAI,MAAM,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC/B,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;QAC7B,CAAC;QACD,OAAO,MAAM,CAAC,OAAO,CAAC;IACvB,CAAC;IAED;;;;OAIG;IACH,SAAS,CAAC,QAAmC;QAC5C,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QAC7B,IAAI,QAAQ,GAAG,IAAI,CAAC;QACpB,OAAO,GAAG,EAAE;YACX,IAAI,CAAC,QAAQ;gBAAE,OAAO;YACtB,QAAQ,GAAG,KAAK,CAAC;YACjB,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QACjC,CAAC,CAAC;IACH,CAAC;IAED,wCAAwC;IACxC,gBAAgB;QACf,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,CAAC;IACxB,CAAC;IAEO,MAAM,CAAC,OAA8B;QAC5C,MAAM,QAAQ,GAAG,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QAC5C,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC,CAAC;QAC9C,KAAK,MAAM,QAAQ,IAAI,QAAQ,EAAE,CAAC;YACjC,IAAI,CAAC;gBACJ,QAAQ,CAAC,MAAM,CAAC,CAAC;YAClB,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBAChB,OAAO,CAAC,IAAI,CAAC,sCAAsC,EAAE,KAAK,CAAC,CAAC;YAC7D,CAAC;QACF,CAAC;IACF,CAAC;CACD"}

package/dist/runtime/core/cohort.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Cohort identity for the section runtime engine (M7).
+ *
+ * One cohort is the tuple `(sectionId, attemptId)` for the section the
+ * host is currently rendering. Stage progression, readiness latches, and
+ * `pie-loading-complete` emission are all gated on this tuple — when it
+ * changes, the engine emits `disposed` for the outgoing cohort and
+ * resets to `composed` for the new one.
+ *
+ * `attemptId` is optional in the public surface (per the toolkit /
+ * layout-CE prop shape) but the engine carries it as the empty string
+ * when absent so the cohort key is total.
+ */
+export interface CohortKey {
+    /** Section identifier; required for any non-idle cohort. */
+    sectionId: string;
+    /** Attempt identifier; empty string if the host did not provide one. */
+    attemptId: string;
+}
+/**
+ * Stable string form of the cohort tuple used as a key for the
+ * `loadingCompleteEmittedForCohort` latch and equality checks.
+ */
+export declare function cohortKey(cohort: CohortKey | null): string;
+/**
+ * `true` iff the two cohorts have the same `(sectionId, attemptId)` pair.
+ * Treats both inputs as identifying the cohort by value, never by
+ * reference.
+ */
+export declare function cohortsEqual(a: CohortKey | null, b: CohortKey | null): boolean;
+/**
+ * Normalize host-provided `(sectionId, attemptId)` into a cohort. Returns
+ * `null` when the section identifier is empty — that is the engine's
+ * idle state (no cohort).
+ */
+export declare function makeCohort(args: {
+    sectionId: string | null | undefined;
+    attemptId: string | null | undefined;
+}): CohortKey | null;
+//# sourceMappingURL=cohort.d.ts.map

package/dist/runtime/core/cohort.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cohort.d.ts","sourceRoot":"","sources":["../../../src/runtime/core/cohort.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,MAAM,WAAW,SAAS;IACzB,4DAA4D;IAC5D,SAAS,EAAE,MAAM,CAAC;IAClB,wEAAwE;IACxE,SAAS,EAAE,MAAM,CAAC;CAClB;AAED;;;GAGG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,GAAG,MAAM,CAG1D;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,SAAS,GAAG,IAAI,EAAE,CAAC,EAAE,SAAS,GAAG,IAAI,GAAG,OAAO,CAI9E;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE;IAChC,SAAS,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IACrC,SAAS,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;CACrC,GAAG,SAAS,GAAG,IAAI,CAOnB"}

package/dist/runtime/core/cohort.js

@@ -0,0 +1,49 @@
+/**
+ * Cohort identity for the section runtime engine (M7).
+ *
+ * One cohort is the tuple `(sectionId, attemptId)` for the section the
+ * host is currently rendering. Stage progression, readiness latches, and
+ * `pie-loading-complete` emission are all gated on this tuple — when it
+ * changes, the engine emits `disposed` for the outgoing cohort and
+ * resets to `composed` for the new one.
+ *
+ * `attemptId` is optional in the public surface (per the toolkit /
+ * layout-CE prop shape) but the engine carries it as the empty string
+ * when absent so the cohort key is total.
+ */
+/**
+ * Stable string form of the cohort tuple used as a key for the
+ * `loadingCompleteEmittedForCohort` latch and equality checks.
+ */
+export function cohortKey(cohort) {
+    if (!cohort)
+        return "";
+    return `${cohort.sectionId}|${cohort.attemptId}`;
+}
+/**
+ * `true` iff the two cohorts have the same `(sectionId, attemptId)` pair.
+ * Treats both inputs as identifying the cohort by value, never by
+ * reference.
+ */
+export function cohortsEqual(a, b) {
+    if (a === b)
+        return true;
+    if (!a || !b)
+        return false;
+    return a.sectionId === b.sectionId && a.attemptId === b.attemptId;
+}
+/**
+ * Normalize host-provided `(sectionId, attemptId)` into a cohort. Returns
+ * `null` when the section identifier is empty — that is the engine's
+ * idle state (no cohort).
+ */
+export function makeCohort(args) {
+    const sectionId = args.sectionId ?? "";
+    if (!sectionId)
+        return null;
+    return {
+        sectionId,
+        attemptId: args.attemptId ?? "",
+    };
+}
+//# sourceMappingURL=cohort.js.map

package/dist/runtime/core/cohort.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cohort.js","sourceRoot":"","sources":["../../../src/runtime/core/cohort.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AASH;;;GAGG;AACH,MAAM,UAAU,SAAS,CAAC,MAAwB;IACjD,IAAI,CAAC,MAAM;QAAE,OAAO,EAAE,CAAC;IACvB,OAAO,GAAG,MAAM,CAAC,SAAS,IAAI,MAAM,CAAC,SAAS,EAAE,CAAC;AAClD,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,YAAY,CAAC,CAAmB,EAAE,CAAmB;IACpE,IAAI,CAAC,KAAK,CAAC;QAAE,OAAO,IAAI,CAAC;IACzB,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC;QAAE,OAAO,KAAK,CAAC;IAC3B,OAAO,CAAC,CAAC,SAAS,KAAK,CAAC,CAAC,SAAS,IAAI,CAAC,CAAC,SAAS,KAAK,CAAC,CAAC,SAAS,CAAC;AACnE,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,UAAU,CAAC,IAG1B;IACA,MAAM,SAAS,GAAG,IAAI,CAAC,SAAS,IAAI,EAAE,CAAC;IACvC,IAAI,CAAC,SAAS;QAAE,OAAO,IAAI,CAAC;IAC5B,OAAO;QACN,SAAS;QACT,SAAS,EAAE,IAAI,CAAC,SAAS,IAAI,EAAE;KAC/B,CAAC;AACH,CAAC"}

package/dist/runtime/core/engine-input.d.ts

@@ -0,0 +1,114 @@
+/**
+ * Section runtime engine inputs (M7 — Variant C, layered core).
+ *
+ * Inputs are the discriminated union of events the adapter (PR 2) feeds
+ * into the pure transition function (`engine-transition.ts`). The shape
+ * is closed: every field is plain data so the transition can be tested
+ * without any DOM, Svelte, or coordinator wiring.
+ *
+ * Adapter→core boundary contract:
+ *   - The adapter never mutates engine state directly. It always
+ *     constructs an input and calls `core.dispatch(input)`.
+ *   - Inputs are total: an unhandled `kind` is a programming error
+ *     (the transition uses `assertNever` exhaustiveness).
+ *   - Inputs carry only data, never live host references that would
+ *     pin lifetime. Coordinator and controller handles live in the
+ *     adapter; the core only sees readiness signals derived from them.
+ */
+import type { CohortKey } from "./cohort.js";
+import type { EffectiveRuntime, RuntimeInputs } from "./engine-resolver.js";
+import type { EngineReadinessSignals } from "./engine-readiness.js";
+import type { FrameworkErrorModel } from "../../services/framework-error.js";
+/**
+ * `initialize` is the first transition out of `idle`. It carries the
+ * cohort key and the resolved runtime/tools snapshot for the cohort.
+ * The adapter constructs this input after running the resolver against
+ * the host's two-tier inputs.
+ */
+export type EngineInputInitialize = {
+    kind: "initialize";
+    cohort: CohortKey;
+    effectiveRuntime: EffectiveRuntime;
+    effectiveToolsConfig: unknown;
+    itemCount: number;
+};
+/**
+ * `update-runtime` is sent when the host two-tier inputs change but
+ * the cohort does not. The transition stores the latest resolver
+ * output without changing phase; readiness gates and stage progression
+ * stay where they are.
+ */
+export type EngineInputUpdateRuntime = {
+    kind: "update-runtime";
+    effectiveRuntime: EffectiveRuntime;
+    effectiveToolsConfig: unknown;
+};
+/**
+ * `cohort-change` is sent when `(sectionId, attemptId)` changes. The
+ * transition emits `disposed` for the outgoing cohort, resets state
+ * to `booting-section` for the new one, and re-arms latches.
+ */
+export type EngineInputCohortChange = {
+    kind: "cohort-change";
+    cohort: CohortKey;
+    effectiveRuntime: EffectiveRuntime;
+    effectiveToolsConfig: unknown;
+    itemCount: number;
+};
+/**
+ * `section-controller-resolved` is sent when the coordinator returns
+ * the controller for the current cohort. Advances the phase from
+ * `booting-section` → `engine-ready` (assuming `composed` is already
+ * implied by `phase >= booting-section`, which the FSM treats as
+ * monotonic).
+ */
+export type EngineInputSectionControllerResolved = {
+    kind: "section-controller-resolved";
+};
+/**
+ * `update-readiness-signals` carries the latest readiness snapshot
+ * from the host. The transition uses it to gate the move into
+ * `interactive` and to decide whether to emit `loading-complete`.
+ *
+ * The full signal set is sent every time so the transition does not
+ * have to reason about partial overlays.
+ */
+export type EngineInputUpdateReadinessSignals = {
+    kind: "update-readiness-signals";
+    signals: EngineReadinessSignals;
+    loadedCount: number;
+    itemCount: number;
+    /**
+     * Strict-mode gate. When `"strict"`, `interactive` only fires
+     * after `allLoadingComplete`; in `"progressive"`, `interactionReady`
+     * is sufficient. Carried per-input so the host can reconfigure
+     * mode mid-cohort without re-initializing.
+     */
+    mode: "progressive" | "strict";
+};
+/**
+ * `framework-error` is sent for every framework-error report (M3
+ * canonical channel). The transition records the latest error in
+ * state and emits a `framework-error` output so the adapter can fan
+ * out to subscribers and the DOM event.
+ */
+export type EngineInputFrameworkError = {
+    kind: "framework-error";
+    error: FrameworkErrorModel;
+};
+/**
+ * `dispose` tears the engine down. Emits `disposed` for the current
+ * cohort (if any) and moves to the terminal `disposed` phase. After
+ * dispose the engine accepts no further inputs (the transition logs
+ * a warning and is a no-op).
+ */
+export type EngineInputDispose = {
+    kind: "dispose";
+};
+export type SectionEngineInput = EngineInputInitialize | EngineInputUpdateRuntime | EngineInputCohortChange | EngineInputSectionControllerResolved | EngineInputUpdateReadinessSignals | EngineInputFrameworkError | EngineInputDispose;
+/**
+ * Convenience re-export so the adapter can import `RuntimeInputs`
+ * from a single place when it constructs `initialize` inputs.
+ */
+export type { RuntimeInputs };
+//# sourceMappingURL=engine-input.d.ts.map

package/dist/runtime/core/engine-input.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine-input.d.ts","sourceRoot":"","sources":["../../../src/runtime/core/engine-input.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAC7C,OAAO,KAAK,EACX,gBAAgB,EAChB,aAAa,EACb,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAC;AACpE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,mCAAmC,CAAC;AAE7E;;;;;GAKG;AACH,MAAM,MAAM,qBAAqB,GAAG;IACnC,IAAI,EAAE,YAAY,CAAC;IACnB,MAAM,EAAE,SAAS,CAAC;IAClB,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,oBAAoB,EAAE,OAAO,CAAC;IAC9B,SAAS,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF;;;;;GAKG;AACH,MAAM,MAAM,wBAAwB,GAAG;IACtC,IAAI,EAAE,gBAAgB,CAAC;IACvB,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,oBAAoB,EAAE,OAAO,CAAC;CAC9B,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,uBAAuB,GAAG;IACrC,IAAI,EAAE,eAAe,CAAC;IACtB,MAAM,EAAE,SAAS,CAAC;IAClB,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,oBAAoB,EAAE,OAAO,CAAC;IAC9B,SAAS,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,MAAM,oCAAoC,GAAG;IAClD,IAAI,EAAE,6BAA6B,CAAC;CACpC,CAAC;AAEF;;;;;;;GAOG;AACH,MAAM,MAAM,iCAAiC,GAAG;IAC/C,IAAI,EAAE,0BAA0B,CAAC;IACjC,OAAO,EAAE,sBAAsB,CAAC;IAChC,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB;;;;;OAKG;IACH,IAAI,EAAE,aAAa,GAAG,QAAQ,CAAC;CAC/B,CAAC;AAEF;;;;;GAKG;AACH,MAAM,MAAM,yBAAyB,GAAG;IACvC,IAAI,EAAE,iBAAiB,CAAC;IACxB,KAAK,EAAE,mBAAmB,CAAC;CAC3B,CAAC;AAEF;;;;;GAKG;AACH,MAAM,MAAM,kBAAkB,GAAG;IAChC,IAAI,EAAE,SAAS,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAC3B,qBAAqB,GACrB,wBAAwB,GACxB,uBAAuB,GACvB,oCAAoC,GACpC,iCAAiC,GACjC,yBAAyB,GACzB,kBAAkB,CAAC;AAEtB;;;GAGG;AACH,YAAY,EAAE,aAAa,EAAE,CAAC"}

package/dist/runtime/core/engine-input.js

@@ -0,0 +1,19 @@
+/**
+ * Section runtime engine inputs (M7 — Variant C, layered core).
+ *
+ * Inputs are the discriminated union of events the adapter (PR 2) feeds
+ * into the pure transition function (`engine-transition.ts`). The shape
+ * is closed: every field is plain data so the transition can be tested
+ * without any DOM, Svelte, or coordinator wiring.
+ *
+ * Adapter→core boundary contract:
+ *   - The adapter never mutates engine state directly. It always
+ *     constructs an input and calls `core.dispatch(input)`.
+ *   - Inputs are total: an unhandled `kind` is a programming error
+ *     (the transition uses `assertNever` exhaustiveness).
+ *   - Inputs carry only data, never live host references that would
+ *     pin lifetime. Coordinator and controller handles live in the
+ *     adapter; the core only sees readiness signals derived from them.
+ */
+export {};
+//# sourceMappingURL=engine-input.js.map

package/dist/runtime/core/engine-input.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine-input.js","sourceRoot":"","sources":["../../../src/runtime/core/engine-input.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG"}