@invinite-org/chartlang-runtime 1.1.1 → 1.3.0

package/dist/state/lifecycle.js.map

@@ -1 +1 @@
-{"version":3,"file":"lifecycle.js","sourceRoot":"","sources":["../../src/state/lifecycle.ts"],"names":[],"mappings":"AAAA,+DAA+D;AAC/D,+DAA+D;AAuB/D;;;;;;;;;GASG;AACH,MAAM,UAAU,wBAAwB,CAAC,GAAmB;IACxD,KAAK,MAAM,IAAI,IAAI,GAAG,CAAC,UAAU,CAAC,MAAM,EAAE,EAAE,CAAC;QACzC,IAAI,CAAC,SAAS,EAAE,CAAC;IACrB,CAAC;AACL,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,gBAAgB,CAAC,GAAmB;IAChD,KAAK,MAAM,IAAI,IAAI,GAAG,CAAC,UAAU,CAAC,MAAM,EAAE,EAAE,CAAC;QACzC,IAAI,CAAC,UAAU,EAAE,CAAC;IACtB,CAAC;AACL,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,eAAe,CAAC,GAAmB;IAC/C,KAAK,MAAM,CAAC,GAAG,EAAE,IAAI,CAAC,IAAI,GAAG,CAAC,UAAU,CAAC,OAAO,EAAE,EAAE,CAAC;QACjD,GAAG,CAAC,UAAU,CAAC,GAAG,CAA6B,GAAG,EAAE;YAChD,SAAS,EAAE,IAAI,CAAC,SAAS;YACzB,SAAS,EAAE,IAAI,CAAC,SAAS;SAC5B,CAAC,CAAC;IACP,CAAC;AACL,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,mBAAmB,CAAC,GAAmB;IACnD,MAAM,GAAG,GAA4B,EAAE,CAAC;IACxC,KAAK,MAAM,CAAC,GAAG,EAAE,IAAI,CAAC,IAAI,GAAG,CAAC,UAAU,CAAC,OAAO,EAAE,EAAE,CAAC;QACjD,GAAG,CAAC,GAAG,CAAC,GAAG;YACP,SAAS,EAAE,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,SAAS,CAAC;YACzC,SAAS,EAAE,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,SAAS,CAAC;SAC5C,CAAC;IACN,CAAC;IACD,OAAO,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;AAC9B,CAAC;AAED;;;;;;;;;GASG;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,GAAG,CAAC,UAAU,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;IACnC,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 { RuntimeContext } from \"../runtimeContext.js\";\n\n/**\n * Persisted representation for a runtime state slot. Keys use\n * `${slotId}:state`, matching the compiler-injected slot id plus the\n * state namespace suffix.\n *\n * @since 0.4\n * @stable\n * @example\n *     const snapshot: StateSlotSnapshot<number> = {\n *         committed: 1,\n *         tentative: 2,\n *     };\n *     void snapshot;\n */\nexport type StateSlotSnapshot<T> = {\n    readonly committed: T;\n    readonly tentative: T;\n};\n\n/**\n * Reset all non-`state.tick.*` tentative values before tick compute.\n *\n * @since 0.4\n * @stable\n * @example\n *     // resetTentativeStateSlots(ctx);\n *     const called = true;\n *     void called;\n */\nexport function resetTentativeStateSlots(ctx: RuntimeContext): void {\n    for (const slot of ctx.stateSlots.values()) {\n        slot.onBarTick();\n    }\n}\n\n/**\n * Commit all non-`state.tick.*` tentative values after close compute.\n *\n * @since 0.4\n * @stable\n * @example\n *     // commitStateSlots(ctx);\n *     const called = true;\n *     void called;\n */\nexport function commitStateSlots(ctx: RuntimeContext): void {\n    for (const slot of ctx.stateSlots.values()) {\n        slot.onBarClose();\n    }\n}\n\n/**\n * Flush runtime state slots into the backing {@link StateStore}.\n *\n * @since 0.4\n * @stable\n * @example\n *     // flushStateSlots(ctx);\n *     const called = true;\n *     void called;\n */\nexport function flushStateSlots(ctx: RuntimeContext): void {\n    for (const [key, slot] of ctx.stateSlots.entries()) {\n        ctx.stateStore.set<StateSlotSnapshot<unknown>>(key, {\n            committed: slot.committed,\n            tentative: slot.tentative,\n        });\n    }\n}\n\n/**\n * Serialise runtime state slots into a snapshot payload.\n *\n * @since 0.5\n * @stable\n * @example\n *     // const slots = serialiseStateSlots(ctx);\n *     const slots = {};\n *     void slots;\n */\nexport function serialiseStateSlots(ctx: RuntimeContext): Readonly<Record<string, unknown>> {\n    const out: Record<string, unknown> = {};\n    for (const [key, slot] of ctx.stateSlots.entries()) {\n        out[key] = {\n            committed: slot.serialise(slot.committed),\n            tentative: slot.serialise(slot.tentative),\n        };\n    }\n    return Object.freeze(out);\n}\n\n/**\n * Seed restored state-slot payloads into the backing slot store.\n *\n * @since 0.5\n * @stable\n * @example\n *     // restoreStateSlots(ctx, snapshot.slots);\n *     const restored = true;\n *     void restored;\n */\nexport function restoreStateSlots(\n    ctx: RuntimeContext,\n    slots: Readonly<Record<string, unknown>>,\n): void {\n    ctx.stateSlots.clear();\n    for (const [key, value] of Object.entries(slots)) {\n        ctx.stateStore.set(key, value);\n    }\n}\n"]}
+{"version":3,"file":"lifecycle.js","sourceRoot":"","sources":["../../src/state/lifecycle.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 { RuntimeContext } from \"../runtimeContext.js\";\nimport { advanceSeriesSlot, commitSeriesSlot, resetSeriesSlotHead } from \"./seriesSlot.js\";\n\n/**\n * Persisted representation for a runtime state slot. Keys use\n * `${slotId}:state`, matching the compiler-injected slot id plus the\n * state namespace suffix.\n *\n * @since 0.4\n * @stable\n * @example\n *     const snapshot: StateSlotSnapshot<number> = {\n *         committed: 1,\n *         tentative: 2,\n *     };\n *     void snapshot;\n */\nexport type StateSlotSnapshot<T> = {\n    readonly committed: T;\n    readonly tentative: T;\n};\n\n/**\n * Reset all non-`state.tick.*` tentative values before tick compute.\n *\n * @since 0.4\n * @stable\n * @example\n *     // resetTentativeStateSlots(ctx);\n *     const called = true;\n *     void called;\n */\nexport function resetTentativeStateSlots(ctx: RuntimeContext): void {\n    for (const slot of ctx.stateSlots.values()) {\n        slot.onBarTick();\n    }\n}\n\n/**\n * Commit all non-`state.tick.*` tentative values after close compute.\n *\n * @since 0.4\n * @stable\n * @example\n *     // commitStateSlots(ctx);\n *     const called = true;\n *     void called;\n */\nexport function commitStateSlots(ctx: RuntimeContext): void {\n    for (const slot of ctx.stateSlots.values()) {\n        slot.onBarClose();\n    }\n}\n\n/**\n * Flush runtime state slots into the backing {@link StateStore}.\n *\n * @since 0.4\n * @stable\n * @example\n *     // flushStateSlots(ctx);\n *     const called = true;\n *     void called;\n */\nexport function flushStateSlots(ctx: RuntimeContext): void {\n    for (const [key, slot] of ctx.stateSlots.entries()) {\n        ctx.stateStore.set<StateSlotSnapshot<unknown>>(key, {\n            committed: slot.committed,\n            tentative: slot.tentative,\n        });\n    }\n}\n\n/**\n * Serialise runtime state slots into a snapshot payload.\n *\n * @since 0.5\n * @stable\n * @example\n *     // const slots = serialiseStateSlots(ctx);\n *     const slots = {};\n *     void slots;\n */\nexport function serialiseStateSlots(ctx: RuntimeContext): Readonly<Record<string, unknown>> {\n    const out: Record<string, unknown> = {};\n    for (const [key, slot] of ctx.stateSlots.entries()) {\n        out[key] = {\n            committed: slot.serialise(slot.committed),\n            tentative: slot.serialise(slot.tentative),\n        };\n    }\n    return Object.freeze(out);\n}\n\n/**\n * Seed restored state-slot payloads into the backing slot store.\n *\n * @since 0.5\n * @stable\n * @example\n *     // restoreStateSlots(ctx, snapshot.slots);\n *     const restored = true;\n *     void restored;\n */\nexport function restoreStateSlots(\n    ctx: RuntimeContext,\n    slots: Readonly<Record<string, unknown>>,\n): void {\n    ctx.stateSlots.clear();\n    for (const [key, value] of Object.entries(slots)) {\n        ctx.stateStore.set(key, value);\n    }\n}\n\n/**\n * Advance every `state.series` ring once for a new close bar — append a\n * fresh `NaN` head so the prior committed head slides to index 1. Runs\n * BEFORE compute on close, so a slot first allocated mid-compute (already\n * holding its seeded head) is not present here and is not double-advanced.\n *\n * @since 0.9\n * @stable\n * @example\n *     // advanceSeriesSlots(ctx);\n *     const advanced = true;\n *     void advanced;\n */\nexport function advanceSeriesSlots(ctx: RuntimeContext): void {\n    for (const slot of ctx.seriesSlots.values()) {\n        advanceSeriesSlot(slot);\n    }\n}\n\n/**\n * Commit every `state.series` live head as its bar-close value after\n * close compute, so the next advance retains it and a tick can reset to\n * it.\n *\n * @since 0.9\n * @stable\n * @example\n *     // commitSeriesSlots(ctx);\n *     const committed = true;\n *     void committed;\n */\nexport function commitSeriesSlots(ctx: RuntimeContext): void {\n    for (const slot of ctx.seriesSlots.values()) {\n        commitSeriesSlot(slot);\n    }\n}\n\n/**\n * Reset every `state.series` live head to its last committed value before\n * tick compute, so a re-write refines from the committed baseline and a\n * tick without a write reads the committed head. Does NOT advance length.\n *\n * @since 0.9\n * @stable\n * @example\n *     // resetSeriesHeads(ctx);\n *     const reset = true;\n *     void reset;\n */\nexport function resetSeriesHeads(ctx: RuntimeContext): void {\n    for (const slot of ctx.seriesSlots.values()) {\n        resetSeriesSlotHead(slot);\n    }\n}\n\n/**\n * Roll every `state.array` slot's tentative ring back to its committed ring\n * before tick compute, so a head-replacing tick discards in-progress pushes\n * (and a tick without a push reads the committed collection). Runs once per\n * tick, before compute, next to {@link resetSeriesHeads}. There is no advance —\n * the array changes only when the author pushes.\n *\n * @since 1.3\n * @stable\n * @example\n *     // resetTentativeArraySlots(ctx);\n *     const reset = true;\n *     void reset;\n */\nexport function resetTentativeArraySlots(ctx: RuntimeContext): void {\n    for (const slot of ctx.arraySlots.values()) {\n        slot.onBarTick();\n    }\n}\n\n/**\n * Commit every `state.array` slot's tentative ring into its committed ring\n * after close compute, so the next tick can roll back to it. Runs once per\n * close, after compute, next to {@link commitSeriesSlots}.\n *\n * @since 1.3\n * @stable\n * @example\n *     // commitArraySlots(ctx);\n *     const committed = true;\n *     void committed;\n */\nexport function commitArraySlots(ctx: RuntimeContext): void {\n    for (const slot of ctx.arraySlots.values()) {\n        slot.onBarClose();\n    }\n}\n"]}

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,EAIR,cAAc,EACjB,MAAM,8BAA8B,CAAC;AAiHtC;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,IAAI,cAAc,CA4BpD"}

package/dist/state/stateNamespace.js

@@ -1,6 +1,9 @@
 // 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 { createArrayStateSlot } from "./arrayStateSlot.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 +17,26 @@ 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`;
+/**
+ * Compose the runtime's `state.array` slot key — the `:array` suffix (vs
+ * `:state` / `:series`) lets the snapshot restore router tell an array slot
+ * from a scalar or series slot. The `slotIdPrefix` isolation rule is identical
+ * to {@link stateKey}.
+ *
+ * @since 1.3
+ * @internal
+ */
+const arrayKey = (ctx, slotId) => `${ctx.slotIdPrefix ?? ""}${slotId}:array`;
 function getCtx(name) {
     const ctx = ACTIVE_RUNTIME_CONTEXT.current;
     if (ctx === null) {
@@ -36,6 +59,36 @@ 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;
+}
+function getOrAllocateArray(slotId, capacity) {
+    const ctx = getCtx("state.array");
+    const key = arrayKey(ctx, slotId);
+    const existing = ctx.arraySlots.get(key);
+    if (existing !== undefined) {
+        return existing.handle;
+    }
+    // No store-consult / seed: an empty collection starts empty, and warm
+    // restart rehydrates `arraySlots` up front via `restoreArraySlots` (mirrors
+    // the `state.series` allocator), so this path only runs for a first-seen
+    // callsite.
+    const slot = createArrayStateSlot(capacity);
+    ctx.arraySlots.set(key, slot);
+    return slot.handle;
+}
 /**
  * Build the runtime `state` namespace installed on `ComputeContext`.
  * Each function accepts the compiler-injected `slotId` as its first
@@ -53,6 +106,8 @@ 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),
+        array: (slotId, capacity) => getOrAllocateArray(slotId, capacity),
         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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","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, StateNamespace } from \"@invinite-org/chartlang-core\";\n\nimport { ACTIVE_RUNTIME_CONTEXT, type RuntimeContext } from \"../runtimeContext.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\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\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        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"]}
+{"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 {\n    MutableArraySlot,\n    MutableSlot,\n    NumberSeriesSlot,\n    StateNamespace,\n} from \"@invinite-org/chartlang-core\";\n\nimport { Float64RingBuffer } from \"../ringBuffer.js\";\nimport { ACTIVE_RUNTIME_CONTEXT, type RuntimeContext } from \"../runtimeContext.js\";\nimport { createArrayStateSlot } from \"./arrayStateSlot.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\n/**\n * Compose the runtime's `state.array` slot key — the `:array` suffix (vs\n * `:state` / `:series`) lets the snapshot restore router tell an array slot\n * from a scalar or series slot. The `slotIdPrefix` isolation rule is identical\n * to {@link stateKey}.\n *\n * @since 1.3\n * @internal\n */\nconst arrayKey = (ctx: RuntimeContext, slotId: string): string =>\n    `${ctx.slotIdPrefix ?? \"\"}${slotId}:array`;\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\nfunction getOrAllocateArray(slotId: string, capacity: number): MutableArraySlot<number> {\n    const ctx = getCtx(\"state.array\");\n    const key = arrayKey(ctx, slotId);\n    const existing = ctx.arraySlots.get(key);\n    if (existing !== undefined) {\n        return existing.handle;\n    }\n    // No store-consult / seed: an empty collection starts empty, and warm\n    // restart rehydrates `arraySlots` up front via `restoreArraySlots` (mirrors\n    // the `state.series` allocator), so this path only runs for a first-seen\n    // callsite.\n    const slot = createArrayStateSlot(capacity);\n    ctx.arraySlots.set(key, slot);\n    return slot.handle;\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        array: (slotId: string, capacity: number): MutableArraySlot<number> =>\n            getOrAllocateArray(slotId, capacity),\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/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