@invinite-org/chartlang-runtime 1.2.0 → 1.3.0

package/dist/runtimeContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"runtimeContext.d.ts","sourceRoot":"","sources":["../src/runtimeContext.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"runtimeContext.d.ts","sourceRoot":"","sources":["../src/runtimeContext.ts"],"names":[],"mappings":"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"}

package/dist/runtimeContext.js.map

@@ -1 +1 @@
-{"version":3,"file":"runtimeContext.js","sourceRoot":"","sources":["../src/runtimeContext.ts"],"names":[],"mappings":"AAAA,+DAA+D;AAC/D,+DAA+D;AA2V/D;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAuC;IACtE,OAAO,EAAE,IAAI;CAChB,CAAC","sourcesContent":["// Copyright (c) 2026 Invinite. Licensed under the MIT License.\n// See the LICENSE file in the repo root for full license text.\n\nimport type {\n    AlertConditionEmission,\n    AlertEmission,\n    Capabilities,\n    DrawingEmission,\n    LogEmission,\n    PlotEmission,\n    PlotOverride,\n    RuntimeDiagnostic,\n} from \"@invinite-org/chartlang-adapter-kit\";\nimport type {\n    AlertConditionDefinition,\n    Bar,\n    DrawingBucket,\n    DrawingCounts,\n    DrawingKind,\n    DrawingState,\n    SecurityBar,\n    Series,\n} from \"@invinite-org/chartlang-core\";\n\nimport type { DepOutputStore } from \"./dep/DepOutputStore.js\";\nimport type { PersistentStateStore } from \"./persistentStateStore.js\";\nimport type { SecurityExprRunner } from \"./request/securityExprRunner.js\";\nimport type { SeriesSlot } from \"./state/seriesSlot.js\";\nimport type { StateSlot } from \"./state/stateSlot.js\";\nimport type { StateStore } from \"./stateStore.js\";\nimport type { StreamState } from \"./streamState.js\";\nimport type { RuntimeViews } from \"./views/index.js\";\n\n/**\n * Per-handle drawing slot the runtime persists across bars. The key is\n * `slotId#subId` (compiler-injected callsite id + per-bar sub-id from\n * {@link nextSubId}). `state` holds the last full {@link DrawingState}\n * emitted for the handle; subsequent `update(patch)` calls merge into\n * it and re-emit the full payload. `removed: true`\n * is sticky — further `update` / `remove` on the handle no-op.\n *\n * `z` is the presentation-only render-order key `handle.ts`'s `splitZ`\n * lifted out of the drawing's `state.style` (default `0`). It is stored\n * **beside** `state` — never inside `state` / `state.style` — because\n * the wire carries it as the top-level {@link DrawingEmission.z} field,\n * not as part of {@link DrawingState}. It persists across bars; an\n * `update` that does not re-specify a non-zero `z` retains it, a\n * re-specified non-zero `z` overrides, and a cross-bar re-entry\n * re-specifies it from the new call.\n *\n * @since 0.3\n * @stable\n * @example\n *     // const slot: DrawingSlot = {\n *     //     handleId: \"x.chart.ts:1:1#0\",\n *     //     kind: \"line\",\n *     //     state: { kind: \"line\", anchors: [...], style: {} },\n *     //     z: 0,\n *     //     removed: false,\n *     // };\n */\nexport type DrawingSlot = {\n    readonly handleId: string;\n    readonly kind: DrawingKind;\n    state: DrawingState;\n    z: number;\n    removed: boolean;\n};\n\n/**\n * Mutable counterpart of `RunnerEmissions` (from adapter-kit) that the\n * runtime accumulates into per bar. Task 6's execution loop pushes\n * here during `compute`; `drain()` snapshots into the readonly\n * `RunnerEmissions` shape the adapter receives.\n *\n * @since 0.1\n * @example\n *     // const emissions: MutableRunnerEmissions = {\n *     //     plots: [],\n *     //     drawings: [],\n *     //     alerts: [],\n *     //     diagnostics: [],\n *     //     fromBar: 0,\n *     //     toBar: 0,\n *     // };\n */\nexport type MutableRunnerEmissions = {\n    plots: PlotEmission[];\n    drawings: DrawingEmission[];\n    alerts: AlertEmission[];\n    alertConditions?: AlertConditionEmission[];\n    logs: LogEmission[];\n    diagnostics: RuntimeDiagnostic[];\n    fromBar: number;\n    toBar: number;\n};\n\n/**\n * The contract Task 6's execution loop hands to stateful primitives\n * (Tasks 7-8) inside a single `compute` step. Tasks 7-8 read this\n * through {@link ACTIVE_RUNTIME_CONTEXT} — the runtime sets `.current`\n * around `compute` in a `try/finally`, so primitives can find their\n * series, slot store, capability bag, emission destination, and bar\n * index without an explicit argument.\n *\n * `isTick` discriminates `onBarTick` calls (head-replace mode) from\n * `onBarClose` / `onHistory` (append mode). Stateful primitives in\n * Task 7 use it to swap append vs replace-head behaviour.\n *\n * `stateSlots` stores Phase-4 `state.*` / `state.tick.*` slots keyed by\n * `${slotId}:state`; values flush into `stateStore` at close/dispose.\n *\n * `views` is a mutable container whose fields are replaced with fresh frozen\n * `barstate.*`, `syminfo.*`, and `timeframe.*` snapshots as the runner\n * advances.\n *\n * `resolvedInputs` is the frozen bag handed to `compute({ inputs })`,\n * resolved once at mount from manifest defaults plus adapter overrides.\n *\n * @since 0.1\n * @example\n *     // const ctx: RuntimeContext = {\n *     //     stream, stateStore, capabilities, emissions,\n *     //     barIndex: () => 0,\n *     //     isTick: false,\n *     // };\n */\nexport type RuntimeContext = {\n    readonly stream: StreamState;\n    readonly stateStore: StateStore;\n    readonly persistentStateStore?: PersistentStateStore;\n    lastPersistTime: number;\n    readonly capabilities: Capabilities;\n    readonly emissions: MutableRunnerEmissions;\n    readonly barIndex: () => number;\n    isTick: boolean;\n    /**\n     * Per-handle drawing slot store keyed by `slotId#subId`. Allocated\n     * on first `op: \"create\"`; mutated by `update(patch)` to merge the\n     * patch into the slot's `state`; flagged `removed: true` on\n     * `remove()`. Cleared on `dispose`. Persists across bars.\n     * @since 0.3\n     */\n    readonly drawingSlots: Map<string, DrawingSlot>;\n    /**\n     * Per-callsite per-bar sub-id counter. Each `draw.<kind>(...)` call\n     * inside a bar reads `nextSubId(ctx, slotId)`; the counter resets\n     * at the top of each `onBarClose` / `onBarTick` so iteration `i` at\n     * the same callsite yields the same `slotId#i` across bars.\n     * Cleared on `dispose`. @since 0.3\n     */\n    readonly drawingSubIdCounters: Map<string, number>;\n    /**\n     * Live per-bucket allocation tally for the current script. Each\n     * `op: \"create\"` increments the relevant bucket; each\n     * `op: \"remove\"` decrements (clamped at 0). `op: \"update\"` is\n     * free. `pushDrawing` drops the emission with\n     * `drawing-budget-exceeded` once a bucket hits its effective\n     * budget (min of adapter cap + `scriptMaxDrawings`). Reset to\n     * zero on `dispose`. @since 0.3\n     */\n    readonly drawingBucketCounters: Record<DrawingBucket, number>;\n    /**\n     * The script's per-bucket cap from `defineIndicator({ maxDrawings:\n     * ... })` / `defineDrawing({ maxDrawings: ... })`. `null` when\n     * omitted — `pushDrawing` then enforces the adapter cap alone.\n     * Effective budget is `min(scriptMaxDrawings[b],\n     * capabilities.maxDrawingsPerScript[b])`. @since 0.3\n     */\n    readonly scriptMaxDrawings: DrawingCounts | null;\n    /**\n     * Runtime `state.*` / `state.tick.*` slot store keyed by\n     * `${slotIdPrefix ?? \"\"}${slotId}:state`. Non-tick slots keep\n     * committed/tentative values; tick slots commit writes immediately.\n     * Cleared on `dispose` after flushing snapshots to `stateStore`.\n     * @since 0.4\n     */\n    readonly stateSlots: Map<string, StateSlot<unknown>>;\n    /**\n     * Runtime `state.series` slot store keyed by\n     * `${slotIdPrefix ?? \"\"}${slotId}:series`. Each holds a history ring +\n     * the identity-stable script-facing view + the last committed head.\n     * The ring advances once per close (script-invisible lockstep), so\n     * `s[1]` is always one committed bar back. Cleared on `dispose` after\n     * the final snapshot captures it. @since 0.9\n     */\n    readonly seriesSlots: Map<string, SeriesSlot>;\n    /**\n     * Secondary candle streams keyed by `IntervalDescriptor.value`.\n     * Mutated only by `createScriptRunner` mount/restore/routing. @since 0.5\n     */\n    readonly secondaryStreams: Map<string, StreamState>;\n    /**\n     * Per-`request.security` slot cache keyed by `slotId|interval`. Phase 4\n     * stores NaN fallback bars here; Phase 5 replaces the value producer with\n     * aligned secondary stream series while preserving stable identity.\n     * @since 0.4\n     */\n    readonly requestSecurityBars: Map<string, SecurityBar>;\n    /**\n     * Per-compute aligned numeric arrays keyed by\n     * `slotId|interval|sourceKey`. Cleared on main-stream close/tick before\n     * `compute` so `request.security` re-aligns against the latest\n     * secondary buffers. @since 0.5\n     */\n    readonly requestSecurityAlignments: Map<string, ReadonlyArray<number>>;\n    /**\n     * Per-compute cache of ascending `Bar[]` materialisations keyed by the\n     * source `StreamState`. Shared by `request.security` and `request.lowerTf`\n     * (via `request/streamBars.ts:ascendingBarsFor`) so a stable bar-array\n     * identity is reused across every consumer in a bar — the `getOrAlign` /\n     * `getOrBucket` WeakMap caches actually hit and the same ring buffer is\n     * walked once per bar instead of 10×. Cleared alongside\n     * {@link requestSecurityAlignments}. @since 0.5\n     */\n    readonly requestSecurityAscendingBars: Map<StreamState, ReadonlyArray<Bar>>;\n    /**\n     * Mounted HTF expression runners keyed by `slotId`. One entry per\n     * `manifest.securityExpressions` callsite. `request.security(slotId,\n     * opts, expr)` dispatches the expression overload off this registry\n     * (rather than `expr !== undefined`) and captures the callback here.\n     * Absent on dep / sibling contexts and single-timeframe scripts.\n     * Cleared on `dispose`. @since 0.7\n     */\n    securityExprRunners?: Map<string, SecurityExprRunner>;\n    /**\n     * Per-interval index into {@link securityExprRunners}, keyed by\n     * `IntervalDescriptor.value`. `driveSecurityExpressions` fans a\n     * secondary close / tick out to every runner on that interval.\n     * Absent when no expression callsites are declared. Cleared on\n     * `dispose`. @since 0.7\n     */\n    securityExprRunnersByInterval?: ReadonlyMap<string, ReadonlyArray<SecurityExprRunner>>;\n    /**\n     * Per-compute aligned expression-output series cache keyed by\n     * `slotId|interval`. Holds the stable `Series<number>` Proxy each\n     * expression-form `request.security` returns; cleared each bar\n     * (alongside {@link requestSecurityAlignments}) so the proxy re-aligns\n     * the runner's output buffer against the latest secondary buffers.\n     * @since 0.7\n     */\n    requestSecurityExprSeries?: Map<string, Series<number>>;\n    /**\n     * Per-`request.lowerTf` slot cache keyed by `slotId|interval`. Values are\n     * stable `Series<ReadonlyArray<Bar>>` proxies over the latest LTF bucket\n     * materialisation. @since 0.6\n     */\n    readonly requestLowerTfViews: Map<string, Series<ReadonlyArray<Bar>>>;\n    /**\n     * Runtime diagnostic dedupe for `request.*` capability gates, keyed by\n     * `code|slotId|interval|kind`. Cleared on `dispose`. @since 0.4\n     */\n    readonly diagnosedRequestKeys: Set<string>;\n    /**\n     * Manifest-declared alert conditions keyed by condition id. Used by\n     * `signal(conditionId, fired)` to reject unknown ids without\n     * re-reading the manifest each bar. @since 0.5\n     */\n    readonly alertConditions?: ReadonlyMap<string, AlertConditionDefinition>;\n    /**\n     * Dedupe for alert-condition capability/unknown-id diagnostics, keyed\n     * by `code|conditionId`. Cleared on dispose. @since 0.5\n     */\n    readonly diagnosedAlertConditionKeys?: Set<string>;\n    /**\n     * Number of `runtime.log.*` emissions accepted in the active compute\n     * step. Reset at the start of each close/tick. @since 0.5\n     */\n    logBudget: number;\n    /**\n     * Per-step dedupe flag for `runtime-log-budget-exceeded`. Reset with\n     * `logBudget` at the start of each close/tick. @since 0.5\n     */\n    logBudgetExceededDiagnosed: boolean;\n    /**\n     * Frozen effective input values keyed by script input name. Resolved once\n     * at mount and reused by every compute step. @since 0.4\n     */\n    resolvedInputs: Readonly<Record<string, unknown>>;\n    /**\n     * Mount-time script pane default. The runner sets it from\n     * `manifest.overlay`:\n     *   - `overlay` absent / `true` → `\"overlay\"`.\n     *   - `overlay === false` → `\"script:<sanitised(manifest.name)>\"`.\n     * `resolvePane` reads this value when a `plot()` / `hline()` call\n     * has no explicit `pane` opt.\n     * @since 0.2\n     */\n    readonly defaultPane: string;\n    /**\n     * Stable non-overlay pane key for this script. Explicit\n     * `pane: \"new\"` resolves here even when `defaultPane === \"overlay\"`\n     * so every `\"new\"` plot in a script joins one script-owned subpane.\n     * @since 0.2\n     */\n    readonly scriptPane: string;\n    /**\n     * Host-supplied per-slot presentation overrides, keyed by\n     * `PlotEmission.slotId`. Applied at emit time by `applyPlotOverride`.\n     * Mutable — `setPlotOverrides` swaps it live (presentation-only, so\n     * it does not break the frozen-input determinism guarantee). Entries\n     * themselves are frozen. @since 0.8\n     */\n    plotOverrides: Readonly<Record<string, PlotOverride>>;\n    /**\n     * Runtime diagnostic dedupe for mount-time input override failures,\n     * keyed by manifest input key. Cleared on `dispose`. @since 0.4\n     */\n    readonly diagnosedInputKeys: Set<string>;\n    /**\n     * Runtime `barstate.*`, `syminfo.*`, and `timeframe.*` views. The\n     * container is mutable; each assigned view snapshot is frozen.\n     * @since 0.4\n     */\n    readonly views: RuntimeViews;\n    /**\n     * Prefix prepended when emissions from this context flow into the\n     * parent runner's queues, and mirrored into every `stateSlots` /\n     * `StateStore` key written by `state.*` / `state.tick.*` so each\n     * runner's persisted state is isolated. `\"dep:<localId>/\"` for\n     * private dep runners, `\"export:<exportName>/\"` for sibling\n     * runners, and `\"\"` (or absent) for primary single-script and\n     * bundle-primary runners.\n     *\n     * @since 0.7\n     */\n    slotIdPrefix?: string;\n    /**\n     * `true` when this context belongs to a private dep runner — its\n     * emissions are dropped (or captured into the dep output store) by\n     * `applyDepEmissionPolicy`. `false` / absent for primary and\n     * sibling runners.\n     *\n     * @since 0.7\n     */\n    isDep?: boolean;\n    /**\n     * Per-bar titled-output buffer shared by the primary and every\n     * sibling of a `CompiledScriptBundle`. Populated by\n     * `applyDepEmissionPolicy` after each dep/sibling's compute; read\n     * by `__chartlang_depOutput` during the consumer's compute. `null`\n     * / absent for single-script runners with no deps.\n     *\n     * @since 0.7\n     */\n    depOutputStore?: DepOutputStore | null;\n};\n\n/**\n * Process-wide context slot. Task 6's `createScriptRunner` mutates\n * `.current` inside `try { ... } finally { current = null }` around\n * every `compute` invocation; Tasks 7-8 read it inside primitive\n * implementations. JavaScript's single-threaded execution model\n * guarantees only one `compute` runs at a time, so this ambient\n * slot is safe.\n *\n * The export is intentionally just a holder — no class, no methods,\n * no validation. Responsibility for setting and clearing lives in\n * Task 6.\n *\n * @since 0.1\n * @example\n *     // import { ACTIVE_RUNTIME_CONTEXT }\n *     //     from \"@invinite-org/chartlang-runtime\";\n *     // ACTIVE_RUNTIME_CONTEXT.current; // null at module load\n */\nexport const ACTIVE_RUNTIME_CONTEXT: { current: RuntimeContext | null } = {\n    current: null,\n};\n"]}
+{"version":3,"file":"runtimeContext.js","sourceRoot":"","sources":["../src/runtimeContext.ts"],"names":[],"mappings":"AAAA,+DAA+D;AAC/D,+DAA+D;AAgY/D;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAuC;IACtE,OAAO,EAAE,IAAI;CAChB,CAAC","sourcesContent":["// Copyright (c) 2026 Invinite. Licensed under the MIT License.\n// See the LICENSE file in the repo root for full license text.\n\nimport type {\n    AlertConditionEmission,\n    AlertEmission,\n    Capabilities,\n    DrawingEmission,\n    LogEmission,\n    PlotEmission,\n    PlotOverride,\n    RuntimeDiagnostic,\n} from \"@invinite-org/chartlang-adapter-kit\";\nimport type {\n    AlertConditionDefinition,\n    Bar,\n    DrawingBucket,\n    DrawingCounts,\n    DrawingKind,\n    DrawingState,\n    SecurityBar,\n    Series,\n} from \"@invinite-org/chartlang-core\";\n\nimport type { DepOutputStore } from \"./dep/DepOutputStore.js\";\nimport type { PersistentStateStore } from \"./persistentStateStore.js\";\nimport type { SecurityExprRunner } from \"./request/securityExprRunner.js\";\nimport type { ArrayStateSlot } from \"./state/arrayStateSlot.js\";\nimport type { SeriesSlot } from \"./state/seriesSlot.js\";\nimport type { StateSlot } from \"./state/stateSlot.js\";\nimport type { StateStore } from \"./stateStore.js\";\nimport type { StreamState } from \"./streamState.js\";\nimport type { RuntimeViews } from \"./views/index.js\";\n\n/**\n * Per-handle drawing slot the runtime persists across bars. The key is\n * `slotId#subId` (compiler-injected callsite id + per-bar sub-id from\n * {@link nextSubId}). `state` holds the last full {@link DrawingState}\n * emitted for the handle; subsequent `update(patch)` calls merge into\n * it and re-emit the full payload. `removed: true`\n * is sticky — further `update` / `remove` on the handle no-op.\n *\n * `z` is the presentation-only render-order key `handle.ts`'s `splitZ`\n * lifted out of the drawing's `state.style` (default `0`). It is stored\n * **beside** `state` — never inside `state` / `state.style` — because\n * the wire carries it as the top-level {@link DrawingEmission.z} field,\n * not as part of {@link DrawingState}. It persists across bars; an\n * `update` that does not re-specify a non-zero `z` retains it, a\n * re-specified non-zero `z` overrides, and a cross-bar re-entry\n * re-specifies it from the new call.\n *\n * @since 0.3\n * @stable\n * @example\n *     // const slot: DrawingSlot = {\n *     //     handleId: \"x.chart.ts:1:1#0\",\n *     //     kind: \"line\",\n *     //     state: { kind: \"line\", anchors: [...], style: {} },\n *     //     z: 0,\n *     //     removed: false,\n *     // };\n */\nexport type DrawingSlot = {\n    readonly handleId: string;\n    readonly kind: DrawingKind;\n    state: DrawingState;\n    z: number;\n    removed: boolean;\n};\n\n/**\n * Mutable counterpart of `RunnerEmissions` (from adapter-kit) that the\n * runtime accumulates into per bar. Task 6's execution loop pushes\n * here during `compute`; `drain()` snapshots into the readonly\n * `RunnerEmissions` shape the adapter receives.\n *\n * @since 0.1\n * @example\n *     // const emissions: MutableRunnerEmissions = {\n *     //     plots: [],\n *     //     drawings: [],\n *     //     alerts: [],\n *     //     diagnostics: [],\n *     //     fromBar: 0,\n *     //     toBar: 0,\n *     // };\n */\nexport type MutableRunnerEmissions = {\n    plots: PlotEmission[];\n    drawings: DrawingEmission[];\n    alerts: AlertEmission[];\n    alertConditions?: AlertConditionEmission[];\n    logs: LogEmission[];\n    diagnostics: RuntimeDiagnostic[];\n    fromBar: number;\n    toBar: number;\n};\n\n/**\n * The contract Task 6's execution loop hands to stateful primitives\n * (Tasks 7-8) inside a single `compute` step. Tasks 7-8 read this\n * through {@link ACTIVE_RUNTIME_CONTEXT} — the runtime sets `.current`\n * around `compute` in a `try/finally`, so primitives can find their\n * series, slot store, capability bag, emission destination, and bar\n * index without an explicit argument.\n *\n * `isTick` discriminates `onBarTick` calls (head-replace mode) from\n * `onBarClose` / `onHistory` (append mode). Stateful primitives in\n * Task 7 use it to swap append vs replace-head behaviour.\n *\n * `stateSlots` stores Phase-4 `state.*` / `state.tick.*` slots keyed by\n * `${slotId}:state`; values flush into `stateStore` at close/dispose.\n *\n * `views` is a mutable container whose fields are replaced with fresh frozen\n * `barstate.*`, `syminfo.*`, and `timeframe.*` snapshots as the runner\n * advances.\n *\n * `resolvedInputs` is the frozen bag handed to `compute({ inputs })`,\n * resolved once at mount from manifest defaults plus adapter overrides.\n *\n * @since 0.1\n * @example\n *     // const ctx: RuntimeContext = {\n *     //     stream, stateStore, capabilities, emissions,\n *     //     barIndex: () => 0,\n *     //     isTick: false,\n *     // };\n */\nexport type RuntimeContext = {\n    readonly stream: StreamState;\n    readonly stateStore: StateStore;\n    readonly persistentStateStore?: PersistentStateStore;\n    lastPersistTime: number;\n    readonly capabilities: Capabilities;\n    readonly emissions: MutableRunnerEmissions;\n    readonly barIndex: () => number;\n    isTick: boolean;\n    /**\n     * Per-handle drawing slot store keyed by `slotId#subId`. Allocated\n     * on first `op: \"create\"`; mutated by `update(patch)` to merge the\n     * patch into the slot's `state`; flagged `removed: true` on\n     * `remove()`. Cleared on `dispose`. Persists across bars.\n     * @since 0.3\n     */\n    readonly drawingSlots: Map<string, DrawingSlot>;\n    /**\n     * Per-callsite per-bar sub-id counter. Each `draw.<kind>(...)` call\n     * inside a bar reads `nextSubId(ctx, slotId)`; the counter resets\n     * at the top of each `onBarClose` / `onBarTick` so iteration `i` at\n     * the same callsite yields the same `slotId#i` across bars.\n     * Cleared on `dispose`. @since 0.3\n     */\n    readonly drawingSubIdCounters: Map<string, number>;\n    /**\n     * Live per-bucket allocation tally for the current script. Each\n     * `op: \"create\"` increments the relevant bucket; each\n     * `op: \"remove\"` decrements (clamped at 0). `op: \"update\"` is\n     * free. `pushDrawing` drops the emission with\n     * `drawing-budget-exceeded` once a bucket hits its effective\n     * budget (min of adapter cap + `scriptMaxDrawings`). Reset to\n     * zero on `dispose`. @since 0.3\n     */\n    readonly drawingBucketCounters: Record<DrawingBucket, number>;\n    /**\n     * The script's per-bucket cap from `defineIndicator({ maxDrawings:\n     * ... })` / `defineDrawing({ maxDrawings: ... })`. `null` when\n     * omitted — `pushDrawing` then enforces the adapter cap alone.\n     * Effective budget is `min(scriptMaxDrawings[b],\n     * capabilities.maxDrawingsPerScript[b])`. @since 0.3\n     */\n    readonly scriptMaxDrawings: DrawingCounts | null;\n    /**\n     * Runtime `state.*` / `state.tick.*` slot store keyed by\n     * `${slotIdPrefix ?? \"\"}${slotId}:state`. Non-tick slots keep\n     * committed/tentative values; tick slots commit writes immediately.\n     * Cleared on `dispose` after flushing snapshots to `stateStore`.\n     * @since 0.4\n     */\n    readonly stateSlots: Map<string, StateSlot<unknown>>;\n    /**\n     * Runtime `state.series` slot store keyed by\n     * `${slotIdPrefix ?? \"\"}${slotId}:series`. Each holds a history ring +\n     * the identity-stable script-facing view + the last committed head.\n     * The ring advances once per close (script-invisible lockstep), so\n     * `s[1]` is always one committed bar back. Cleared on `dispose` after\n     * the final snapshot captures it. @since 0.9\n     */\n    readonly seriesSlots: Map<string, SeriesSlot>;\n    /**\n     * Runtime `state.array` slot store keyed by\n     * `${slotIdPrefix ?? \"\"}${slotId}:array`. Each holds two\n     * `Float64RingBuffer`s (committed + tentative) behind an identity-stable\n     * bounded-FIFO handle. A parallel map (vs folding into `stateSlots`)\n     * mirrors the `state.series` precedent — both collection primitives share\n     * the two-ring shape and snapshot directly from the live map with no\n     * `StateStore` flush. Cleared on `dispose`. @since 1.3\n     */\n    readonly arraySlots: Map<string, ArrayStateSlot>;\n    /**\n     * The chart's own symbol, resolved once at mount from the adapter\n     * `syminfo.ticker` (`\"\"` when the adapter supplies none). A\n     * `request.security` call that omits `symbol` — or passes this exact\n     * ticker — resolves to it and collapses to the bare-interval\n     * {@link feedKey}, so the chart-symbol path is byte-identical to the\n     * pre-multi-symbol baseline. Only a *different* symbol allocates a\n     * `\"<symbol>@<interval>\"` feed. @since 1.3\n     */\n    readonly chartSymbol: string;\n    /**\n     * Secondary candle streams keyed by the composite\n     * `feedKey(symbol, interval)` (the shared core helper). A symbol-omitted\n     * feed collapses to the bare interval — `feedKey(undefined, \"1D\") === \"1D\"`\n     * — so the chart-symbol path is byte-identical to the pre-multi-symbol\n     * baseline; a non-chart symbol keys as `\"<symbol>@<interval>\"`. Mutated only\n     * by `createScriptRunner` mount/restore/routing. @since 0.5\n     */\n    readonly secondaryStreams: Map<string, StreamState>;\n    /**\n     * Per-`request.security` slot cache keyed by `slotId|feedKey`. Phase 4\n     * stores NaN fallback bars here; Phase 5 replaces the value producer with\n     * aligned secondary stream series while preserving stable identity. The\n     * `feedKey` collapses to the bare interval for chart-symbol requests, so\n     * the omitted-symbol cache key is byte-identical to the baseline.\n     * @since 0.4\n     */\n    readonly requestSecurityBars: Map<string, SecurityBar>;\n    /**\n     * Per-compute aligned numeric arrays keyed by\n     * `slotId|feedKey|sourceKey`. Cleared on main-stream close/tick before\n     * `compute` so `request.security` re-aligns against the latest\n     * secondary buffers. @since 0.5\n     */\n    readonly requestSecurityAlignments: Map<string, ReadonlyArray<number>>;\n    /**\n     * Per-compute cache of ascending `Bar[]` materialisations keyed by the\n     * source `StreamState`. Shared by `request.security` and `request.lowerTf`\n     * (via `request/streamBars.ts:ascendingBarsFor`) so a stable bar-array\n     * identity is reused across every consumer in a bar — the `getOrAlign` /\n     * `getOrBucket` WeakMap caches actually hit and the same ring buffer is\n     * walked once per bar instead of 10×. Cleared alongside\n     * {@link requestSecurityAlignments}. @since 0.5\n     */\n    readonly requestSecurityAscendingBars: Map<StreamState, ReadonlyArray<Bar>>;\n    /**\n     * Mounted HTF expression runners keyed by `slotId`. One entry per\n     * `manifest.securityExpressions` callsite. `request.security(slotId,\n     * opts, expr)` dispatches the expression overload off this registry\n     * (rather than `expr !== undefined`) and captures the callback here.\n     * Absent on dep / sibling contexts and single-timeframe scripts.\n     * Cleared on `dispose`. @since 0.7\n     */\n    securityExprRunners?: Map<string, SecurityExprRunner>;\n    /**\n     * Per-feed index into {@link securityExprRunners}, keyed by the composite\n     * `feedKey(symbol, interval)`. `driveSecurityExpressions` fans a secondary\n     * close / tick (tagged with that same composite key on\n     * `CandleEvent.streamKey`) out to every runner on that feed. A\n     * symbol-omitted callsite collapses to the bare interval, byte-identical to\n     * the pre-multi-symbol baseline. Absent when no expression callsites are\n     * declared. Cleared on `dispose`. @since 0.7\n     */\n    securityExprRunnersByFeed?: ReadonlyMap<string, ReadonlyArray<SecurityExprRunner>>;\n    /**\n     * Per-compute aligned expression-output series cache keyed by\n     * `slotId|feedKey`. Holds the stable `Series<number>` Proxy each\n     * expression-form `request.security` returns; cleared each bar\n     * (alongside {@link requestSecurityAlignments}) so the proxy re-aligns\n     * the runner's output buffer against the latest secondary buffers.\n     * @since 0.7\n     */\n    requestSecurityExprSeries?: Map<string, Series<number>>;\n    /**\n     * Per-`request.lowerTf` slot cache keyed by `slotId|interval`. Values are\n     * stable `Series<ReadonlyArray<Bar>>` proxies over the latest LTF bucket\n     * materialisation. @since 0.6\n     */\n    readonly requestLowerTfViews: Map<string, Series<ReadonlyArray<Bar>>>;\n    /**\n     * Runtime diagnostic dedupe for `request.*` capability gates, keyed by\n     * `code|slotId|interval|kind`. Cleared on `dispose`. @since 0.4\n     */\n    readonly diagnosedRequestKeys: Set<string>;\n    /**\n     * Runtime diagnostic dedupe for `time.*` / `session.*` DST-zone\n     * fallbacks, keyed by `tz-dst-unsupported|<tz>`. The calendar accessors\n     * are `slot: false` (no slotId to key on), so they dedupe on the\n     * timezone string here — a DST zone warns at most once per distinct tz\n     * per mount. Cleared on `dispose`. @since 1.5\n     */\n    readonly diagnosedTzKeys: Set<string>;\n    /**\n     * Manifest-declared alert conditions keyed by condition id. Used by\n     * `signal(conditionId, fired)` to reject unknown ids without\n     * re-reading the manifest each bar. @since 0.5\n     */\n    readonly alertConditions?: ReadonlyMap<string, AlertConditionDefinition>;\n    /**\n     * Dedupe for alert-condition capability/unknown-id diagnostics, keyed\n     * by `code|conditionId`. Cleared on dispose. @since 0.5\n     */\n    readonly diagnosedAlertConditionKeys?: Set<string>;\n    /**\n     * Number of `runtime.log.*` emissions accepted in the active compute\n     * step. Reset at the start of each close/tick. @since 0.5\n     */\n    logBudget: number;\n    /**\n     * Per-step dedupe flag for `runtime-log-budget-exceeded`. Reset with\n     * `logBudget` at the start of each close/tick. @since 0.5\n     */\n    logBudgetExceededDiagnosed: boolean;\n    /**\n     * Frozen effective input values keyed by script input name. Resolved once\n     * at mount and reused by every compute step. @since 0.4\n     */\n    resolvedInputs: Readonly<Record<string, unknown>>;\n    /**\n     * Mount-time script pane default. The runner sets it from\n     * `manifest.overlay`:\n     *   - `overlay` absent / `true` → `\"overlay\"`.\n     *   - `overlay === false` → `\"script:<sanitised(manifest.name)>\"`.\n     * `resolvePane` reads this value when a `plot()` / `hline()` call\n     * has no explicit `pane` opt.\n     * @since 0.2\n     */\n    readonly defaultPane: string;\n    /**\n     * Stable non-overlay pane key for this script. Explicit\n     * `pane: \"new\"` resolves here even when `defaultPane === \"overlay\"`\n     * so every `\"new\"` plot in a script joins one script-owned subpane.\n     * @since 0.2\n     */\n    readonly scriptPane: string;\n    /**\n     * Host-supplied per-slot presentation overrides, keyed by\n     * `PlotEmission.slotId`. Applied at emit time by `applyPlotOverride`.\n     * Mutable — `setPlotOverrides` swaps it live (presentation-only, so\n     * it does not break the frozen-input determinism guarantee). Entries\n     * themselves are frozen. @since 0.8\n     */\n    plotOverrides: Readonly<Record<string, PlotOverride>>;\n    /**\n     * Runtime diagnostic dedupe for mount-time input override failures,\n     * keyed by manifest input key. Cleared on `dispose`. @since 0.4\n     */\n    readonly diagnosedInputKeys: Set<string>;\n    /**\n     * Runtime `barstate.*`, `syminfo.*`, and `timeframe.*` views. The\n     * container is mutable; each assigned view snapshot is frozen.\n     * @since 0.4\n     */\n    readonly views: RuntimeViews;\n    /**\n     * Prefix prepended when emissions from this context flow into the\n     * parent runner's queues, and mirrored into every `stateSlots` /\n     * `StateStore` key written by `state.*` / `state.tick.*` so each\n     * runner's persisted state is isolated. `\"dep:<localId>/\"` for\n     * private dep runners, `\"export:<exportName>/\"` for sibling\n     * runners, and `\"\"` (or absent) for primary single-script and\n     * bundle-primary runners.\n     *\n     * @since 0.7\n     */\n    slotIdPrefix?: string;\n    /**\n     * `true` when this context belongs to a private dep runner — its\n     * emissions are dropped (or captured into the dep output store) by\n     * `applyDepEmissionPolicy`. `false` / absent for primary and\n     * sibling runners.\n     *\n     * @since 0.7\n     */\n    isDep?: boolean;\n    /**\n     * Per-bar titled-output buffer shared by the primary and every\n     * sibling of a `CompiledScriptBundle`. Populated by\n     * `applyDepEmissionPolicy` after each dep/sibling's compute; read\n     * by `__chartlang_depOutput` during the consumer's compute. `null`\n     * / absent for single-script runners with no deps.\n     *\n     * @since 0.7\n     */\n    depOutputStore?: DepOutputStore | null;\n};\n\n/**\n * Process-wide context slot. Task 6's `createScriptRunner` mutates\n * `.current` inside `try { ... } finally { current = null }` around\n * every `compute` invocation; Tasks 7-8 read it inside primitive\n * implementations. JavaScript's single-threaded execution model\n * guarantees only one `compute` runs at a time, so this ambient\n * slot is safe.\n *\n * The export is intentionally just a holder — no class, no methods,\n * no validation. Responsibility for setting and clearing lives in\n * Task 6.\n *\n * @since 0.1\n * @example\n *     // import { ACTIVE_RUNTIME_CONTEXT }\n *     //     from \"@invinite-org/chartlang-runtime\";\n *     // ACTIVE_RUNTIME_CONTEXT.current; // null at module load\n */\nexport const ACTIVE_RUNTIME_CONTEXT: { current: RuntimeContext | null } = {\n    current: null,\n};\n"]}

package/dist/state/arrayPersistence.d.ts

@@ -0,0 +1,48 @@
+import type { JsonValue } from "@invinite-org/chartlang-core";
+import type { RuntimeContext } from "../runtimeContext.js";
+/**
+ * Return whether a snapshot slot key belongs to the `state.array` namespace
+ * (a `${slotIdPrefix}${slotId}:array` key). Lets the restore router separate
+ * array slots from scalar `state.*` (`:state`), `state.series` (`:series`), and
+ * `ta.*` (`ta:`) slots, all of which share one `slots` record.
+ *
+ * @since 1.3
+ * @internal
+ * @stable
+ * @example
+ *     isArraySlotSnapshotKey("x.chart.ts:1:1:array"); // true
+ */
+export declare function isArraySlotSnapshotKey(key: string): boolean;
+/**
+ * Serialise the runner's `state.array` slots into JSON-clean snapshot entries
+ * keyed by the same `${prefix}${slotId}:array` key the slot store uses. Both
+ * rings ride {@link Float64RingBuffer.serialiseSnapshotBuffer}; `capacity` is
+ * recorded so restore can detect a script-edited capacity and degrade.
+ *
+ * @since 1.3
+ * @internal
+ * @stable
+ * @example
+ *     // const entries = serialiseArraySlots(ctx);
+ *     const entries = {};
+ *     void entries;
+ */
+export declare function serialiseArraySlots(ctx: RuntimeContext): Readonly<Record<string, JsonValue>>;
+/**
+ * Restore `state.array` slots from namespaced snapshot entries into
+ * `ctx.arraySlots`, rebuilding each ring at the *persisted* `capacity`. Non-array
+ * keys are ignored; a malformed snapshot — or one whose ring shape no longer
+ * matches its recorded `capacity` — is skipped so the slot starts fresh (a
+ * script-edited `state.array(cap)` literal degrades, it does not throw). The
+ * handle identity is recreated on restore (acceptable — same as `state.series`).
+ *
+ * @since 1.3
+ * @internal
+ * @stable
+ * @example
+ *     // restoreArraySlots(ctx, snapshot.slots);
+ *     const restored = true;
+ *     void restored;
+ */
+export declare function restoreArraySlots(ctx: RuntimeContext, slots: Readonly<Record<string, unknown>>): void;
+//# sourceMappingURL=arrayPersistence.d.ts.map

package/dist/state/arrayPersistence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arrayPersistence.d.ts","sourceRoot":"","sources":["../../src/state/arrayPersistence.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAS9D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAM3D;;;;;;;;;;;GAWG;AACH,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAE3D;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,cAAc,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC,CAW5F;AAaD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,iBAAiB,CAC7B,GAAG,EAAE,cAAc,EACnB,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACzC,IAAI,CASN"}

package/dist/state/arrayPersistence.js

@@ -0,0 +1,88 @@
+// Copyright (c) 2026 Invinite. Licensed under the MIT License.
+// See the LICENSE file in the repo root for full license text.
+import { isBufferSnapshot, isInteger, isRecord, restoreBuffer, serialiseBuffer, } from "../bufferSnapshot.js";
+import { restoreArrayStateSlot } from "./arrayStateSlot.js";
+const ARRAY_SLOT_SUFFIX = ":array";
+/**
+ * Return whether a snapshot slot key belongs to the `state.array` namespace
+ * (a `${slotIdPrefix}${slotId}:array` key). Lets the restore router separate
+ * array slots from scalar `state.*` (`:state`), `state.series` (`:series`), and
+ * `ta.*` (`ta:`) slots, all of which share one `slots` record.
+ *
+ * @since 1.3
+ * @internal
+ * @stable
+ * @example
+ *     isArraySlotSnapshotKey("x.chart.ts:1:1:array"); // true
+ */
+export function isArraySlotSnapshotKey(key) {
+    return key.endsWith(ARRAY_SLOT_SUFFIX);
+}
+/**
+ * Serialise the runner's `state.array` slots into JSON-clean snapshot entries
+ * keyed by the same `${prefix}${slotId}:array` key the slot store uses. Both
+ * rings ride {@link Float64RingBuffer.serialiseSnapshotBuffer}; `capacity` is
+ * recorded so restore can detect a script-edited capacity and degrade.
+ *
+ * @since 1.3
+ * @internal
+ * @stable
+ * @example
+ *     // const entries = serialiseArraySlots(ctx);
+ *     const entries = {};
+ *     void entries;
+ */
+export function serialiseArraySlots(ctx) {
+    const out = {};
+    for (const [key, slot] of ctx.arraySlots.entries()) {
+        out[key] = {
+            kind: "state.array",
+            capacity: slot.capacity,
+            committed: serialiseBuffer(slot.committedRing),
+            tentative: serialiseBuffer(slot.tentativeRing),
+        };
+    }
+    return Object.freeze(out);
+}
+function restoreArraySlotSnapshot(snapshot) {
+    if (!isRecord(snapshot) || snapshot.kind !== "state.array")
+        return null;
+    if (!isInteger(snapshot.capacity) || snapshot.capacity <= 0)
+        return null;
+    const { committed, tentative } = snapshot;
+    if (!isBufferSnapshot(committed) || !isBufferSnapshot(tentative))
+        return null;
+    const committedRing = restoreBuffer(committed, snapshot.capacity);
+    const tentativeRing = restoreBuffer(tentative, snapshot.capacity);
+    if (committedRing === null || tentativeRing === null)
+        return null;
+    return restoreArrayStateSlot(committedRing, tentativeRing);
+}
+/**
+ * Restore `state.array` slots from namespaced snapshot entries into
+ * `ctx.arraySlots`, rebuilding each ring at the *persisted* `capacity`. Non-array
+ * keys are ignored; a malformed snapshot — or one whose ring shape no longer
+ * matches its recorded `capacity` — is skipped so the slot starts fresh (a
+ * script-edited `state.array(cap)` literal degrades, it does not throw). The
+ * handle identity is recreated on restore (acceptable — same as `state.series`).
+ *
+ * @since 1.3
+ * @internal
+ * @stable
+ * @example
+ *     // restoreArraySlots(ctx, snapshot.slots);
+ *     const restored = true;
+ *     void restored;
+ */
+export function restoreArraySlots(ctx, slots) {
+    ctx.arraySlots.clear();
+    for (const [key, value] of Object.entries(slots)) {
+        if (!isArraySlotSnapshotKey(key))
+            continue;
+        const slot = restoreArraySlotSnapshot(value);
+        if (slot !== null) {
+            ctx.arraySlots.set(key, slot);
+        }
+    }
+}
+//# sourceMappingURL=arrayPersistence.js.map

package/dist/state/arrayPersistence.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"arrayPersistence.js","sourceRoot":"","sources":["../../src/state/arrayPersistence.ts"],"names":[],"mappings":"AAAA,+DAA+D;AAC/D,+DAA+D;AAI/D,OAAO,EACH,gBAAgB,EAChB,SAAS,EACT,QAAQ,EACR,aAAa,EACb,eAAe,GAClB,MAAM,sBAAsB,CAAC;AAG9B,OAAO,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AAE5D,MAAM,iBAAiB,GAAG,QAAQ,CAAC;AAEnC;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,sBAAsB,CAAC,GAAW;IAC9C,OAAO,GAAG,CAAC,QAAQ,CAAC,iBAAiB,CAAC,CAAC;AAC3C,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,mBAAmB,CAAC,GAAmB;IACnD,MAAM,GAAG,GAA8B,EAAE,CAAC;IAC1C,KAAK,MAAM,CAAC,GAAG,EAAE,IAAI,CAAC,IAAI,GAAG,CAAC,UAAU,CAAC,OAAO,EAAE,EAAE,CAAC;QACjD,GAAG,CAAC,GAAG,CAAC,GAAG;YACP,IAAI,EAAE,aAAa;YACnB,QAAQ,EAAE,IAAI,CAAC,QAAQ;YACvB,SAAS,EAAE,eAAe,CAAC,IAAI,CAAC,aAAa,CAAC;YAC9C,SAAS,EAAE,eAAe,CAAC,IAAI,CAAC,aAAa,CAAC;SACjD,CAAC;IACN,CAAC;IACD,OAAO,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;AAC9B,CAAC;AAED,SAAS,wBAAwB,CAAC,QAAiB;IAC/C,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,QAAQ,CAAC,IAAI,KAAK,aAAa;QAAE,OAAO,IAAI,CAAC;IACxE,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,QAAQ,CAAC,QAAQ,IAAI,CAAC;QAAE,OAAO,IAAI,CAAC;IACzE,MAAM,EAAE,SAAS,EAAE,SAAS,EAAE,GAAG,QAAQ,CAAC;IAC1C,IAAI,CAAC,gBAAgB,CAAC,SAAS,CAAC,IAAI,CAAC,gBAAgB,CAAC,SAAS,CAAC;QAAE,OAAO,IAAI,CAAC;IAC9E,MAAM,aAAa,GAAG,aAAa,CAAC,SAAS,EAAE,QAAQ,CAAC,QAAQ,CAAC,CAAC;IAClE,MAAM,aAAa,GAAG,aAAa,CAAC,SAAS,EAAE,QAAQ,CAAC,QAAQ,CAAC,CAAC;IAClE,IAAI,aAAa,KAAK,IAAI,IAAI,aAAa,KAAK,IAAI;QAAE,OAAO,IAAI,CAAC;IAClE,OAAO,qBAAqB,CAAC,aAAa,EAAE,aAAa,CAAC,CAAC;AAC/D,CAAC;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,iBAAiB,CAC7B,GAAmB,EACnB,KAAwC;IAExC,GAAG,CAAC,UAAU,CAAC,KAAK,EAAE,CAAC;IACvB,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QAC/C,IAAI,CAAC,sBAAsB,CAAC,GAAG,CAAC;YAAE,SAAS;QAC3C,MAAM,IAAI,GAAG,wBAAwB,CAAC,KAAK,CAAC,CAAC;QAC7C,IAAI,IAAI,KAAK,IAAI,EAAE,CAAC;YAChB,GAAG,CAAC,UAAU,CAAC,GAAG,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;QAClC,CAAC;IACL,CAAC;AACL,CAAC","sourcesContent":["// Copyright (c) 2026 Invinite. Licensed under the MIT License.\n// See the LICENSE file in the repo root for full license text.\n\nimport type { JsonValue } from \"@invinite-org/chartlang-core\";\n\nimport {\n    isBufferSnapshot,\n    isInteger,\n    isRecord,\n    restoreBuffer,\n    serialiseBuffer,\n} from \"../bufferSnapshot.js\";\nimport type { RuntimeContext } from \"../runtimeContext.js\";\nimport type { ArrayStateSlot } from \"./arrayStateSlot.js\";\nimport { restoreArrayStateSlot } from \"./arrayStateSlot.js\";\n\nconst ARRAY_SLOT_SUFFIX = \":array\";\n\n/**\n * Return whether a snapshot slot key belongs to the `state.array` namespace\n * (a `${slotIdPrefix}${slotId}:array` key). Lets the restore router separate\n * array slots from scalar `state.*` (`:state`), `state.series` (`:series`), and\n * `ta.*` (`ta:`) slots, all of which share one `slots` record.\n *\n * @since 1.3\n * @internal\n * @stable\n * @example\n *     isArraySlotSnapshotKey(\"x.chart.ts:1:1:array\"); // true\n */\nexport function isArraySlotSnapshotKey(key: string): boolean {\n    return key.endsWith(ARRAY_SLOT_SUFFIX);\n}\n\n/**\n * Serialise the runner's `state.array` slots into JSON-clean snapshot entries\n * keyed by the same `${prefix}${slotId}:array` key the slot store uses. Both\n * rings ride {@link Float64RingBuffer.serialiseSnapshotBuffer}; `capacity` is\n * recorded so restore can detect a script-edited capacity and degrade.\n *\n * @since 1.3\n * @internal\n * @stable\n * @example\n *     // const entries = serialiseArraySlots(ctx);\n *     const entries = {};\n *     void entries;\n */\nexport function serialiseArraySlots(ctx: RuntimeContext): Readonly<Record<string, JsonValue>> {\n    const out: Record<string, JsonValue> = {};\n    for (const [key, slot] of ctx.arraySlots.entries()) {\n        out[key] = {\n            kind: \"state.array\",\n            capacity: slot.capacity,\n            committed: serialiseBuffer(slot.committedRing),\n            tentative: serialiseBuffer(slot.tentativeRing),\n        };\n    }\n    return Object.freeze(out);\n}\n\nfunction restoreArraySlotSnapshot(snapshot: unknown): ArrayStateSlot | null {\n    if (!isRecord(snapshot) || snapshot.kind !== \"state.array\") return null;\n    if (!isInteger(snapshot.capacity) || snapshot.capacity <= 0) return null;\n    const { committed, tentative } = snapshot;\n    if (!isBufferSnapshot(committed) || !isBufferSnapshot(tentative)) return null;\n    const committedRing = restoreBuffer(committed, snapshot.capacity);\n    const tentativeRing = restoreBuffer(tentative, snapshot.capacity);\n    if (committedRing === null || tentativeRing === null) return null;\n    return restoreArrayStateSlot(committedRing, tentativeRing);\n}\n\n/**\n * Restore `state.array` slots from namespaced snapshot entries into\n * `ctx.arraySlots`, rebuilding each ring at the *persisted* `capacity`. Non-array\n * keys are ignored; a malformed snapshot — or one whose ring shape no longer\n * matches its recorded `capacity` — is skipped so the slot starts fresh (a\n * script-edited `state.array(cap)` literal degrades, it does not throw). The\n * handle identity is recreated on restore (acceptable — same as `state.series`).\n *\n * @since 1.3\n * @internal\n * @stable\n * @example\n *     // restoreArraySlots(ctx, snapshot.slots);\n *     const restored = true;\n *     void restored;\n */\nexport function restoreArraySlots(\n    ctx: RuntimeContext,\n    slots: Readonly<Record<string, unknown>>,\n): void {\n    ctx.arraySlots.clear();\n    for (const [key, value] of Object.entries(slots)) {\n        if (!isArraySlotSnapshotKey(key)) continue;\n        const slot = restoreArraySlotSnapshot(value);\n        if (slot !== null) {\n            ctx.arraySlots.set(key, slot);\n        }\n    }\n}\n"]}

package/dist/state/arrayStateSlot.d.ts

@@ -0,0 +1,78 @@
+import type { MutableArraySlot } from "@invinite-org/chartlang-core";
+import { Float64RingBuffer } from "../ringBuffer.js";
+/**
+ * Runtime slot behind a script-facing `state.array(capacity)` handle. Unlike
+ * the scalar `StateSlot` (one committed/tentative *value*) or the `SeriesSlot`
+ * (one ring advanced once per bar), this is a **bounded FIFO collection** with
+ * two `Float64RingBuffer`s: `tentativeRing` holds the live, author-facing
+ * pushes; `committedRing` is the bar-close snapshot a tick rolls back to.
+ *
+ * The committed/tentative discipline mirrors `StateSlot`: pushes during a tick
+ * mutate the tentative ring; a head-bar-replacing tick resets it from committed
+ * (in-progress pushes discarded); a bar close commits tentative into committed.
+ * The two-ring copy is `O(capacity)` per tick via a typed-array
+ * {@link Float64RingBuffer.copyFrom} memcpy — bounded because `capacity` is a
+ * required compile-time literal (see `tasks/future/state-array/README.md`
+ * Architecture Decisions: "Tick rollback = a two-ring buffer copy").
+ *
+ * @since 1.3
+ * @stable
+ * @example
+ *     const slot = new ArrayStateSlot(4);
+ *     slot.handle.push(1);
+ *     slot.onBarClose();
+ *     slot.handle.get(0); // 1
+ */
+export declare class ArrayStateSlot {
+    readonly capacity: number;
+    readonly committedRing: Float64RingBuffer;
+    readonly tentativeRing: Float64RingBuffer;
+    readonly handle: MutableArraySlot<number>;
+    constructor(capacity: number);
+    /** Commit the tentative ring into the committed ring (bar close). */
+    onBarClose(): void;
+    /** Roll the tentative ring back to the committed ring (head-replacing tick). */
+    onBarTick(): void;
+}
+/**
+ * Build the identity-stable {@link MutableArraySlot} handle over an
+ * {@link ArrayStateSlot}. All author-facing reads and writes route through the
+ * **tentative** ring (mirroring `StateSlot.set`/`StateSlot.get`, which read and
+ * write `tentative` for non-tick slots); the committed ring is the rollback
+ * source. `get(out-of-range)` returns `NaN` (the ring's `at` contract), never
+ * throws. A plain object with getters — no `Proxy` — because the handle has a
+ * fixed method set and is deliberately not number-coercible.
+ *
+ * @since 1.3
+ * @stable
+ * @example
+ *     // const handle = buildArrayHandle(new ArrayStateSlot(4));
+ *     // handle.push(1);
+ *     // handle.last(); // 1
+ */
+export declare function buildArrayHandle(slot: ArrayStateSlot): MutableArraySlot<number>;
+/**
+ * Allocate a fresh {@link ArrayStateSlot} — both rings empty (`size === 0`).
+ * Unlike `state.float(init)` there is no seed value: an empty collection starts
+ * empty.
+ *
+ * @since 1.3
+ * @stable
+ * @example
+ *     // const slot = createArrayStateSlot(20);
+ *     // slot.handle.size; // 0
+ */
+export declare function createArrayStateSlot(capacity: number): ArrayStateSlot;
+/**
+ * Rebuild an {@link ArrayStateSlot} from already-restored rings (snapshot
+ * path). The handle identity is recreated — acceptable, same as
+ * `state.series` / `ta.*` restore.
+ *
+ * @since 1.3
+ * @stable
+ * @example
+ *     // const slot = restoreArrayStateSlot(committedRing, tentativeRing);
+ *     // slot.handle.size;
+ */
+export declare function restoreArrayStateSlot(committedRing: Float64RingBuffer, tentativeRing: Float64RingBuffer): ArrayStateSlot;
+//# sourceMappingURL=arrayStateSlot.d.ts.map

package/dist/state/arrayStateSlot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arrayStateSlot.d.ts","sourceRoot":"","sources":["../../src/state/arrayStateSlot.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAErE,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAErD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qBAAa,cAAc;aAKK,QAAQ,EAAE,MAAM;IAJ5C,QAAQ,CAAC,aAAa,EAAE,iBAAiB,CAAC;IAC1C,QAAQ,CAAC,aAAa,EAAE,iBAAiB,CAAC;IAC1C,QAAQ,CAAC,MAAM,EAAE,gBAAgB,CAAC,MAAM,CAAC,CAAC;gBAEd,QAAQ,EAAE,MAAM;IAM5C,qEAAqE;IACrE,UAAU,IAAI,IAAI;IAIlB,gFAAgF;IAChF,SAAS,IAAI,IAAI;CAGpB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,cAAc,GAAG,gBAAgB,CAAC,MAAM,CAAC,CAqB/E;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,MAAM,GAAG,cAAc,CAErE;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,qBAAqB,CACjC,aAAa,EAAE,iBAAiB,EAChC,aAAa,EAAE,iBAAiB,GACjC,cAAc,CAKhB"}

package/dist/state/arrayStateSlot.js

@@ -0,0 +1,116 @@
+// Copyright (c) 2026 Invinite. Licensed under the MIT License.
+// See the LICENSE file in the repo root for full license text.
+import { Float64RingBuffer } from "../ringBuffer.js";
+/**
+ * Runtime slot behind a script-facing `state.array(capacity)` handle. Unlike
+ * the scalar `StateSlot` (one committed/tentative *value*) or the `SeriesSlot`
+ * (one ring advanced once per bar), this is a **bounded FIFO collection** with
+ * two `Float64RingBuffer`s: `tentativeRing` holds the live, author-facing
+ * pushes; `committedRing` is the bar-close snapshot a tick rolls back to.
+ *
+ * The committed/tentative discipline mirrors `StateSlot`: pushes during a tick
+ * mutate the tentative ring; a head-bar-replacing tick resets it from committed
+ * (in-progress pushes discarded); a bar close commits tentative into committed.
+ * The two-ring copy is `O(capacity)` per tick via a typed-array
+ * {@link Float64RingBuffer.copyFrom} memcpy — bounded because `capacity` is a
+ * required compile-time literal (see `tasks/future/state-array/README.md`
+ * Architecture Decisions: "Tick rollback = a two-ring buffer copy").
+ *
+ * @since 1.3
+ * @stable
+ * @example
+ *     const slot = new ArrayStateSlot(4);
+ *     slot.handle.push(1);
+ *     slot.onBarClose();
+ *     slot.handle.get(0); // 1
+ */
+export class ArrayStateSlot {
+    capacity;
+    committedRing;
+    tentativeRing;
+    handle;
+    constructor(capacity) {
+        this.capacity = capacity;
+        this.committedRing = new Float64RingBuffer(capacity);
+        this.tentativeRing = new Float64RingBuffer(capacity);
+        this.handle = buildArrayHandle(this);
+    }
+    /** Commit the tentative ring into the committed ring (bar close). */
+    onBarClose() {
+        this.committedRing.copyFrom(this.tentativeRing);
+    }
+    /** Roll the tentative ring back to the committed ring (head-replacing tick). */
+    onBarTick() {
+        this.tentativeRing.copyFrom(this.committedRing);
+    }
+}
+/**
+ * Build the identity-stable {@link MutableArraySlot} handle over an
+ * {@link ArrayStateSlot}. All author-facing reads and writes route through the
+ * **tentative** ring (mirroring `StateSlot.set`/`StateSlot.get`, which read and
+ * write `tentative` for non-tick slots); the committed ring is the rollback
+ * source. `get(out-of-range)` returns `NaN` (the ring's `at` contract), never
+ * throws. A plain object with getters — no `Proxy` — because the handle has a
+ * fixed method set and is deliberately not number-coercible.
+ *
+ * @since 1.3
+ * @stable
+ * @example
+ *     // const handle = buildArrayHandle(new ArrayStateSlot(4));
+ *     // handle.push(1);
+ *     // handle.last(); // 1
+ */
+export function buildArrayHandle(slot) {
+    return {
+        push(value) {
+            slot.tentativeRing.append(value);
+        },
+        get(n) {
+            return slot.tentativeRing.at(n);
+        },
+        last() {
+            return slot.tentativeRing.at(0);
+        },
+        clear() {
+            slot.tentativeRing.reset();
+        },
+        get size() {
+            return slot.tentativeRing.length;
+        },
+        get capacity() {
+            return slot.capacity;
+        },
+    };
+}
+/**
+ * Allocate a fresh {@link ArrayStateSlot} — both rings empty (`size === 0`).
+ * Unlike `state.float(init)` there is no seed value: an empty collection starts
+ * empty.
+ *
+ * @since 1.3
+ * @stable
+ * @example
+ *     // const slot = createArrayStateSlot(20);
+ *     // slot.handle.size; // 0
+ */
+export function createArrayStateSlot(capacity) {
+    return new ArrayStateSlot(capacity);
+}
+/**
+ * Rebuild an {@link ArrayStateSlot} from already-restored rings (snapshot
+ * path). The handle identity is recreated — acceptable, same as
+ * `state.series` / `ta.*` restore.
+ *
+ * @since 1.3
+ * @stable
+ * @example
+ *     // const slot = restoreArrayStateSlot(committedRing, tentativeRing);
+ *     // slot.handle.size;
+ */
+export function restoreArrayStateSlot(committedRing, tentativeRing) {
+    const slot = new ArrayStateSlot(committedRing.capacity);
+    slot.committedRing.copyFrom(committedRing);
+    slot.tentativeRing.copyFrom(tentativeRing);
+    return slot;
+}
+//# sourceMappingURL=arrayStateSlot.js.map

package/dist/state/arrayStateSlot.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"arrayStateSlot.js","sourceRoot":"","sources":["../../src/state/arrayStateSlot.ts"],"names":[],"mappings":"AAAA,+DAA+D;AAC/D,+DAA+D;AAI/D,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAErD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,OAAO,cAAc;IAKK;IAJnB,aAAa,CAAoB;IACjC,aAAa,CAAoB;IACjC,MAAM,CAA2B;IAE1C,YAA4B,QAAgB;QAAhB,aAAQ,GAAR,QAAQ,CAAQ;QACxC,IAAI,CAAC,aAAa,GAAG,IAAI,iBAAiB,CAAC,QAAQ,CAAC,CAAC;QACrD,IAAI,CAAC,aAAa,GAAG,IAAI,iBAAiB,CAAC,QAAQ,CAAC,CAAC;QACrD,IAAI,CAAC,MAAM,GAAG,gBAAgB,CAAC,IAAI,CAAC,CAAC;IACzC,CAAC;IAED,qEAAqE;IACrE,UAAU;QACN,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;IACpD,CAAC;IAED,gFAAgF;IAChF,SAAS;QACL,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;IACpD,CAAC;CACJ;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,gBAAgB,CAAC,IAAoB;IACjD,OAAO;QACH,IAAI,CAAC,KAAa;YACd,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QACrC,CAAC;QACD,GAAG,CAAC,CAAS;YACT,OAAO,IAAI,CAAC,aAAa,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;QACpC,CAAC;QACD,IAAI;YACA,OAAO,IAAI,CAAC,aAAa,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;QACpC,CAAC;QACD,KAAK;YACD,IAAI,CAAC,aAAa,CAAC,KAAK,EAAE,CAAC;QAC/B,CAAC;QACD,IAAI,IAAI;YACJ,OAAO,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC;QACrC,CAAC;QACD,IAAI,QAAQ;YACR,OAAO,IAAI,CAAC,QAAQ,CAAC;QACzB,CAAC;KACJ,CAAC;AACN,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,oBAAoB,CAAC,QAAgB;IACjD,OAAO,IAAI,cAAc,CAAC,QAAQ,CAAC,CAAC;AACxC,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,qBAAqB,CACjC,aAAgC,EAChC,aAAgC;IAEhC,MAAM,IAAI,GAAG,IAAI,cAAc,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC;IACxD,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAC;IAC3C,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAC;IAC3C,OAAO,IAAI,CAAC;AAChB,CAAC","sourcesContent":["// Copyright (c) 2026 Invinite. Licensed under the MIT License.\n// See the LICENSE file in the repo root for full license text.\n\nimport type { MutableArraySlot } from \"@invinite-org/chartlang-core\";\n\nimport { Float64RingBuffer } from \"../ringBuffer.js\";\n\n/**\n * Runtime slot behind a script-facing `state.array(capacity)` handle. Unlike\n * the scalar `StateSlot` (one committed/tentative *value*) or the `SeriesSlot`\n * (one ring advanced once per bar), this is a **bounded FIFO collection** with\n * two `Float64RingBuffer`s: `tentativeRing` holds the live, author-facing\n * pushes; `committedRing` is the bar-close snapshot a tick rolls back to.\n *\n * The committed/tentative discipline mirrors `StateSlot`: pushes during a tick\n * mutate the tentative ring; a head-bar-replacing tick resets it from committed\n * (in-progress pushes discarded); a bar close commits tentative into committed.\n * The two-ring copy is `O(capacity)` per tick via a typed-array\n * {@link Float64RingBuffer.copyFrom} memcpy — bounded because `capacity` is a\n * required compile-time literal (see `tasks/future/state-array/README.md`\n * Architecture Decisions: \"Tick rollback = a two-ring buffer copy\").\n *\n * @since 1.3\n * @stable\n * @example\n *     const slot = new ArrayStateSlot(4);\n *     slot.handle.push(1);\n *     slot.onBarClose();\n *     slot.handle.get(0); // 1\n */\nexport class ArrayStateSlot {\n    readonly committedRing: Float64RingBuffer;\n    readonly tentativeRing: Float64RingBuffer;\n    readonly handle: MutableArraySlot<number>;\n\n    constructor(public readonly capacity: number) {\n        this.committedRing = new Float64RingBuffer(capacity);\n        this.tentativeRing = new Float64RingBuffer(capacity);\n        this.handle = buildArrayHandle(this);\n    }\n\n    /** Commit the tentative ring into the committed ring (bar close). */\n    onBarClose(): void {\n        this.committedRing.copyFrom(this.tentativeRing);\n    }\n\n    /** Roll the tentative ring back to the committed ring (head-replacing tick). */\n    onBarTick(): void {\n        this.tentativeRing.copyFrom(this.committedRing);\n    }\n}\n\n/**\n * Build the identity-stable {@link MutableArraySlot} handle over an\n * {@link ArrayStateSlot}. All author-facing reads and writes route through the\n * **tentative** ring (mirroring `StateSlot.set`/`StateSlot.get`, which read and\n * write `tentative` for non-tick slots); the committed ring is the rollback\n * source. `get(out-of-range)` returns `NaN` (the ring's `at` contract), never\n * throws. A plain object with getters — no `Proxy` — because the handle has a\n * fixed method set and is deliberately not number-coercible.\n *\n * @since 1.3\n * @stable\n * @example\n *     // const handle = buildArrayHandle(new ArrayStateSlot(4));\n *     // handle.push(1);\n *     // handle.last(); // 1\n */\nexport function buildArrayHandle(slot: ArrayStateSlot): MutableArraySlot<number> {\n    return {\n        push(value: number): void {\n            slot.tentativeRing.append(value);\n        },\n        get(n: number): number {\n            return slot.tentativeRing.at(n);\n        },\n        last(): number {\n            return slot.tentativeRing.at(0);\n        },\n        clear(): void {\n            slot.tentativeRing.reset();\n        },\n        get size(): number {\n            return slot.tentativeRing.length;\n        },\n        get capacity(): number {\n            return slot.capacity;\n        },\n    };\n}\n\n/**\n * Allocate a fresh {@link ArrayStateSlot} — both rings empty (`size === 0`).\n * Unlike `state.float(init)` there is no seed value: an empty collection starts\n * empty.\n *\n * @since 1.3\n * @stable\n * @example\n *     // const slot = createArrayStateSlot(20);\n *     // slot.handle.size; // 0\n */\nexport function createArrayStateSlot(capacity: number): ArrayStateSlot {\n    return new ArrayStateSlot(capacity);\n}\n\n/**\n * Rebuild an {@link ArrayStateSlot} from already-restored rings (snapshot\n * path). The handle identity is recreated — acceptable, same as\n * `state.series` / `ta.*` restore.\n *\n * @since 1.3\n * @stable\n * @example\n *     // const slot = restoreArrayStateSlot(committedRing, tentativeRing);\n *     // slot.handle.size;\n */\nexport function restoreArrayStateSlot(\n    committedRing: Float64RingBuffer,\n    tentativeRing: Float64RingBuffer,\n): ArrayStateSlot {\n    const slot = new ArrayStateSlot(committedRing.capacity);\n    slot.committedRing.copyFrom(committedRing);\n    slot.tentativeRing.copyFrom(tentativeRing);\n    return slot;\n}\n"]}

package/dist/state/index.d.ts

@@ -1,4 +1,6 @@
-export { advanceSeriesSlots, commitSeriesSlots, commitStateSlots, flushStateSlots, resetSeriesHeads, restoreStateSlots, resetTentativeStateSlots, serialiseStateSlots, } from "./lifecycle.js";
+export { isArraySlotSnapshotKey, restoreArraySlots, serialiseArraySlots, } from "./arrayPersistence.js";
+export { ArrayStateSlot } from "./arrayStateSlot.js";
+export { advanceSeriesSlots, commitArraySlots, commitSeriesSlots, commitStateSlots, flushStateSlots, resetSeriesHeads, resetTentativeArraySlots, restoreStateSlots, resetTentativeStateSlots, serialiseStateSlots, } from "./lifecycle.js";
 export type { StateSlotSnapshot } from "./lifecycle.js";
 export { isSeriesSlotSnapshotKey, restoreSeriesSlots, serialiseSeriesSlots, } from "./seriesPersistence.js";
 export { buildStateNamespace } from "./stateNamespace.js";

package/dist/state/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/state/index.ts"],"names":[],"mappings":"AAGA,OAAO,EACH,kBAAkB,EAClB,iBAAiB,EACjB,gBAAgB,EAChB,eAAe,EACf,gBAAgB,EAChB,iBAAiB,EACjB,wBAAwB,EACxB,mBAAmB,GACtB,MAAM,gBAAgB,CAAC;AACxB,YAAY,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,EACH,uBAAuB,EACvB,kBAAkB,EAClB,oBAAoB,GACvB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAC1D,YAAY,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAC3D,OAAO,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/state/index.ts"],"names":[],"mappings":"AAGA,OAAO,EACH,sBAAsB,EACtB,iBAAiB,EACjB,mBAAmB,GACtB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,EACH,kBAAkB,EAClB,gBAAgB,EAChB,iBAAiB,EACjB,gBAAgB,EAChB,eAAe,EACf,gBAAgB,EAChB,wBAAwB,EACxB,iBAAiB,EACjB,wBAAwB,EACxB,mBAAmB,GACtB,MAAM,gBAAgB,CAAC;AACxB,YAAY,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,EACH,uBAAuB,EACvB,kBAAkB,EAClB,oBAAoB,GACvB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAC1D,YAAY,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAC3D,OAAO,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/state/index.js

@@ -1,6 +1,8 @@
 // Copyright (c) 2026 Invinite. Licensed under the MIT License.
 // See the LICENSE file in the repo root for full license text.
-export { advanceSeriesSlots, commitSeriesSlots, commitStateSlots, flushStateSlots, resetSeriesHeads, restoreStateSlots, resetTentativeStateSlots, serialiseStateSlots, } from "./lifecycle.js";
+export { isArraySlotSnapshotKey, restoreArraySlots, serialiseArraySlots, } from "./arrayPersistence.js";
+export { ArrayStateSlot } from "./arrayStateSlot.js";
+export { advanceSeriesSlots, commitArraySlots, commitSeriesSlots, commitStateSlots, flushStateSlots, resetSeriesHeads, resetTentativeArraySlots, restoreStateSlots, resetTentativeStateSlots, serialiseStateSlots, } from "./lifecycle.js";
 export { isSeriesSlotSnapshotKey, restoreSeriesSlots, serialiseSeriesSlots, } from "./seriesPersistence.js";
 export { buildStateNamespace } from "./stateNamespace.js";
 export { asMutableSlot, StateSlot } from "./stateSlot.js";

package/dist/state/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/state/index.ts"],"names":[],"mappings":"AAAA,+DAA+D;AAC/D,+DAA+D;AAE/D,OAAO,EACH,kBAAkB,EAClB,iBAAiB,EACjB,gBAAgB,EAChB,eAAe,EACf,gBAAgB,EAChB,iBAAiB,EACjB,wBAAwB,EACxB,mBAAmB,GACtB,MAAM,gBAAgB,CAAC;AAExB,OAAO,EACH,uBAAuB,EACvB,kBAAkB,EAClB,oBAAoB,GACvB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAE1D,OAAO,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC","sourcesContent":["// Copyright (c) 2026 Invinite. Licensed under the MIT License.\n// See the LICENSE file in the repo root for full license text.\n\nexport {\n    advanceSeriesSlots,\n    commitSeriesSlots,\n    commitStateSlots,\n    flushStateSlots,\n    resetSeriesHeads,\n    restoreStateSlots,\n    resetTentativeStateSlots,\n    serialiseStateSlots,\n} from \"./lifecycle.js\";\nexport type { StateSlotSnapshot } from \"./lifecycle.js\";\nexport {\n    isSeriesSlotSnapshotKey,\n    restoreSeriesSlots,\n    serialiseSeriesSlots,\n} from \"./seriesPersistence.js\";\nexport { buildStateNamespace } from \"./stateNamespace.js\";\nexport type { StateSlotSerialisers } from \"./stateSlot.js\";\nexport { asMutableSlot, StateSlot } from \"./stateSlot.js\";\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/state/index.ts"],"names":[],"mappings":"AAAA,+DAA+D;AAC/D,+DAA+D;AAE/D,OAAO,EACH,sBAAsB,EACtB,iBAAiB,EACjB,mBAAmB,GACtB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,EACH,kBAAkB,EAClB,gBAAgB,EAChB,iBAAiB,EACjB,gBAAgB,EAChB,eAAe,EACf,gBAAgB,EAChB,wBAAwB,EACxB,iBAAiB,EACjB,wBAAwB,EACxB,mBAAmB,GACtB,MAAM,gBAAgB,CAAC;AAExB,OAAO,EACH,uBAAuB,EACvB,kBAAkB,EAClB,oBAAoB,GACvB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAE1D,OAAO,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC","sourcesContent":["// Copyright (c) 2026 Invinite. Licensed under the MIT License.\n// See the LICENSE file in the repo root for full license text.\n\nexport {\n    isArraySlotSnapshotKey,\n    restoreArraySlots,\n    serialiseArraySlots,\n} from \"./arrayPersistence.js\";\nexport { ArrayStateSlot } from \"./arrayStateSlot.js\";\nexport {\n    advanceSeriesSlots,\n    commitArraySlots,\n    commitSeriesSlots,\n    commitStateSlots,\n    flushStateSlots,\n    resetSeriesHeads,\n    resetTentativeArraySlots,\n    restoreStateSlots,\n    resetTentativeStateSlots,\n    serialiseStateSlots,\n} from \"./lifecycle.js\";\nexport type { StateSlotSnapshot } from \"./lifecycle.js\";\nexport {\n    isSeriesSlotSnapshotKey,\n    restoreSeriesSlots,\n    serialiseSeriesSlots,\n} from \"./seriesPersistence.js\";\nexport { buildStateNamespace } from \"./stateNamespace.js\";\nexport type { StateSlotSerialisers } from \"./stateSlot.js\";\nexport { asMutableSlot, StateSlot } from \"./stateSlot.js\";\n"]}

package/dist/state/lifecycle.d.ts

@@ -112,4 +112,32 @@ export declare function commitSeriesSlots(ctx: RuntimeContext): void;
  *     void reset;
  */
 export declare function resetSeriesHeads(ctx: RuntimeContext): void;
+/**
+ * Roll every `state.array` slot's tentative ring back to its committed ring
+ * before tick compute, so a head-replacing tick discards in-progress pushes
+ * (and a tick without a push reads the committed collection). Runs once per
+ * tick, before compute, next to {@link resetSeriesHeads}. There is no advance —
+ * the array changes only when the author pushes.
+ *
+ * @since 1.3
+ * @stable
+ * @example
+ *     // resetTentativeArraySlots(ctx);
+ *     const reset = true;
+ *     void reset;
+ */
+export declare function resetTentativeArraySlots(ctx: RuntimeContext): void;
+/**
+ * Commit every `state.array` slot's tentative ring into its committed ring
+ * after close compute, so the next tick can roll back to it. Runs once per
+ * close, after compute, next to {@link commitSeriesSlots}.
+ *
+ * @since 1.3
+ * @stable
+ * @example
+ *     // commitArraySlots(ctx);
+ *     const committed = true;
+ *     void committed;
+ */
+export declare function commitArraySlots(ctx: RuntimeContext): void;
 //# sourceMappingURL=lifecycle.d.ts.map

package/dist/state/lifecycle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lifecycle.d.ts","sourceRoot":"","sources":["../../src/state/lifecycle.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAG3D;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,iBAAiB,CAAC,CAAC,IAAI;IAC/B,QAAQ,CAAC,SAAS,EAAE,CAAC,CAAC;IACtB,QAAQ,CAAC,SAAS,EAAE,CAAC,CAAC;CACzB,CAAC;AAEF;;;;;;;;;GASG;AACH,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,cAAc,GAAG,IAAI,CAIlE;AAED;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,cAAc,GAAG,IAAI,CAI1D;AAED;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,cAAc,GAAG,IAAI,CAOzD;AAED;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,cAAc,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAS1F;AAED;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAC7B,GAAG,EAAE,cAAc,EACnB,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACzC,IAAI,CAKN;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,cAAc,GAAG,IAAI,CAI5D;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,cAAc,GAAG,IAAI,CAI3D;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,cAAc,GAAG,IAAI,CAI1D"}
+{"version":3,"file":"lifecycle.d.ts","sourceRoot":"","sources":["../../src/state/lifecycle.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAG3D;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,iBAAiB,CAAC,CAAC,IAAI;IAC/B,QAAQ,CAAC,SAAS,EAAE,CAAC,CAAC;IACtB,QAAQ,CAAC,SAAS,EAAE,CAAC,CAAC;CACzB,CAAC;AAEF;;;;;;;;;GASG;AACH,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,cAAc,GAAG,IAAI,CAIlE;AAED;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,cAAc,GAAG,IAAI,CAI1D;AAED;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,cAAc,GAAG,IAAI,CAOzD;AAED;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,cAAc,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAS1F;AAED;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAC7B,GAAG,EAAE,cAAc,EACnB,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACzC,IAAI,CAKN;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,cAAc,GAAG,IAAI,CAI5D;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,cAAc,GAAG,IAAI,CAI3D;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,cAAc,GAAG,IAAI,CAI1D;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,cAAc,GAAG,IAAI,CAIlE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,cAAc,GAAG,IAAI,CAI1D"}

package/dist/state/lifecycle.js

@@ -137,4 +137,40 @@ export function resetSeriesHeads(ctx) {
         resetSeriesSlotHead(slot);
     }
 }
+/**
+ * Roll every `state.array` slot's tentative ring back to its committed ring
+ * before tick compute, so a head-replacing tick discards in-progress pushes
+ * (and a tick without a push reads the committed collection). Runs once per
+ * tick, before compute, next to {@link resetSeriesHeads}. There is no advance —
+ * the array changes only when the author pushes.
+ *
+ * @since 1.3
+ * @stable
+ * @example
+ *     // resetTentativeArraySlots(ctx);
+ *     const reset = true;
+ *     void reset;
+ */
+export function resetTentativeArraySlots(ctx) {
+    for (const slot of ctx.arraySlots.values()) {
+        slot.onBarTick();
+    }
+}
+/**
+ * Commit every `state.array` slot's tentative ring into its committed ring
+ * after close compute, so the next tick can roll back to it. Runs once per
+ * close, after compute, next to {@link commitSeriesSlots}.
+ *
+ * @since 1.3
+ * @stable
+ * @example
+ *     // commitArraySlots(ctx);
+ *     const committed = true;
+ *     void committed;
+ */
+export function commitArraySlots(ctx) {
+    for (const slot of ctx.arraySlots.values()) {
+        slot.onBarClose();
+    }
+}
 //# sourceMappingURL=lifecycle.js.map