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

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

@@ -0,0 +1,83 @@
+/**
+ * Section runtime engine state (M7 — Variant C, layered core).
+ *
+ * The state object is the single source of truth for stage, cohort,
+ * readiness signals, and the resolved coordinator/controller handles
+ * across one engine instance. The transition function in
+ * `engine-transition.ts` is the only legal mutator; the adapter (M7
+ * PR 2) reads the state via `SectionEngineCore.getState()` and emits
+ * the bundled `SectionEngineOutput[]` to its bridges.
+ *
+ * Phases (the FSM). Adjustment A2 of the M7 implementation plan locks
+ * this list to four phases that map 1:1 onto the M6 canonical stages:
+ *
+ *   `idle`             → no cohort yet (before `initialize`).
+ *   `booting-section`  → cohort known, controller resolution pending. Maps to stage `composed`.
+ *   `engine-ready`     → controller resolved. Maps to stage `engine-ready`.
+ *   `interactive`      → readiness gate satisfied. Maps to stage `interactive`.
+ *   `disposed`         → engine torn down. Maps to stage `disposed`.
+ *
+ * `loading-complete` is intentionally **not** an FSM phase — it is a
+ * `SectionEngineOutput` emitted from the `interactive` phase when the
+ * readiness signals satisfy `allLoadingComplete`. See
+ * `engine-output.ts` for the output shape and the implementation
+ * plan's Adjustment A2 fence.
+ */
+import type { CohortKey } from "./cohort.js";
+import type { EffectiveRuntime } from "./engine-resolver.js";
+import type { EngineReadinessSignals } from "./engine-readiness.js";
+import type { FrameworkErrorModel } from "../../services/framework-error.js";
+export type SectionEnginePhase = "idle" | "booting-section" | "engine-ready" | "interactive" | "disposed";
+export type SectionEngineState = {
+    /** Current FSM phase. The single source of truth for stage derivation. */
+    phase: SectionEnginePhase;
+    /**
+     * Active cohort, or `null` when the engine is `idle` or `disposed`.
+     * `phase === "idle"` always implies `cohort === null`. A non-idle,
+     * non-disposed phase always has a cohort.
+     */
+    cohort: CohortKey | null;
+    /**
+     * Whether the host has reported the section controller is resolved.
+     * Latched by the `section-controller-resolved` input; the
+     * transition uses it (along with `phase >= booting-section`) to
+     * advance into `engine-ready`.
+     */
+    controllerResolved: boolean;
+    /**
+     * Readiness signal snapshot. Updated by `update-readiness-signals`
+     * inputs from the host (kernel) — the engine itself does not
+     * compute these from scratch in PR 1. Strict-mode gating is
+     * applied at derivation time via `createReadinessDetail`, not by
+     * mutating the signals.
+     */
+    readinessSignals: EngineReadinessSignals;
+    /** Last resolved effective runtime (output of `resolveRuntime`). */
+    effectiveRuntime: EffectiveRuntime | null;
+    /** Last resolved tools config. */
+    effectiveToolsConfig: unknown;
+    /**
+     * `true` once the engine has emitted `loading-complete` for the
+     * current cohort. Re-armed on cohort change. The single-shot
+     * semantics of the canonical `pie-loading-complete` event are
+     * preserved by gating emission on this flag in the transition.
+     */
+    loadingCompleteEmitted: boolean;
+    /**
+     * Most recent framework error, if any. The engine routes errors
+     * through outputs, not through state — this field is kept so
+     * subscribers asking for the latest snapshot (e.g. error banners)
+     * can read it without replaying the output stream.
+     */
+    lastFrameworkError: FrameworkErrorModel | null;
+    /** Number of items the host has registered for the current cohort. */
+    itemCount: number;
+    /** Number of items reported as loaded. */
+    loadedCount: number;
+};
+/**
+ * Initial state. Kept as a function so callers cannot mutate a shared
+ * default by reference.
+ */
+export declare function createInitialEngineState(): SectionEngineState;
+//# sourceMappingURL=engine-state.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"engine-state.d.ts","sourceRoot":"","sources":["../../../src/runtime/core/engine-state.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAC7C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAC7D,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAC;AACpE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,mCAAmC,CAAC;AAE7E,MAAM,MAAM,kBAAkB,GAC3B,MAAM,GACN,iBAAiB,GACjB,cAAc,GACd,aAAa,GACb,UAAU,CAAC;AAEd,MAAM,MAAM,kBAAkB,GAAG;IAChC,0EAA0E;IAC1E,KAAK,EAAE,kBAAkB,CAAC;IAE1B;;;;OAIG;IACH,MAAM,EAAE,SAAS,GAAG,IAAI,CAAC;IAEzB;;;;;OAKG;IACH,kBAAkB,EAAE,OAAO,CAAC;IAE5B;;;;;;OAMG;IACH,gBAAgB,EAAE,sBAAsB,CAAC;IAEzC,oEAAoE;IACpE,gBAAgB,EAAE,gBAAgB,GAAG,IAAI,CAAC;IAE1C,kCAAkC;IAClC,oBAAoB,EAAE,OAAO,CAAC;IAE9B;;;;;OAKG;IACH,sBAAsB,EAAE,OAAO,CAAC;IAEhC;;;;;OAKG;IACH,kBAAkB,EAAE,mBAAmB,GAAG,IAAI,CAAC;IAE/C,sEAAsE;IACtE,SAAS,EAAE,MAAM,CAAC;IAElB,0CAA0C;IAC1C,WAAW,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF;;;GAGG;AACH,wBAAgB,wBAAwB,IAAI,kBAAkB,CAkB7D"}

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

@@ -0,0 +1,49 @@
+/**
+ * Section runtime engine state (M7 — Variant C, layered core).
+ *
+ * The state object is the single source of truth for stage, cohort,
+ * readiness signals, and the resolved coordinator/controller handles
+ * across one engine instance. The transition function in
+ * `engine-transition.ts` is the only legal mutator; the adapter (M7
+ * PR 2) reads the state via `SectionEngineCore.getState()` and emits
+ * the bundled `SectionEngineOutput[]` to its bridges.
+ *
+ * Phases (the FSM). Adjustment A2 of the M7 implementation plan locks
+ * this list to four phases that map 1:1 onto the M6 canonical stages:
+ *
+ *   `idle`             → no cohort yet (before `initialize`).
+ *   `booting-section`  → cohort known, controller resolution pending. Maps to stage `composed`.
+ *   `engine-ready`     → controller resolved. Maps to stage `engine-ready`.
+ *   `interactive`      → readiness gate satisfied. Maps to stage `interactive`.
+ *   `disposed`         → engine torn down. Maps to stage `disposed`.
+ *
+ * `loading-complete` is intentionally **not** an FSM phase — it is a
+ * `SectionEngineOutput` emitted from the `interactive` phase when the
+ * readiness signals satisfy `allLoadingComplete`. See
+ * `engine-output.ts` for the output shape and the implementation
+ * plan's Adjustment A2 fence.
+ */
+/**
+ * Initial state. Kept as a function so callers cannot mutate a shared
+ * default by reference.
+ */
+export function createInitialEngineState() {
+    return {
+        phase: "idle",
+        cohort: null,
+        controllerResolved: false,
+        readinessSignals: {
+            sectionReady: false,
+            interactionReady: false,
+            allLoadingComplete: false,
+            runtimeError: false,
+        },
+        effectiveRuntime: null,
+        effectiveToolsConfig: null,
+        loadingCompleteEmitted: false,
+        lastFrameworkError: null,
+        itemCount: 0,
+        loadedCount: 0,
+    };
+}
+//# sourceMappingURL=engine-state.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"engine-state.js","sourceRoot":"","sources":["../../../src/runtime/core/engine-state.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAuEH;;;GAGG;AACH,MAAM,UAAU,wBAAwB;IACvC,OAAO;QACN,KAAK,EAAE,MAAM;QACb,MAAM,EAAE,IAAI;QACZ,kBAAkB,EAAE,KAAK;QACzB,gBAAgB,EAAE;YACjB,YAAY,EAAE,KAAK;YACnB,gBAAgB,EAAE,KAAK;YACvB,kBAAkB,EAAE,KAAK;YACzB,YAAY,EAAE,KAAK;SACnB;QACD,gBAAgB,EAAE,IAAI;QACtB,oBAAoB,EAAE,IAAI;QAC1B,sBAAsB,EAAE,KAAK;QAC7B,kBAAkB,EAAE,IAAI;QACxB,SAAS,EAAE,CAAC;QACZ,WAAW,EAAE,CAAC;KACd,CAAC;AACH,CAAC"}

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

@@ -0,0 +1,49 @@
+/**
+ * Pure transition function for the section runtime engine (M7 — Variant
+ * C, layered core).
+ *
+ * `transition(state, input)` is total over `(state, input)` pairs and
+ * returns:
+ *   - the next `SectionEngineState` (immutable; the input state object
+ *     is never mutated);
+ *   - the ordered list of `SectionEngineOutput`s the adapter must
+ *     dispatch (DOM events, framework-error fan-out, etc.).
+ *
+ * The function imports nothing from Svelte, the DOM, or the
+ * coordinator. The `core/` constraint is enforced by the per-PR audit
+ * step in the M7 implementation plan.
+ *
+ * Phase machine (per `engine-state.ts`):
+ *   idle → booting-section → engine-ready → interactive → disposed
+ *   (cohort-change rolls back to booting-section for the new cohort
+ *    after emitting `disposed` for the outgoing cohort)
+ *
+ * Output ordering invariants:
+ *   1. `stage-change` for stage advancement fires before any
+ *      `loading-complete` triggered by the same input.
+ *   2. `loading-complete` fires once per cohort, gated on
+ *      `state.loadingCompleteEmitted`.
+ *   3. `framework-error` outputs are independent of the stage chain
+ *      and do not move the phase.
+ *
+ * The deprecated readiness output kinds (`readiness-change`,
+ * `interaction-ready`, `ready`) and their DOM-event bridge were
+ * removed in the broad architecture review compat sweep. Hosts that
+ * need the readiness detail read it via the kernel's `selectReadiness`
+ * / `getSnapshot` selectors or via `SectionEngineCore.getState()`.
+ */
+import type { SectionEngineInput } from "./engine-input.js";
+import type { SectionEngineOutput } from "./engine-output.js";
+import { type SectionEngineState } from "./engine-state.js";
+export interface TransitionResult {
+    state: SectionEngineState;
+    outputs: SectionEngineOutput[];
+}
+/**
+ * Pure transition. Total over `(state, input)`; never mutates inputs;
+ * never throws. Unhandled inputs after `disposed` fall through to a
+ * no-op (the adapter is responsible for not feeding them in, but the
+ * core stays safe by design).
+ */
+export declare function transition(state: SectionEngineState, input: SectionEngineInput): TransitionResult;
+//# sourceMappingURL=engine-transition.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"engine-transition.d.ts","sourceRoot":"","sources":["../../../src/runtime/core/engine-transition.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAGH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAC5D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAM9D,OAAO,EAGN,KAAK,kBAAkB,EACvB,MAAM,mBAAmB,CAAC;AAE3B,MAAM,WAAW,gBAAgB;IAChC,KAAK,EAAE,kBAAkB,CAAC;IAC1B,OAAO,EAAE,mBAAmB,EAAE,CAAC;CAC/B;AAqGD;;;;;GAKG;AACH,wBAAgB,UAAU,CACzB,KAAK,EAAE,kBAAkB,EACzB,KAAK,EAAE,kBAAkB,GACvB,gBAAgB,CAuJlB"}

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

@@ -0,0 +1,261 @@
+/**
+ * Pure transition function for the section runtime engine (M7 — Variant
+ * C, layered core).
+ *
+ * `transition(state, input)` is total over `(state, input)` pairs and
+ * returns:
+ *   - the next `SectionEngineState` (immutable; the input state object
+ *     is never mutated);
+ *   - the ordered list of `SectionEngineOutput`s the adapter must
+ *     dispatch (DOM events, framework-error fan-out, etc.).
+ *
+ * The function imports nothing from Svelte, the DOM, or the
+ * coordinator. The `core/` constraint is enforced by the per-PR audit
+ * step in the M7 implementation plan.
+ *
+ * Phase machine (per `engine-state.ts`):
+ *   idle → booting-section → engine-ready → interactive → disposed
+ *   (cohort-change rolls back to booting-section for the new cohort
+ *    after emitting `disposed` for the outgoing cohort)
+ *
+ * Output ordering invariants:
+ *   1. `stage-change` for stage advancement fires before any
+ *      `loading-complete` triggered by the same input.
+ *   2. `loading-complete` fires once per cohort, gated on
+ *      `state.loadingCompleteEmitted`.
+ *   3. `framework-error` outputs are independent of the stage chain
+ *      and do not move the phase.
+ *
+ * The deprecated readiness output kinds (`readiness-change`,
+ * `interaction-ready`, `ready`) and their DOM-event bridge were
+ * removed in the broad architecture review compat sweep. Hosts that
+ * need the readiness detail read it via the kernel's `selectReadiness`
+ * / `getSnapshot` selectors or via `SectionEngineCore.getState()`.
+ */
+import { cohortsEqual } from "./cohort.js";
+import { createReadinessDetail, } from "./engine-readiness.js";
+import { phaseToStage } from "./engine-stage-derivation.js";
+import { createInitialEngineState, } from "./engine-state.js";
+function emitStageChange(outputs, phase, cohort, status = "entered") {
+    const stage = phaseToStage(phase);
+    if (!stage)
+        return;
+    outputs.push({ kind: "stage-change", stage, status, cohort });
+}
+/**
+ * Transition the engine after `initialize` / `cohort-change`. Sets
+ * the new cohort, resets latches, stores the resolved runtime/tools,
+ * and emits the `composed` stage.
+ */
+function startCohort(args) {
+    const next = {
+        ...createInitialEngineState(),
+        phase: "booting-section",
+        cohort: args.cohort,
+        effectiveRuntime: args.effectiveRuntime,
+        effectiveToolsConfig: args.effectiveToolsConfig,
+        itemCount: args.itemCount,
+    };
+    const outputs = [];
+    emitStageChange(outputs, "booting-section", args.cohort);
+    return { state: next, outputs };
+}
+/**
+ * Apply a readiness update: store new signals, derive the detail in
+ * the requested mode, advance the phase to `interactive` when gated,
+ * and emit `loading-complete` once per cohort.
+ */
+function applyReadinessUpdate(state, args) {
+    if (state.phase === "idle" || state.phase === "disposed") {
+        // No cohort to update; ignore.
+        return { state, outputs: [] };
+    }
+    const detail = createReadinessDetail({
+        mode: args.mode,
+        signals: args.signals,
+    });
+    const outputs = [];
+    let phase = state.phase;
+    let loadingCompleteEmitted = state.loadingCompleteEmitted;
+    // Stage advancement: engine-ready → interactive when readiness
+    // satisfies `interactionReady` (mode-aware via `createReadinessDetail`).
+    if (phase === "engine-ready" && detail.interactionReady) {
+        phase = "interactive";
+        emitStageChange(outputs, phase, state.cohort);
+    }
+    // Canonical `loading-complete` emission. One-shot per cohort, gated
+    // on the readiness signals indicating every item has finished
+    // loading.
+    if (detail.allLoadingComplete &&
+        state.cohort &&
+        !loadingCompleteEmitted) {
+        loadingCompleteEmitted = true;
+        outputs.push({
+            kind: "loading-complete",
+            cohort: state.cohort,
+            itemCount: args.itemCount,
+            loadedCount: args.loadedCount,
+        });
+    }
+    const nextState = {
+        ...state,
+        phase,
+        readinessSignals: args.signals,
+        loadedCount: args.loadedCount,
+        itemCount: args.itemCount,
+        loadingCompleteEmitted,
+    };
+    return { state: nextState, outputs };
+}
+/**
+ * Pure transition. Total over `(state, input)`; never mutates inputs;
+ * never throws. Unhandled inputs after `disposed` fall through to a
+ * no-op (the adapter is responsible for not feeding them in, but the
+ * core stays safe by design).
+ */
+export function transition(state, input) {
+    switch (input.kind) {
+        case "initialize": {
+            if (state.phase === "disposed") {
+                // The engine has been disposed; ignore.
+                return { state, outputs: [] };
+            }
+            if (state.phase !== "idle") {
+                // Already initialized. Treat as `update-runtime` for the
+                // current cohort if the cohort matches; otherwise treat as
+                // a `cohort-change`.
+                if (cohortsEqual(state.cohort, input.cohort)) {
+                    return transition(state, {
+                        kind: "update-runtime",
+                        effectiveRuntime: input.effectiveRuntime,
+                        effectiveToolsConfig: input.effectiveToolsConfig,
+                    });
+                }
+                return transition(state, {
+                    kind: "cohort-change",
+                    cohort: input.cohort,
+                    effectiveRuntime: input.effectiveRuntime,
+                    effectiveToolsConfig: input.effectiveToolsConfig,
+                    itemCount: input.itemCount,
+                });
+            }
+            return startCohort({
+                state,
+                cohort: input.cohort,
+                effectiveRuntime: input.effectiveRuntime,
+                effectiveToolsConfig: input.effectiveToolsConfig,
+                itemCount: input.itemCount,
+            });
+        }
+        case "update-runtime": {
+            if (state.phase === "idle" || state.phase === "disposed") {
+                return { state, outputs: [] };
+            }
+            return {
+                state: {
+                    ...state,
+                    effectiveRuntime: input.effectiveRuntime,
+                    effectiveToolsConfig: input.effectiveToolsConfig,
+                },
+                outputs: [],
+            };
+        }
+        case "cohort-change": {
+            if (state.phase === "disposed") {
+                return { state, outputs: [] };
+            }
+            if (cohortsEqual(state.cohort, input.cohort)) {
+                // No-op cohort change; fall back to a runtime update.
+                return transition(state, {
+                    kind: "update-runtime",
+                    effectiveRuntime: input.effectiveRuntime,
+                    effectiveToolsConfig: input.effectiveToolsConfig,
+                });
+            }
+            const outputs = [];
+            if (state.phase !== "idle") {
+                // Emit `disposed` for the outgoing cohort before we wipe state.
+                outputs.push({
+                    kind: "stage-change",
+                    stage: "disposed",
+                    status: "entered",
+                    cohort: state.cohort,
+                });
+            }
+            const started = startCohort({
+                state,
+                cohort: input.cohort,
+                effectiveRuntime: input.effectiveRuntime,
+                effectiveToolsConfig: input.effectiveToolsConfig,
+                itemCount: input.itemCount,
+            });
+            return {
+                state: started.state,
+                outputs: [...outputs, ...started.outputs],
+            };
+        }
+        case "section-controller-resolved": {
+            if (state.phase !== "booting-section") {
+                // Either too early (idle), too late (interactive / disposed),
+                // or a duplicate notification; the FSM is monotonic.
+                return {
+                    state: { ...state, controllerResolved: true },
+                    outputs: [],
+                };
+            }
+            const outputs = [];
+            emitStageChange(outputs, "engine-ready", state.cohort);
+            return {
+                state: {
+                    ...state,
+                    phase: "engine-ready",
+                    controllerResolved: true,
+                },
+                outputs,
+            };
+        }
+        case "update-readiness-signals": {
+            return applyReadinessUpdate(state, {
+                signals: input.signals,
+                mode: input.mode,
+                loadedCount: input.loadedCount,
+                itemCount: input.itemCount,
+            });
+        }
+        case "framework-error": {
+            return {
+                state: {
+                    ...state,
+                    lastFrameworkError: input.error,
+                    readinessSignals: {
+                        ...state.readinessSignals,
+                        runtimeError: true,
+                    },
+                },
+                outputs: [{ kind: "framework-error", error: input.error }],
+            };
+        }
+        case "dispose": {
+            if (state.phase === "disposed") {
+                return { state, outputs: [] };
+            }
+            const outputs = [];
+            if (state.phase !== "idle") {
+                emitStageChange(outputs, "disposed", state.cohort);
+            }
+            return {
+                state: {
+                    ...state,
+                    phase: "disposed",
+                },
+                outputs,
+            };
+        }
+        default: {
+            const exhaustive = input;
+            void exhaustive;
+            return { state, outputs: [] };
+        }
+    }
+}
+//# sourceMappingURL=engine-transition.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"engine-transition.js","sourceRoot":"","sources":["../../../src/runtime/core/engine-transition.ts"],"names":[],"mappings":"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"}

package/dist/runtime/engine-context.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Svelte context key for the section runtime engine (M7 PR 5).
+ *
+ * Components inside a section player layout consume the engine through
+ * Svelte's native `getContext(SECTION_RUNTIME_ENGINE_KEY)`. The kernel
+ * (`SectionPlayerLayoutKernel.svelte`) is the canonical provider — it
+ * constructs the engine, attaches it to the layout CE host, and exposes
+ * it to descendants via `setContext(SECTION_RUNTIME_ENGINE_KEY, engine)`.
+ *
+ * The contract is one-directional:
+ *   - Provider: the component that owns engine lifetime (kernel today;
+ *     in M7 PR 6 the toolkit CE will fall back to constructing its own
+ *     engine when no upstream provider is present).
+ *   - Consumers: any descendant Svelte component that needs to read
+ *     state, subscribe to outputs, or feed inputs (e.g. the toolkit CE
+ *     reaching the engine through the wrapping kernel).
+ *
+ * The key is a `Symbol` so it cannot collide with userland context keys
+ * and so descendants are forced to import this module rather than
+ * guess a string id.
+ *
+ * **Stability.** This export is part of the stable runtime/engine
+ * surface; renaming or replacing the symbol is a major breaking
+ * change. Adding adjacent context keys (e.g. for dedicated read-only
+ * snapshots) is allowed.
+ */
+import type { SectionRuntimeEngine } from "./SectionRuntimeEngine.js";
+/**
+ * Svelte context key under which a `SectionRuntimeEngine` instance is
+ * provided to descendants.
+ */
+export declare const SECTION_RUNTIME_ENGINE_KEY: unique symbol;
+/**
+ * Type-level alias for the value stored under
+ * `SECTION_RUNTIME_ENGINE_KEY`. Exposed as a separate alias so
+ * consumers can spell the type without importing the implementing
+ * class directly.
+ */
+export type SectionRuntimeEngineContext = SectionRuntimeEngine;
+//# sourceMappingURL=engine-context.d.ts.map

package/dist/runtime/engine-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine-context.d.ts","sourceRoot":"","sources":["../../src/runtime/engine-context.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AAEtE;;;GAGG;AACH,eAAO,MAAM,0BAA0B,EAAE,OAAO,MAE/C,CAAC;AAEF;;;;;GAKG;AACH,MAAM,MAAM,2BAA2B,GAAG,oBAAoB,CAAC"}

package/dist/runtime/engine-context.js

@@ -0,0 +1,32 @@
+/**
+ * Svelte context key for the section runtime engine (M7 PR 5).
+ *
+ * Components inside a section player layout consume the engine through
+ * Svelte's native `getContext(SECTION_RUNTIME_ENGINE_KEY)`. The kernel
+ * (`SectionPlayerLayoutKernel.svelte`) is the canonical provider — it
+ * constructs the engine, attaches it to the layout CE host, and exposes
+ * it to descendants via `setContext(SECTION_RUNTIME_ENGINE_KEY, engine)`.
+ *
+ * The contract is one-directional:
+ *   - Provider: the component that owns engine lifetime (kernel today;
+ *     in M7 PR 6 the toolkit CE will fall back to constructing its own
+ *     engine when no upstream provider is present).
+ *   - Consumers: any descendant Svelte component that needs to read
+ *     state, subscribe to outputs, or feed inputs (e.g. the toolkit CE
+ *     reaching the engine through the wrapping kernel).
+ *
+ * The key is a `Symbol` so it cannot collide with userland context keys
+ * and so descendants are forced to import this module rather than
+ * guess a string id.
+ *
+ * **Stability.** This export is part of the stable runtime/engine
+ * surface; renaming or replacing the symbol is a major breaking
+ * change. Adding adjacent context keys (e.g. for dedicated read-only
+ * snapshots) is allowed.
+ */
+/**
+ * Svelte context key under which a `SectionRuntimeEngine` instance is
+ * provided to descendants.
+ */
+export const SECTION_RUNTIME_ENGINE_KEY = Symbol("@pie-players/section-runtime-engine");
+//# sourceMappingURL=engine-context.js.map

package/dist/runtime/engine-context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine-context.js","sourceRoot":"","sources":["../../src/runtime/engine-context.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAIH;;;GAGG;AACH,MAAM,CAAC,MAAM,0BAA0B,GAAkB,MAAM,CAC9D,qCAAqC,CACrC,CAAC"}

package/dist/runtime/engine.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Section runtime engine — facade entry point (M7 — Variant C).
+ *
+ * Narrow, stable public surface for hosts that want to mount, drive,
+ * or dispose a section runtime via the layered engine. Re-exports the
+ * `SectionRuntimeEngine` facade and its `attachHost` arg shape.
+ *
+ * **Pairing.** This module is the stable counterpart to
+ * `./runtime/internal`, which exposes the wider, evolving surface
+ * (core types, adapter bridges, cohort helpers) for advanced hosts and
+ * for the engine's own tests / benchmarks. Consumers that only need to
+ * mount + drive a section runtime should import from here. Consumers
+ * that need to reach past the facade (e.g. construct an adapter
+ * manually, inspect FSM state types, build alternate fan-out paths)
+ * should import from `./runtime/internal` and accept the documented
+ * stability disclaimer there.
+ *
+ * The package's `exports` map adds `./runtime/engine` in M7 PR 3
+ * alongside the facade refactor.
+ */
+export { SectionRuntimeEngine, type SectionRuntimeEngineHostArgs, } from "./SectionRuntimeEngine.js";
+export { SECTION_RUNTIME_ENGINE_KEY, type SectionRuntimeEngineContext, } from "./engine-context.js";
+export { sectionRuntimeEngineHostContext, connectSectionRuntimeEngineHostContext, type SectionRuntimeEngineHostContextValue, type SectionRuntimeEngineHostContextListener, } from "./section-runtime-engine-host-context.js";
+//# sourceMappingURL=engine.d.ts.map

package/dist/runtime/engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../../src/runtime/engine.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EACN,oBAAoB,EACpB,KAAK,4BAA4B,GACjC,MAAM,2BAA2B,CAAC;AAEnC,OAAO,EACN,0BAA0B,EAC1B,KAAK,2BAA2B,GAChC,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EACN,+BAA+B,EAC/B,sCAAsC,EACtC,KAAK,oCAAoC,EACzC,KAAK,uCAAuC,GAC5C,MAAM,0CAA0C,CAAC"}

package/dist/runtime/engine.js

@@ -0,0 +1,24 @@
+/**
+ * Section runtime engine — facade entry point (M7 — Variant C).
+ *
+ * Narrow, stable public surface for hosts that want to mount, drive,
+ * or dispose a section runtime via the layered engine. Re-exports the
+ * `SectionRuntimeEngine` facade and its `attachHost` arg shape.
+ *
+ * **Pairing.** This module is the stable counterpart to
+ * `./runtime/internal`, which exposes the wider, evolving surface
+ * (core types, adapter bridges, cohort helpers) for advanced hosts and
+ * for the engine's own tests / benchmarks. Consumers that only need to
+ * mount + drive a section runtime should import from here. Consumers
+ * that need to reach past the facade (e.g. construct an adapter
+ * manually, inspect FSM state types, build alternate fan-out paths)
+ * should import from `./runtime/internal` and accept the documented
+ * stability disclaimer there.
+ *
+ * The package's `exports` map adds `./runtime/engine` in M7 PR 3
+ * alongside the facade refactor.
+ */
+export { SectionRuntimeEngine, } from "./SectionRuntimeEngine.js";
+export { SECTION_RUNTIME_ENGINE_KEY, } from "./engine-context.js";
+export { sectionRuntimeEngineHostContext, connectSectionRuntimeEngineHostContext, } from "./section-runtime-engine-host-context.js";
+//# sourceMappingURL=engine.js.map

package/dist/runtime/engine.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.js","sourceRoot":"","sources":["../../src/runtime/engine.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EACN,oBAAoB,GAEpB,MAAM,2BAA2B,CAAC;AAEnC,OAAO,EACN,0BAA0B,GAE1B,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EACN,+BAA+B,EAC/B,sCAAsC,GAGtC,MAAM,0CAA0C,CAAC"}

package/dist/runtime/internal.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Section runtime engine — **internal** entry point (M7 — Variant C).
+ *
+ * Re-exports the layered core + adapter surface for advanced hosts that
+ * want to construct or inspect engines directly, and for the engine's
+ * own tests / benchmarks.
+ *
+ * **Stability posture.** This module is **not** part of the stable
+ * public API. Symbols here are subject to change between minor versions
+ * with only a changeset note. Hosts that need long-term stability
+ * should depend on the facade (`SectionRuntimeEngine` exported from
+ * `./runtime/engine`) instead.
+ *
+ * The split is intentional:
+ *   - `./runtime/engine` (PR 3) — narrow, stable facade for common
+ *     host wiring.
+ *   - `./runtime/internal` — wide, evolving surface for the kernel,
+ *     adapter tests, and any host that wants to reach past the facade.
+ *
+ * The `runtime/engine` and `runtime/internal` package `exports` map
+ * entries are added in PR 3 alongside the facade refactor.
+ */
+export { SectionEngineAdapter } from "./adapter/SectionEngineAdapter.js";
+export type { SectionEngineAdapterOptions } from "./adapter/SectionEngineAdapter.js";
+export { FrameworkErrorBus, type FrameworkErrorListener, type FrameworkErrorPort, type FrameworkErrorReporter, } from "../services/framework-error-bus.js";
+export { createCoordinatorBridge, type CoordinatorBridgeHandle, type CoordinatorBridgeOptions, type CoordinatorPort, type ResolveSectionControllerArgs, } from "./adapter/coordinator-bridge.js";
+export { createDomEventBridge, type DomEventBridgeHandle, type DomEventBridgeOptions, } from "./adapter/dom-event-bridge.js";
+export { createFrameworkErrorBridge, type FrameworkErrorBridgeHandle, type FrameworkErrorBridgeOptions, } from "./adapter/framework-error-bridge.js";
+export { createInstrumentationBridge, type InstrumentationBridgeHandle, type InstrumentationBridgeOptions, type InstrumentationHook, } from "./adapter/instrumentation-bridge.js";
+export { createSubscriberFanout, type EngineOutputListener, type SubscriberFanoutHandle, } from "./adapter/subscriber-fanout.js";
+export { SectionEngineCore } from "./core/SectionEngineCore.js";
+export type { SectionEngineCoreListener } from "./core/SectionEngineCore.js";
+export { cohortKey, cohortsEqual, makeCohort, type CohortKey, } from "./core/cohort.js";
+export type { SectionEngineInput } from "./core/engine-input.js";
+export type { SectionEngineOutput } from "./core/engine-output.js";
+export type { EngineReadinessDetail, EngineReadinessPhase, EngineReadinessSignals, } from "./core/engine-readiness.js";
+export type { SectionEnginePhase, SectionEngineState, } from "./core/engine-state.js";
+export { createInitialEngineState } from "./core/engine-state.js";
+export { phaseToStage } from "./core/engine-stage-derivation.js";
+export { DEFAULT_ASSESSMENT_ID, DEFAULT_ENV, DEFAULT_ISOLATION, DEFAULT_LAZY_INIT, DEFAULT_PLAYER_TYPE, resolveOnFrameworkError, resolveRuntime, resolveSectionEngineRuntimeState, resolveToolsConfig, type EffectiveRuntime, type FrameworkErrorHandler, type LoadingCompleteHandler, type PlayerOverrides, type RuntimeConfig, type RuntimeInputs, type StageChangeHandler, } from "./core/engine-resolver.js";
+export { createReadinessDetail, resolveReadinessPhase, } from "./core/engine-readiness.js";
+export { transition } from "./core/engine-transition.js";
+export type { TransitionResult } from "./core/engine-transition.js";
+//# sourceMappingURL=internal.d.ts.map