@invinite-org/chartlang-runtime 1.1.0 → 1.2.0

package/dist/state/seriesPersistence.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.series`
+ * namespace (a `${slotIdPrefix}${slotId}:series` key). Lets the restore
+ * router separate series slots from scalar `state.*` (`:state`) and `ta.*`
+ * (`ta:`) slots, all of which share one `slots` record.
+ *
+ * @since 0.9
+ * @internal
+ * @stable
+ * @example
+ *     isSeriesSlotSnapshotKey("x.chart.ts:1:1:series"); // true
+ */
+export declare function isSeriesSlotSnapshotKey(key: string): boolean;
+/**
+ * Serialise the runner's `state.series` slots into JSON-clean snapshot
+ * entries keyed by the same `${prefix}${slotId}:series` key the slot store
+ * uses. `committedHead` is nulled when `NaN` (the validator rejects `NaN`);
+ * the buffer rides {@link Float64RingBuffer.serialiseSnapshotBuffer}.
+ *
+ * @since 0.9
+ * @internal
+ * @stable
+ * @example
+ *     // const entries = serialiseSeriesSlots(ctx);
+ *     const entries = {};
+ *     void entries;
+ */
+export declare function serialiseSeriesSlots(ctx: RuntimeContext): Readonly<Record<string, JsonValue>>;
+/**
+ * Restore `state.series` slots from namespaced snapshot entries into
+ * `ctx.seriesSlots`, rebuilding each ring via
+ * {@link Float64RingBuffer.restoreFromSnapshotBuffer} sized to the runner's
+ * current `capacity`. Non-series keys are ignored; malformed series
+ * snapshots are skipped. The view identity is recreated on restore
+ * (acceptable — same as `ta.*`).
+ *
+ * @since 0.9
+ * @internal
+ * @stable
+ * @example
+ *     // restoreSeriesSlots(ctx, snapshot.slots, capacity);
+ *     const restored = true;
+ *     void restored;
+ */
+export declare function restoreSeriesSlots(ctx: RuntimeContext, slots: Readonly<Record<string, unknown>>, capacity: number): void;
+//# sourceMappingURL=seriesPersistence.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"seriesPersistence.d.ts","sourceRoot":"","sources":["../../src/state/seriesPersistence.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAU9D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAK3D;;;;;;;;;;;GAWG;AACH,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAE5D;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,cAAc,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC,CAU7F;AAaD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,kBAAkB,CAC9B,GAAG,EAAE,cAAc,EACnB,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,QAAQ,EAAE,MAAM,GACjB,IAAI,CASN"}

package/dist/state/seriesPersistence.js

@@ -0,0 +1,87 @@
+// Copyright (c) 2026 Invinite. Licensed under the MIT License.
+// See the LICENSE file in the repo root for full license text.
+import { finiteOrNull, isBufferSnapshot, isRecord, restoreBuffer, restoreNumber, serialiseBuffer, } from "../bufferSnapshot.js";
+import { restoreSeriesSlot } from "./seriesSlot.js";
+const SERIES_SLOT_SUFFIX = ":series";
+/**
+ * Return whether a snapshot slot key belongs to the `state.series`
+ * namespace (a `${slotIdPrefix}${slotId}:series` key). Lets the restore
+ * router separate series slots from scalar `state.*` (`:state`) and `ta.*`
+ * (`ta:`) slots, all of which share one `slots` record.
+ *
+ * @since 0.9
+ * @internal
+ * @stable
+ * @example
+ *     isSeriesSlotSnapshotKey("x.chart.ts:1:1:series"); // true
+ */
+export function isSeriesSlotSnapshotKey(key) {
+    return key.endsWith(SERIES_SLOT_SUFFIX);
+}
+/**
+ * Serialise the runner's `state.series` slots into JSON-clean snapshot
+ * entries keyed by the same `${prefix}${slotId}:series` key the slot store
+ * uses. `committedHead` is nulled when `NaN` (the validator rejects `NaN`);
+ * the buffer rides {@link Float64RingBuffer.serialiseSnapshotBuffer}.
+ *
+ * @since 0.9
+ * @internal
+ * @stable
+ * @example
+ *     // const entries = serialiseSeriesSlots(ctx);
+ *     const entries = {};
+ *     void entries;
+ */
+export function serialiseSeriesSlots(ctx) {
+    const out = {};
+    for (const [key, slot] of ctx.seriesSlots.entries()) {
+        out[key] = {
+            kind: "state.series",
+            buffer: serialiseBuffer(slot.buffer),
+            committedHead: finiteOrNull(slot.committedHead),
+        };
+    }
+    return Object.freeze(out);
+}
+function restoreSeriesSlotSnapshot(snapshot, capacity) {
+    if (!isRecord(snapshot) || snapshot.kind !== "state.series")
+        return null;
+    const bufferSnapshot = snapshot.buffer;
+    if (!isBufferSnapshot(bufferSnapshot))
+        return null;
+    const committedHead = restoreNumber(snapshot.committedHead);
+    if (committedHead === null)
+        return null;
+    const buffer = restoreBuffer(bufferSnapshot, capacity);
+    if (buffer === null)
+        return null;
+    return restoreSeriesSlot(buffer, committedHead);
+}
+/**
+ * Restore `state.series` slots from namespaced snapshot entries into
+ * `ctx.seriesSlots`, rebuilding each ring via
+ * {@link Float64RingBuffer.restoreFromSnapshotBuffer} sized to the runner's
+ * current `capacity`. Non-series keys are ignored; malformed series
+ * snapshots are skipped. The view identity is recreated on restore
+ * (acceptable — same as `ta.*`).
+ *
+ * @since 0.9
+ * @internal
+ * @stable
+ * @example
+ *     // restoreSeriesSlots(ctx, snapshot.slots, capacity);
+ *     const restored = true;
+ *     void restored;
+ */
+export function restoreSeriesSlots(ctx, slots, capacity) {
+    ctx.seriesSlots.clear();
+    for (const [key, value] of Object.entries(slots)) {
+        if (!isSeriesSlotSnapshotKey(key))
+            continue;
+        const slot = restoreSeriesSlotSnapshot(value, capacity);
+        if (slot !== null) {
+            ctx.seriesSlots.set(key, slot);
+        }
+    }
+}
+//# sourceMappingURL=seriesPersistence.js.map

package/dist/state/seriesPersistence.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"seriesPersistence.js","sourceRoot":"","sources":["../../src/state/seriesPersistence.ts"],"names":[],"mappings":"AAAA,+DAA+D;AAC/D,+DAA+D;AAI/D,OAAO,EACH,YAAY,EACZ,gBAAgB,EAChB,QAAQ,EACR,aAAa,EACb,aAAa,EACb,eAAe,GAClB,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EAAE,iBAAiB,EAAmB,MAAM,iBAAiB,CAAC;AAErE,MAAM,kBAAkB,GAAG,SAAS,CAAC;AAErC;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,uBAAuB,CAAC,GAAW;IAC/C,OAAO,GAAG,CAAC,QAAQ,CAAC,kBAAkB,CAAC,CAAC;AAC5C,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,oBAAoB,CAAC,GAAmB;IACpD,MAAM,GAAG,GAA8B,EAAE,CAAC;IAC1C,KAAK,MAAM,CAAC,GAAG,EAAE,IAAI,CAAC,IAAI,GAAG,CAAC,WAAW,CAAC,OAAO,EAAE,EAAE,CAAC;QAClD,GAAG,CAAC,GAAG,CAAC,GAAG;YACP,IAAI,EAAE,cAAc;YACpB,MAAM,EAAE,eAAe,CAAC,IAAI,CAAC,MAAM,CAAC;YACpC,aAAa,EAAE,YAAY,CAAC,IAAI,CAAC,aAAa,CAAC;SAClD,CAAC;IACN,CAAC;IACD,OAAO,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;AAC9B,CAAC;AAED,SAAS,yBAAyB,CAAC,QAAiB,EAAE,QAAgB;IAClE,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,QAAQ,CAAC,IAAI,KAAK,cAAc;QAAE,OAAO,IAAI,CAAC;IACzE,MAAM,cAAc,GAAG,QAAQ,CAAC,MAAM,CAAC;IACvC,IAAI,CAAC,gBAAgB,CAAC,cAAc,CAAC;QAAE,OAAO,IAAI,CAAC;IACnD,MAAM,aAAa,GAAG,aAAa,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAC;IAC5D,IAAI,aAAa,KAAK,IAAI;QAAE,OAAO,IAAI,CAAC;IACxC,MAAM,MAAM,GAAG,aAAa,CAAC,cAAc,EAAE,QAAQ,CAAC,CAAC;IACvD,IAAI,MAAM,KAAK,IAAI;QAAE,OAAO,IAAI,CAAC;IACjC,OAAO,iBAAiB,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;AACpD,CAAC;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,kBAAkB,CAC9B,GAAmB,EACnB,KAAwC,EACxC,QAAgB;IAEhB,GAAG,CAAC,WAAW,CAAC,KAAK,EAAE,CAAC;IACxB,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QAC/C,IAAI,CAAC,uBAAuB,CAAC,GAAG,CAAC;YAAE,SAAS;QAC5C,MAAM,IAAI,GAAG,yBAAyB,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;QACxD,IAAI,IAAI,KAAK,IAAI,EAAE,CAAC;YAChB,GAAG,CAAC,WAAW,CAAC,GAAG,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;QACnC,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    finiteOrNull,\n    isBufferSnapshot,\n    isRecord,\n    restoreBuffer,\n    restoreNumber,\n    serialiseBuffer,\n} from \"../bufferSnapshot.js\";\nimport type { RuntimeContext } from \"../runtimeContext.js\";\nimport { restoreSeriesSlot, type SeriesSlot } from \"./seriesSlot.js\";\n\nconst SERIES_SLOT_SUFFIX = \":series\";\n\n/**\n * Return whether a snapshot slot key belongs to the `state.series`\n * namespace (a `${slotIdPrefix}${slotId}:series` key). Lets the restore\n * router separate series slots from scalar `state.*` (`:state`) and `ta.*`\n * (`ta:`) slots, all of which share one `slots` record.\n *\n * @since 0.9\n * @internal\n * @stable\n * @example\n *     isSeriesSlotSnapshotKey(\"x.chart.ts:1:1:series\"); // true\n */\nexport function isSeriesSlotSnapshotKey(key: string): boolean {\n    return key.endsWith(SERIES_SLOT_SUFFIX);\n}\n\n/**\n * Serialise the runner's `state.series` slots into JSON-clean snapshot\n * entries keyed by the same `${prefix}${slotId}:series` key the slot store\n * uses. `committedHead` is nulled when `NaN` (the validator rejects `NaN`);\n * the buffer rides {@link Float64RingBuffer.serialiseSnapshotBuffer}.\n *\n * @since 0.9\n * @internal\n * @stable\n * @example\n *     // const entries = serialiseSeriesSlots(ctx);\n *     const entries = {};\n *     void entries;\n */\nexport function serialiseSeriesSlots(ctx: RuntimeContext): Readonly<Record<string, JsonValue>> {\n    const out: Record<string, JsonValue> = {};\n    for (const [key, slot] of ctx.seriesSlots.entries()) {\n        out[key] = {\n            kind: \"state.series\",\n            buffer: serialiseBuffer(slot.buffer),\n            committedHead: finiteOrNull(slot.committedHead),\n        };\n    }\n    return Object.freeze(out);\n}\n\nfunction restoreSeriesSlotSnapshot(snapshot: unknown, capacity: number): SeriesSlot | null {\n    if (!isRecord(snapshot) || snapshot.kind !== \"state.series\") return null;\n    const bufferSnapshot = snapshot.buffer;\n    if (!isBufferSnapshot(bufferSnapshot)) return null;\n    const committedHead = restoreNumber(snapshot.committedHead);\n    if (committedHead === null) return null;\n    const buffer = restoreBuffer(bufferSnapshot, capacity);\n    if (buffer === null) return null;\n    return restoreSeriesSlot(buffer, committedHead);\n}\n\n/**\n * Restore `state.series` slots from namespaced snapshot entries into\n * `ctx.seriesSlots`, rebuilding each ring via\n * {@link Float64RingBuffer.restoreFromSnapshotBuffer} sized to the runner's\n * current `capacity`. Non-series keys are ignored; malformed series\n * snapshots are skipped. The view identity is recreated on restore\n * (acceptable — same as `ta.*`).\n *\n * @since 0.9\n * @internal\n * @stable\n * @example\n *     // restoreSeriesSlots(ctx, snapshot.slots, capacity);\n *     const restored = true;\n *     void restored;\n */\nexport function restoreSeriesSlots(\n    ctx: RuntimeContext,\n    slots: Readonly<Record<string, unknown>>,\n    capacity: number,\n): void {\n    ctx.seriesSlots.clear();\n    for (const [key, value] of Object.entries(slots)) {\n        if (!isSeriesSlotSnapshotKey(key)) continue;\n        const slot = restoreSeriesSlotSnapshot(value, capacity);\n        if (slot !== null) {\n            ctx.seriesSlots.set(key, slot);\n        }\n    }\n}\n"]}

package/dist/state/seriesSlot.d.ts

@@ -0,0 +1,105 @@
+import type { NumberSeriesSlot } from "@invinite-org/chartlang-core";
+import type { Float64RingBuffer } from "../ringBuffer.js";
+/**
+ * Runtime slot behind a script-facing `state.series(init)` handle. The
+ * `buffer` is the history ring (index 0 = live head); the `view` is the
+ * identity-stable {@link NumberSeriesSlot} the script reads and writes;
+ * `committedHead` snapshots the head as of the last bar close so a tick
+ * can reset the live head before the script refines it.
+ *
+ * Unlike the scalar `StateSlot`, there is no tentative/committed value
+ * split — the head IS the tentative value and history IS committed (a bar
+ * advances the ring on close). `committedHead` exists only so a tick's
+ * `resetSeriesSlotHead` can undo a prior tick's `replaceHead`.
+ *
+ * @since 0.9
+ * @stable
+ * @example
+ *     // const slot = createSeriesSlot(new Float64RingBuffer(8), 0);
+ *     // slot.view.value = 42;
+ *     // slot.view[0]; // 42
+ */
+export type SeriesSlot = {
+    readonly kind: "state.series";
+    readonly buffer: Float64RingBuffer;
+    readonly view: NumberSeriesSlot;
+    committedHead: number;
+};
+/**
+ * Build the identity-stable {@link NumberSeriesSlot} view over a ring
+ * buffer. Series reads (`[n]`, `current`, `length`, `valueOf`,
+ * `Symbol.toPrimitive`) delegate to a reused {@link makeSeriesView}; the
+ * `value` property is added on top — `get` → `buffer.at(0)` (live head),
+ * `set` → `buffer.replaceHead(v)` (write-through to the live head). The
+ * object's identity is stable across bars, so a script can keep
+ * `const s = state.series(0)` at the top of `compute`.
+ *
+ * @since 0.9
+ * @stable
+ * @example
+ *     // const view = makeSeriesSlotView(buffer);
+ *     // view.value = 7; // replaceHead
+ *     // +view;          // 7  (valueOf → buffer.at(0))
+ *     // view[1];        // one committed bar back
+ */
+export declare function makeSeriesSlotView(buffer: Float64RingBuffer): NumberSeriesSlot;
+/**
+ * Allocate a fresh {@link SeriesSlot}: seed the live head with `init`
+ * (matching `state.float(init)` — a never-written series reads `init` on
+ * its allocation bar), set `committedHead = init`, and build the
+ * identity-stable view. Later bars the script does not write become `NaN`
+ * gaps because the close hook advances the ring with `append(NaN)`.
+ *
+ * @since 0.9
+ * @stable
+ * @example
+ *     // const slot = createSeriesSlot(new Float64RingBuffer(8), 0);
+ *     // slot.view[0]; // 0 (the seeded init on the allocation bar)
+ */
+export declare function createSeriesSlot(buffer: Float64RingBuffer, init: number): SeriesSlot;
+/**
+ * Rebuild a {@link SeriesSlot} over an already-restored ring buffer
+ * (snapshot path). The view identity is recreated — acceptable, same as
+ * `ta.*` restore.
+ *
+ * @since 0.9
+ * @stable
+ * @example
+ *     // const slot = restoreSeriesSlot(restoredBuffer, committedHead);
+ *     // slot.view[1];
+ */
+export declare function restoreSeriesSlot(buffer: Float64RingBuffer, committedHead: number): SeriesSlot;
+/**
+ * Advance the ring for a new close bar: append a fresh `NaN` head so the
+ * prior committed head slides to index 1. Runs once per close, before the
+ * script's compute, for every already-allocated slot.
+ *
+ * @since 0.9
+ * @stable
+ * @example
+ *     // advanceSeriesSlot(slot); // slot.view[0] is now NaN until written
+ */
+export declare function advanceSeriesSlot(slot: SeriesSlot): void;
+/**
+ * Commit the live head as the bar-close value, so the next close's
+ * `advanceSeriesSlot` retains it and a subsequent tick's
+ * `resetSeriesSlotHead` restores it. Runs once per close, after compute.
+ *
+ * @since 0.9
+ * @stable
+ * @example
+ *     // commitSeriesSlot(slot); // slot.committedHead = slot.view[0]
+ */
+export declare function commitSeriesSlot(slot: SeriesSlot): void;
+/**
+ * Reset the live head to the last committed value at the start of a tick,
+ * so a tick that re-writes refines from the committed baseline and a tick
+ * that does not write reads the committed head. Does NOT advance length.
+ *
+ * @since 0.9
+ * @stable
+ * @example
+ *     // resetSeriesSlotHead(slot); // slot.view[0] = slot.committedHead
+ */
+export declare function resetSeriesSlotHead(slot: SeriesSlot): void;
+//# sourceMappingURL=seriesSlot.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"seriesSlot.d.ts","sourceRoot":"","sources":["../../src/state/seriesSlot.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAErE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAG1D;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,MAAM,UAAU,GAAG;IACrB,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;IAC9B,QAAQ,CAAC,MAAM,EAAE,iBAAiB,CAAC;IACnC,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC;IAChC,aAAa,EAAE,MAAM,CAAC;CACzB,CAAC;AAEF;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,iBAAiB,GAAG,gBAAgB,CAmB9E;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,iBAAiB,EAAE,IAAI,EAAE,MAAM,GAAG,UAAU,CAQpF;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,GAAG,UAAU,CAO9F;AAED;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI,CAExD;AAED;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI,CAEvD;AAED;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI,CAE1D"}

package/dist/state/seriesSlot.js

@@ -0,0 +1,123 @@
+// Copyright (c) 2026 Invinite. Licensed under the MIT License.
+// See the LICENSE file in the repo root for full license text.
+import { makeSeriesView } from "../seriesView.js";
+/**
+ * Build the identity-stable {@link NumberSeriesSlot} view over a ring
+ * buffer. Series reads (`[n]`, `current`, `length`, `valueOf`,
+ * `Symbol.toPrimitive`) delegate to a reused {@link makeSeriesView}; the
+ * `value` property is added on top — `get` → `buffer.at(0)` (live head),
+ * `set` → `buffer.replaceHead(v)` (write-through to the live head). The
+ * object's identity is stable across bars, so a script can keep
+ * `const s = state.series(0)` at the top of `compute`.
+ *
+ * @since 0.9
+ * @stable
+ * @example
+ *     // const view = makeSeriesSlotView(buffer);
+ *     // view.value = 7; // replaceHead
+ *     // +view;          // 7  (valueOf → buffer.at(0))
+ *     // view[1];        // one committed bar back
+ */
+export function makeSeriesSlotView(buffer) {
+    const reads = makeSeriesView(buffer);
+    return new Proxy(reads, {
+        get(target, prop, receiver) {
+            if (prop === "value")
+                return buffer.at(0);
+            return Reflect.get(target, prop, receiver);
+        },
+        set(_target, prop, value) {
+            if (prop === "value") {
+                buffer.replaceHead(value);
+                return true;
+            }
+            return false;
+        },
+        has(target, prop) {
+            if (prop === "value")
+                return true;
+            return Reflect.has(target, prop);
+        },
+    });
+}
+/**
+ * Allocate a fresh {@link SeriesSlot}: seed the live head with `init`
+ * (matching `state.float(init)` — a never-written series reads `init` on
+ * its allocation bar), set `committedHead = init`, and build the
+ * identity-stable view. Later bars the script does not write become `NaN`
+ * gaps because the close hook advances the ring with `append(NaN)`.
+ *
+ * @since 0.9
+ * @stable
+ * @example
+ *     // const slot = createSeriesSlot(new Float64RingBuffer(8), 0);
+ *     // slot.view[0]; // 0 (the seeded init on the allocation bar)
+ */
+export function createSeriesSlot(buffer, init) {
+    buffer.append(init);
+    return {
+        kind: "state.series",
+        buffer,
+        view: makeSeriesSlotView(buffer),
+        committedHead: init,
+    };
+}
+/**
+ * Rebuild a {@link SeriesSlot} over an already-restored ring buffer
+ * (snapshot path). The view identity is recreated — acceptable, same as
+ * `ta.*` restore.
+ *
+ * @since 0.9
+ * @stable
+ * @example
+ *     // const slot = restoreSeriesSlot(restoredBuffer, committedHead);
+ *     // slot.view[1];
+ */
+export function restoreSeriesSlot(buffer, committedHead) {
+    return {
+        kind: "state.series",
+        buffer,
+        view: makeSeriesSlotView(buffer),
+        committedHead,
+    };
+}
+/**
+ * Advance the ring for a new close bar: append a fresh `NaN` head so the
+ * prior committed head slides to index 1. Runs once per close, before the
+ * script's compute, for every already-allocated slot.
+ *
+ * @since 0.9
+ * @stable
+ * @example
+ *     // advanceSeriesSlot(slot); // slot.view[0] is now NaN until written
+ */
+export function advanceSeriesSlot(slot) {
+    slot.buffer.append(Number.NaN);
+}
+/**
+ * Commit the live head as the bar-close value, so the next close's
+ * `advanceSeriesSlot` retains it and a subsequent tick's
+ * `resetSeriesSlotHead` restores it. Runs once per close, after compute.
+ *
+ * @since 0.9
+ * @stable
+ * @example
+ *     // commitSeriesSlot(slot); // slot.committedHead = slot.view[0]
+ */
+export function commitSeriesSlot(slot) {
+    slot.committedHead = slot.buffer.at(0);
+}
+/**
+ * Reset the live head to the last committed value at the start of a tick,
+ * so a tick that re-writes refines from the committed baseline and a tick
+ * that does not write reads the committed head. Does NOT advance length.
+ *
+ * @since 0.9
+ * @stable
+ * @example
+ *     // resetSeriesSlotHead(slot); // slot.view[0] = slot.committedHead
+ */
+export function resetSeriesSlotHead(slot) {
+    slot.buffer.replaceHead(slot.committedHead);
+}
+//# sourceMappingURL=seriesSlot.js.map

package/dist/state/seriesSlot.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"seriesSlot.js","sourceRoot":"","sources":["../../src/state/seriesSlot.ts"],"names":[],"mappings":"AAAA,+DAA+D;AAC/D,+DAA+D;AAK/D,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AA4BlD;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,kBAAkB,CAAC,MAAyB;IACxD,MAAM,KAAK,GAAG,cAAc,CAAS,MAAM,CAAC,CAAC;IAC7C,OAAO,IAAI,KAAK,CAAC,KAAyB,EAAE;QACxC,GAAG,CAAC,MAAM,EAAE,IAAI,EAAE,QAAQ;YACtB,IAAI,IAAI,KAAK,OAAO;gBAAE,OAAO,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;YAC1C,OAAO,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,IAAI,EAAE,QAAQ,CAAC,CAAC;QAC/C,CAAC;QACD,GAAG,CAAC,OAAO,EAAE,IAAI,EAAE,KAAK;YACpB,IAAI,IAAI,KAAK,OAAO,EAAE,CAAC;gBACnB,MAAM,CAAC,WAAW,CAAC,KAAe,CAAC,CAAC;gBACpC,OAAO,IAAI,CAAC;YAChB,CAAC;YACD,OAAO,KAAK,CAAC;QACjB,CAAC;QACD,GAAG,CAAC,MAAM,EAAE,IAAI;YACZ,IAAI,IAAI,KAAK,OAAO;gBAAE,OAAO,IAAI,CAAC;YAClC,OAAO,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;QACrC,CAAC;KACJ,CAAC,CAAC;AACP,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,gBAAgB,CAAC,MAAyB,EAAE,IAAY;IACpE,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IACpB,OAAO;QACH,IAAI,EAAE,cAAc;QACpB,MAAM;QACN,IAAI,EAAE,kBAAkB,CAAC,MAAM,CAAC;QAChC,aAAa,EAAE,IAAI;KACtB,CAAC;AACN,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,iBAAiB,CAAC,MAAyB,EAAE,aAAqB;IAC9E,OAAO;QACH,IAAI,EAAE,cAAc;QACpB,MAAM;QACN,IAAI,EAAE,kBAAkB,CAAC,MAAM,CAAC;QAChC,aAAa;KAChB,CAAC;AACN,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,iBAAiB,CAAC,IAAgB;IAC9C,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;AACnC,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,gBAAgB,CAAC,IAAgB;IAC7C,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;AAC3C,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,mBAAmB,CAAC,IAAgB;IAChD,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;AAChD,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 { NumberSeriesSlot } from \"@invinite-org/chartlang-core\";\n\nimport type { Float64RingBuffer } from \"../ringBuffer.js\";\nimport { makeSeriesView } from \"../seriesView.js\";\n\n/**\n * Runtime slot behind a script-facing `state.series(init)` handle. The\n * `buffer` is the history ring (index 0 = live head); the `view` is the\n * identity-stable {@link NumberSeriesSlot} the script reads and writes;\n * `committedHead` snapshots the head as of the last bar close so a tick\n * can reset the live head before the script refines it.\n *\n * Unlike the scalar `StateSlot`, there is no tentative/committed value\n * split — the head IS the tentative value and history IS committed (a bar\n * advances the ring on close). `committedHead` exists only so a tick's\n * `resetSeriesSlotHead` can undo a prior tick's `replaceHead`.\n *\n * @since 0.9\n * @stable\n * @example\n *     // const slot = createSeriesSlot(new Float64RingBuffer(8), 0);\n *     // slot.view.value = 42;\n *     // slot.view[0]; // 42\n */\nexport type SeriesSlot = {\n    readonly kind: \"state.series\";\n    readonly buffer: Float64RingBuffer;\n    readonly view: NumberSeriesSlot;\n    committedHead: number;\n};\n\n/**\n * Build the identity-stable {@link NumberSeriesSlot} view over a ring\n * buffer. Series reads (`[n]`, `current`, `length`, `valueOf`,\n * `Symbol.toPrimitive`) delegate to a reused {@link makeSeriesView}; the\n * `value` property is added on top — `get` → `buffer.at(0)` (live head),\n * `set` → `buffer.replaceHead(v)` (write-through to the live head). The\n * object's identity is stable across bars, so a script can keep\n * `const s = state.series(0)` at the top of `compute`.\n *\n * @since 0.9\n * @stable\n * @example\n *     // const view = makeSeriesSlotView(buffer);\n *     // view.value = 7; // replaceHead\n *     // +view;          // 7  (valueOf → buffer.at(0))\n *     // view[1];        // one committed bar back\n */\nexport function makeSeriesSlotView(buffer: Float64RingBuffer): NumberSeriesSlot {\n    const reads = makeSeriesView<number>(buffer);\n    return new Proxy(reads as NumberSeriesSlot, {\n        get(target, prop, receiver) {\n            if (prop === \"value\") return buffer.at(0);\n            return Reflect.get(target, prop, receiver);\n        },\n        set(_target, prop, value) {\n            if (prop === \"value\") {\n                buffer.replaceHead(value as number);\n                return true;\n            }\n            return false;\n        },\n        has(target, prop) {\n            if (prop === \"value\") return true;\n            return Reflect.has(target, prop);\n        },\n    });\n}\n\n/**\n * Allocate a fresh {@link SeriesSlot}: seed the live head with `init`\n * (matching `state.float(init)` — a never-written series reads `init` on\n * its allocation bar), set `committedHead = init`, and build the\n * identity-stable view. Later bars the script does not write become `NaN`\n * gaps because the close hook advances the ring with `append(NaN)`.\n *\n * @since 0.9\n * @stable\n * @example\n *     // const slot = createSeriesSlot(new Float64RingBuffer(8), 0);\n *     // slot.view[0]; // 0 (the seeded init on the allocation bar)\n */\nexport function createSeriesSlot(buffer: Float64RingBuffer, init: number): SeriesSlot {\n    buffer.append(init);\n    return {\n        kind: \"state.series\",\n        buffer,\n        view: makeSeriesSlotView(buffer),\n        committedHead: init,\n    };\n}\n\n/**\n * Rebuild a {@link SeriesSlot} over an already-restored ring buffer\n * (snapshot path). The view identity is recreated — acceptable, same as\n * `ta.*` restore.\n *\n * @since 0.9\n * @stable\n * @example\n *     // const slot = restoreSeriesSlot(restoredBuffer, committedHead);\n *     // slot.view[1];\n */\nexport function restoreSeriesSlot(buffer: Float64RingBuffer, committedHead: number): SeriesSlot {\n    return {\n        kind: \"state.series\",\n        buffer,\n        view: makeSeriesSlotView(buffer),\n        committedHead,\n    };\n}\n\n/**\n * Advance the ring for a new close bar: append a fresh `NaN` head so the\n * prior committed head slides to index 1. Runs once per close, before the\n * script's compute, for every already-allocated slot.\n *\n * @since 0.9\n * @stable\n * @example\n *     // advanceSeriesSlot(slot); // slot.view[0] is now NaN until written\n */\nexport function advanceSeriesSlot(slot: SeriesSlot): void {\n    slot.buffer.append(Number.NaN);\n}\n\n/**\n * Commit the live head as the bar-close value, so the next close's\n * `advanceSeriesSlot` retains it and a subsequent tick's\n * `resetSeriesSlotHead` restores it. Runs once per close, after compute.\n *\n * @since 0.9\n * @stable\n * @example\n *     // commitSeriesSlot(slot); // slot.committedHead = slot.view[0]\n */\nexport function commitSeriesSlot(slot: SeriesSlot): void {\n    slot.committedHead = slot.buffer.at(0);\n}\n\n/**\n * Reset the live head to the last committed value at the start of a tick,\n * so a tick that re-writes refines from the committed baseline and a tick\n * that does not write reads the committed head. Does NOT advance length.\n *\n * @since 0.9\n * @stable\n * @example\n *     // resetSeriesSlotHead(slot); // slot.view[0] = slot.committedHead\n */\nexport function resetSeriesSlotHead(slot: SeriesSlot): void {\n    slot.buffer.replaceHead(slot.committedHead);\n}\n"]}

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

@@ -1 +1 @@
-{"version":3,"file":"stateNamespace.d.ts","sourceRoot":"","sources":["../../src/state/stateNamespace.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAe,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAsDhF;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,IAAI,cAAc,CAwBpD"}
+{"version":3,"file":"stateNamespace.d.ts","sourceRoot":"","sources":["../../src/state/stateNamespace.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAiC,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAoFlG;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,IAAI,cAAc,CA0BpD"}

package/dist/state/stateNamespace.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.
+import { Float64RingBuffer } from "../ringBuffer.js";
 import { ACTIVE_RUNTIME_CONTEXT } from "../runtimeContext.js";
+import { createSeriesSlot } from "./seriesSlot.js";
 import { asMutableSlot, StateSlot } from "./stateSlot.js";
 /**
  * Compose the runtime's `state.*` slot key from the compiler-injected
@@ -14,6 +16,16 @@ import { asMutableSlot, StateSlot } from "./stateSlot.js";
  * @internal
  */
 const stateKey = (ctx, slotId) => `${ctx.slotIdPrefix ?? ""}${slotId}:state`;
+/**
+ * Compose the runtime's `state.series` slot key — the `:series` suffix
+ * (vs `:state`) lets the snapshot restore router tell a series slot from a
+ * scalar `state.*` slot. The `slotIdPrefix` isolation rule is identical to
+ * {@link stateKey}.
+ *
+ * @since 0.9
+ * @internal
+ */
+const seriesKey = (ctx, slotId) => `${ctx.slotIdPrefix ?? ""}${slotId}:series`;
 function getCtx(name) {
     const ctx = ACTIVE_RUNTIME_CONTEXT.current;
     if (ctx === null) {
@@ -36,6 +48,21 @@ function getOrAllocate(name, slotId, init, tickPersistent) {
     ctx.stateSlots.set(key, slot);
     return asMutableSlot(slot);
 }
+function getOrAllocateSeries(slotId, init) {
+    const ctx = getCtx("state.series");
+    const key = seriesKey(ctx, slotId);
+    const existing = ctx.seriesSlots.get(key);
+    if (existing !== undefined) {
+        return existing.view;
+    }
+    // Size the ring to the runner's global capacity (`maxLookback + 1`, or
+    // the 5000-slot dynamic fallback). Warm restart rehydrates `seriesSlots`
+    // up front via `restoreSeriesSlots`, so a restored slot is found above
+    // and this seed path only runs for a genuinely first-seen callsite.
+    const slot = createSeriesSlot(new Float64RingBuffer(ctx.stream.ohlcv.close.capacity), init);
+    ctx.seriesSlots.set(key, slot);
+    return slot.view;
+}
 /**
  * Build the runtime `state` namespace installed on `ComputeContext`.
  * Each function accepts the compiler-injected `slotId` as its first
@@ -53,6 +80,7 @@ export function buildStateNamespace() {
         int: (slotId, init) => getOrAllocate("state.int", slotId, init, false),
         bool: (slotId, init) => getOrAllocate("state.bool", slotId, init, false),
         string: (slotId, init) => getOrAllocate("state.string", slotId, init, false),
+        series: (slotId, init) => getOrAllocateSeries(slotId, init),
         tick: {
             float: (slotId, init) => getOrAllocate("state.tick.float", slotId, init, true),
             int: (slotId, init) => getOrAllocate("state.tick.int", slotId, init, true),

package/dist/state/stateNamespace.js.map

@@ -1 +1 @@
-{"version":3,"file":"stateNamespace.js","sourceRoot":"","sources":["../../src/state/stateNamespace.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"stateNamespace.js","sourceRoot":"","sources":["../../src/state/stateNamespace.ts"],"names":[],"mappings":"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","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 { MutableSlot, NumberSeriesSlot, StateNamespace } from \"@invinite-org/chartlang-core\";\n\nimport { Float64RingBuffer } from \"../ringBuffer.js\";\nimport { ACTIVE_RUNTIME_CONTEXT, type RuntimeContext } from \"../runtimeContext.js\";\nimport { createSeriesSlot } from \"./seriesSlot.js\";\nimport { asMutableSlot, StateSlot } from \"./stateSlot.js\";\n\ntype StoredStateSlot<T> = {\n    readonly committed: T;\n    readonly tentative: T;\n};\n\n/**\n * Compose the runtime's `state.*` slot key from the compiler-injected\n * `slotId` plus the active context's `slotIdPrefix`. The primary runner\n * has an absent / empty prefix — its keys stay byte-identical to the\n * Phase-1 `${slotId}:state` shape so single-script snapshots load\n * unchanged. `DepRunner` contexts carry `dep:<localId>/`,\n * `SiblingRunner` contexts carry `export:<exportName>/`.\n *\n * @since 0.7\n * @internal\n */\nconst stateKey = (ctx: RuntimeContext, slotId: string): string =>\n    `${ctx.slotIdPrefix ?? \"\"}${slotId}:state`;\n\n/**\n * Compose the runtime's `state.series` slot key — the `:series` suffix\n * (vs `:state`) lets the snapshot restore router tell a series slot from a\n * scalar `state.*` slot. The `slotIdPrefix` isolation rule is identical to\n * {@link stateKey}.\n *\n * @since 0.9\n * @internal\n */\nconst seriesKey = (ctx: RuntimeContext, slotId: string): string =>\n    `${ctx.slotIdPrefix ?? \"\"}${slotId}:series`;\n\nfunction getCtx(name: string): RuntimeContext {\n    const ctx = ACTIVE_RUNTIME_CONTEXT.current;\n    if (ctx === null) {\n        throw new Error(`${name} called outside an active script step`);\n    }\n    return ctx;\n}\n\nfunction getOrAllocate<T>(\n    name: string,\n    slotId: string,\n    init: T,\n    tickPersistent: boolean,\n): MutableSlot<T> {\n    const ctx = getCtx(name);\n    const key = stateKey(ctx, slotId);\n    const existing = ctx.stateSlots.get(key);\n    if (existing !== undefined) {\n        return asMutableSlot(existing as StateSlot<T>);\n    }\n\n    const stored = ctx.stateStore.get<StoredStateSlot<T>>(key);\n    const slot = new StateSlot<T>(stored?.committed ?? init, tickPersistent);\n    if (stored !== undefined) {\n        slot.tentative = stored.tentative;\n    }\n    ctx.stateSlots.set(key, slot as StateSlot<unknown>);\n    return asMutableSlot(slot);\n}\n\nfunction getOrAllocateSeries(slotId: string, init: number): NumberSeriesSlot {\n    const ctx = getCtx(\"state.series\");\n    const key = seriesKey(ctx, slotId);\n    const existing = ctx.seriesSlots.get(key);\n    if (existing !== undefined) {\n        return existing.view;\n    }\n    // Size the ring to the runner's global capacity (`maxLookback + 1`, or\n    // the 5000-slot dynamic fallback). Warm restart rehydrates `seriesSlots`\n    // up front via `restoreSeriesSlots`, so a restored slot is found above\n    // and this seed path only runs for a genuinely first-seen callsite.\n    const slot = createSeriesSlot(new Float64RingBuffer(ctx.stream.ohlcv.close.capacity), init);\n    ctx.seriesSlots.set(key, slot);\n    return slot.view;\n}\n\n/**\n * Build the runtime `state` namespace installed on `ComputeContext`.\n * Each function accepts the compiler-injected `slotId` as its first\n * parameter, then the script-facing init value.\n *\n * @since 0.4\n * @stable\n * @example\n *     const ns = buildStateNamespace();\n *     void ns.float;\n */\nexport function buildStateNamespace(): StateNamespace {\n    const ns = {\n        float: (slotId: string, init: number): MutableSlot<number> =>\n            getOrAllocate(\"state.float\", slotId, init, false),\n        int: (slotId: string, init: number): MutableSlot<number> =>\n            getOrAllocate(\"state.int\", slotId, init, false),\n        bool: (slotId: string, init: boolean): MutableSlot<boolean> =>\n            getOrAllocate(\"state.bool\", slotId, init, false),\n        string: (slotId: string, init: string): MutableSlot<string> =>\n            getOrAllocate(\"state.string\", slotId, init, false),\n        series: (slotId: string, init: number): NumberSeriesSlot =>\n            getOrAllocateSeries(slotId, init),\n        tick: {\n            float: (slotId: string, init: number): MutableSlot<number> =>\n                getOrAllocate(\"state.tick.float\", slotId, init, true),\n            int: (slotId: string, init: number): MutableSlot<number> =>\n                getOrAllocate(\"state.tick.int\", slotId, init, true),\n            bool: (slotId: string, init: boolean): MutableSlot<boolean> =>\n                getOrAllocate(\"state.tick.bool\", slotId, init, true),\n            string: (slotId: string, init: string): MutableSlot<string> =>\n                getOrAllocate(\"state.tick.string\", slotId, init, true),\n        },\n    };\n    Object.freeze(ns.tick);\n    Object.freeze(ns);\n    return ns as unknown as StateNamespace;\n}\n"]}

package/dist/state/stateSlot.js.map

@@ -1 +1 @@
-{"version":3,"file":"stateSlot.js","sourceRoot":"","sources":["../../src/state/stateSlot.ts"],"names":[],"mappings":"AAAA,+DAA+D;AAC/D,+DAA+D;AAwB/D;;;;;;;;;;;;;;GAcG;AACH,MAAM,OAAO,SAAS;IAME;IACC;IANrB,SAAS,CAAI;IACb,SAAS,CAAI;IAEb,YACI,IAAO,EACS,cAAuB,EACtB,cAAuC,EAAE;QAD1C,mBAAc,GAAd,cAAc,CAAS;QACtB,gBAAW,GAAX,WAAW,CAA8B;QAE1D,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;QACtB,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;IAC1B,CAAC;IAED,GAAG;QACC,OAAO,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC;IACjE,CAAC;IAED,GAAG,CAAC,KAAQ;QACR,IAAI,IAAI,CAAC,cAAc,EAAE,CAAC;YACtB,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;QAC3B,CAAC;aAAM,CAAC;YACJ,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;QAC3B,CAAC;IACL,CAAC;IAED,UAAU;QACN,IAAI,CAAC,IAAI,CAAC,cAAc,EAAE,CAAC;YACvB,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC;QACpC,CAAC;IACL,CAAC;IAED,SAAS;QACL,IAAI,CAAC,IAAI,CAAC,cAAc,EAAE,CAAC;YACvB,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC;QACpC,CAAC;IACL,CAAC;IAED,SAAS,CAAC,KAAQ;QACd,OAAO,IAAI,CAAC,WAAW,CAAC,cAAc,EAAE,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC;IAC7D,CAAC;CACJ;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,aAAa,CAAI,IAAkB;IAC/C,OAAO;QACH,IAAI,KAAK;YACL,OAAO,IAAI,CAAC,GAAG,EAAE,CAAC;QACtB,CAAC;QACD,IAAI,KAAK,CAAC,KAAQ;YACd,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QACpB,CAAC;KACJ,CAAC;AACN,CAAC"}
+{"version":3,"file":"stateSlot.js","sourceRoot":"","sources":["../../src/state/stateSlot.ts"],"names":[],"mappings":"AAAA,+DAA+D;AAC/D,+DAA+D;AAwB/D;;;;;;;;;;;;;;GAcG;AACH,MAAM,OAAO,SAAS;IAME;IACC;IANrB,SAAS,CAAI;IACb,SAAS,CAAI;IAEb,YACI,IAAO,EACS,cAAuB,EACtB,cAAuC,EAAE;QAD1C,mBAAc,GAAd,cAAc,CAAS;QACtB,gBAAW,GAAX,WAAW,CAA8B;QAE1D,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;QACtB,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;IAC1B,CAAC;IAED,GAAG;QACC,OAAO,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC;IACjE,CAAC;IAED,GAAG,CAAC,KAAQ;QACR,IAAI,IAAI,CAAC,cAAc,EAAE,CAAC;YACtB,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;QAC3B,CAAC;aAAM,CAAC;YACJ,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;QAC3B,CAAC;IACL,CAAC;IAED,UAAU;QACN,IAAI,CAAC,IAAI,CAAC,cAAc,EAAE,CAAC;YACvB,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC;QACpC,CAAC;IACL,CAAC;IAED,SAAS;QACL,IAAI,CAAC,IAAI,CAAC,cAAc,EAAE,CAAC;YACvB,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC;QACpC,CAAC;IACL,CAAC;IAED,SAAS,CAAC,KAAQ;QACd,OAAO,IAAI,CAAC,WAAW,CAAC,cAAc,EAAE,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC;IAC7D,CAAC;CACJ;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,aAAa,CAAI,IAAkB;IAC/C,OAAO;QACH,IAAI,KAAK;YACL,OAAO,IAAI,CAAC,GAAG,EAAE,CAAC;QACtB,CAAC;QACD,IAAI,KAAK,CAAC,KAAQ;YACd,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QACpB,CAAC;KACJ,CAAC;AACN,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 { MutableSlot } from \"@invinite-org/chartlang-core\";\n\n/**\n * Optional PLAN §6.9 state-slot marshal hooks. Phase-4 `state.*`\n * primitives use the identity default because their values are already\n * JSON-clean; future primitives with typed-array internals can provide\n * explicit hooks.\n *\n * @since 0.5\n * @stable\n * @example\n *     const hooks: StateSlotSerialisers<number> = {\n *         serialiseState: (value) => value,\n *         deserialiseState: (value) => Number(value),\n *     };\n *     void hooks;\n */\nexport type StateSlotSerialisers<T> = {\n    readonly serialiseState?: (value: T) => unknown;\n    readonly deserialiseState?: (value: unknown) => T;\n};\n\n/**\n * Internal runtime slot behind script-facing {@link MutableSlot}\n * proxies. `tickPersistent: true` models `state.tick.*`, whose writes\n * commit immediately; `false` models `state.*`, whose writes remain\n * tentative until bar close.\n *\n * @since 0.4\n * @stable\n * @example\n *     const slot = new StateSlot(0, false);\n *     slot.set(5);\n *     slot.onBarClose();\n *     const pair = { committed: slot.committed, tentative: slot.tentative };\n *     void pair;\n */\nexport class StateSlot<T> {\n    committed: T;\n    tentative: T;\n\n    constructor(\n        init: T,\n        public readonly tickPersistent: boolean,\n        private readonly serialisers: StateSlotSerialisers<T> = {},\n    ) {\n        this.committed = init;\n        this.tentative = init;\n    }\n\n    get(): T {\n        return this.tickPersistent ? this.committed : this.tentative;\n    }\n\n    set(value: T): void {\n        if (this.tickPersistent) {\n            this.committed = value;\n        } else {\n            this.tentative = value;\n        }\n    }\n\n    onBarClose(): void {\n        if (!this.tickPersistent) {\n            this.committed = this.tentative;\n        }\n    }\n\n    onBarTick(): void {\n        if (!this.tickPersistent) {\n            this.tentative = this.committed;\n        }\n    }\n\n    serialise(value: T): unknown {\n        return this.serialisers.serialiseState?.(value) ?? value;\n    }\n}\n\n/**\n * Build the script-facing mutable proxy for a runtime state slot.\n *\n * @since 0.4\n * @stable\n * @example\n *     const slot = asMutableSlot(new StateSlot(1, false));\n *     slot.value = 2;\n *     void slot.value;\n */\nexport function asMutableSlot<T>(slot: StateSlot<T>): MutableSlot<T> {\n    return {\n        get value(): T {\n            return slot.get();\n        },\n        set value(value: T) {\n            slot.set(value);\n        },\n    };\n}\n"]}

package/dist/stateStore.d.ts

@@ -2,11 +2,11 @@
  * Per-runner slot store the runtime hands stateful primitives. Phase 1
  * ships only the in-memory default — `inMemoryStateStore()` — keyed
  * by `${slotIdPrefix ?? ""}${slotId}:state` where the slot id is the
- * compiler-assigned id from PLAN.md §5.5 and the prefix is the active
+ * compiler-assigned id and the prefix is the active
  * `RuntimeContext.slotIdPrefix` (`""` for primary, `dep:<localId>/`
  * for deps, `export:<exportName>/` for siblings — see Task 5). Phase 5
  * layers a `PersistentStateStore` sub-interface on top with snapshot
- * `load` / `save` / `clear` methods (see PLAN.md §6.9). Implementations
+ * `load` / `save` / `clear` methods. Implementations
  * (IDB-backed for browsers, caller-supplied for servers) satisfy the
  * Phase-5 sub-interface; the Phase-1 surface stays stable and
  * additive.

package/dist/stateStore.js.map

@@ -1 +1 @@
-{"version":3,"file":"stateStore.js","sourceRoot":"","sources":["../src/stateStore.ts"],"names":[],"mappings":"AAAA,+DAA+D;AAC/D,+DAA+D;AA8B/D;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,kBAAkB;IAC9B,MAAM,KAAK,GAAG,IAAI,GAAG,EAAmB,CAAC;IACzC,OAAO;QACH,GAAG,CAAI,EAAU;YACb,OAAO,KAAK,CAAC,GAAG,CAAC,EAAE,CAAkB,CAAC;QAC1C,CAAC;QACD,GAAG,CAAI,EAAU,EAAE,KAAQ;YACvB,KAAK,CAAC,GAAG,CAAC,EAAE,EAAE,KAAK,CAAC,CAAC;QACzB,CAAC;QACD,GAAG,CAAC,EAAU;YACV,OAAO,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;QACzB,CAAC;QACD,KAAK;YACD,KAAK,CAAC,KAAK,EAAE,CAAC;QAClB,CAAC;KACJ,CAAC;AACN,CAAC"}
+{"version":3,"file":"stateStore.js","sourceRoot":"","sources":["../src/stateStore.ts"],"names":[],"mappings":"AAAA,+DAA+D;AAC/D,+DAA+D;AA8B/D;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,kBAAkB;IAC9B,MAAM,KAAK,GAAG,IAAI,GAAG,EAAmB,CAAC;IACzC,OAAO;QACH,GAAG,CAAI,EAAU;YACb,OAAO,KAAK,CAAC,GAAG,CAAC,EAAE,CAAkB,CAAC;QAC1C,CAAC;QACD,GAAG,CAAI,EAAU,EAAE,KAAQ;YACvB,KAAK,CAAC,GAAG,CAAC,EAAE,EAAE,KAAK,CAAC,CAAC;QACzB,CAAC;QACD,GAAG,CAAC,EAAU;YACV,OAAO,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;QACzB,CAAC;QACD,KAAK;YACD,KAAK,CAAC,KAAK,EAAE,CAAC;QAClB,CAAC;KACJ,CAAC;AACN,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\n/**\n * Per-runner slot store the runtime hands stateful primitives. Phase 1\n * ships only the in-memory default — `inMemoryStateStore()` — keyed\n * by `${slotIdPrefix ?? \"\"}${slotId}:state` where the slot id is the\n * compiler-assigned id and the prefix is the active\n * `RuntimeContext.slotIdPrefix` (`\"\"` for primary, `dep:<localId>/`\n * for deps, `export:<exportName>/` for siblings — see Task 5). Phase 5\n * layers a `PersistentStateStore` sub-interface on top with snapshot\n * `load` / `save` / `clear` methods. Implementations\n * (IDB-backed for browsers, caller-supplied for servers) satisfy the\n * Phase-5 sub-interface; the Phase-1 surface stays stable and\n * additive.\n *\n * @since 0.1\n * @example\n *     // import { inMemoryStateStore } from \"@invinite-org/chartlang-runtime\";\n *     // const store = inMemoryStateStore();\n *     // store.set<{ count: number }>(\"ta:ema:slot#0\", { count: 1 });\n *     // store.has(\"ta:ema:slot#0\"); // true\n *     // store.get<{ count: number }>(\"ta:ema:slot#0\"); // { count: 1 }\n */\nexport type StateStore = {\n    get<T>(slotId: string): T | undefined;\n    set<T>(slotId: string, value: T): void;\n    has(slotId: string): boolean;\n    clear(): void;\n};\n\n/**\n * Default Phase-1 `StateStore` — a process-local `Map<string, unknown>`\n * with last-write-wins semantics. Used by the CLI, the conformance\n * suite, and the host-worker until Phase 5 wires the IDB backing.\n *\n * @since 0.1\n * @example\n *     // import { inMemoryStateStore } from \"@invinite-org/chartlang-runtime\";\n *     // const store = inMemoryStateStore();\n *     // store.set(\"slot#0\", 42);\n *     // store.get<number>(\"slot#0\"); // 42\n *     // store.clear();\n *     // store.has(\"slot#0\"); // false\n */\nexport function inMemoryStateStore(): StateStore {\n    const store = new Map<string, unknown>();\n    return {\n        get<T>(id: string): T | undefined {\n            return store.get(id) as T | undefined;\n        },\n        set<T>(id: string, value: T): void {\n            store.set(id, value);\n        },\n        has(id: string): boolean {\n            return store.has(id);\n        },\n        clear(): void {\n            store.clear();\n        },\n    };\n}\n"]}

package/dist/streamState.d.ts

@@ -1,4 +1,4 @@
-import type { Bar, BarViewport, Series, StreamSnapshot } from "@invinite-org/chartlang-core";
+import type { Bar, BarViewport, Price, PriceSeries, Series, StreamSnapshot, VolumeSeries, WorldPoint } from "@invinite-org/chartlang-core";
 import { Float64RingBuffer } from "./ringBuffer.js";
 /**
  * The per-stream OHLCV ring-buffer set. Each field is a
@@ -31,13 +31,17 @@ export type OhlcvBuffers = {
     readonly hlcc4: Float64RingBuffer;
 };
 /**
- * Mutable scalar view of the current bar. Identity stays stable across
- * the run — Task 6's execution loop mutates the fields in place per
- * bar so scripts that destructure `bar` in `compute` keep seeing fresh
- * values without rebinding.
+ * View of the current bar handed to `compute`. Identity stays stable across
+ * the run. The OHLCV + derived price/volume fields are the stream's cached
+ * number-coercible `Series` views (one identity per ring buffer) — they read
+ * the live buffer head, so a script can both use `bar.close` as a scalar
+ * (`bar.close * 2`) and index it (`bar.close[1]`) without the runtime copying
+ * scalars per bar. `time` stays a mutable scalar (the timestamp axis the
+ * emit/draw pipeline consumes as a raw number); `symbol` / `interval` are
+ * constant strings for a given `StreamState`.
  *
- * `symbol` and `interval` are constant for a given `StreamState`
- * instance; the rest are NaN / 0 before the first bar lands.
+ * Before the first bar the buffers are empty, so `bar.close[0]` / `+bar.close`
+ * read `NaN` and `bar.close.length` is `0`.
  *
  * @since 0.1
  * @example
@@ -47,24 +51,26 @@ export type OhlcvBuffers = {
  *     //     capacity: 5,
  *     //     symbol: "AAPL",
  *     // });
- *     // bar.symbol;   // "AAPL"
- *     // bar.interval; // "1D"
- *     // bar.close;    // NaN until the first bar
+ *     // bar.symbol;       // "AAPL"
+ *     // bar.interval;     // "1D"
+ *     // +bar.close;       // NaN until the first bar
+ *     // bar.close.length; // 0 until the first bar
  */
 export type BarView = {
     time: number;
-    open: number;
-    high: number;
-    low: number;
-    close: number;
-    volume: number;
-    hl2: number;
-    hlc3: number;
-    ohlc4: number;
-    hlcc4: number;
+    open: PriceSeries;
+    high: PriceSeries;
+    low: PriceSeries;
+    close: PriceSeries;
+    volume: VolumeSeries;
+    hl2: PriceSeries;
+    hlc3: PriceSeries;
+    ohlc4: PriceSeries;
+    hlcc4: PriceSeries;
     symbol: string;
     interval: string;
     viewport: BarViewport;
+    point(offset: number, price: Price): WorldPoint;
 };
 /**
  * Everything the runtime owns for a single interval stream — the OHLCV
@@ -110,7 +116,7 @@ export type StreamState = {
 };
 /**
  * Construct a fresh `StreamState`. The ring-buffer capacity is the
- * compiler-emitted `manifest.maxLookback + 1` per PLAN.md §6.6
+ * compiler-emitted `manifest.maxLookback + 1`
  * (caller must enforce `capacity >= 1`). All buffers start empty;
  * the `BarView` starts with `NaN` prices, `0` time and volume, and the
  * supplied `symbol` / `interval` constants. `taSlots` is an empty map.

package/dist/streamState.d.ts.map

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