@invinite-org/chartlang-runtime 1.1.1 → 1.2.0

package/dist/seriesView.d.ts

@@ -10,6 +10,14 @@ import type { RingBufferLike } from "./ringBuffer.js";
  * Property reads dispatch as follows:
  * - `series.current` → `buf.at(0)`
  * - `series.length` → `buf.length`
+ * - `series.valueOf` / `series[Symbol.toPrimitive]` → a function returning
+ *   `buf.at(0)`, so a numeric series coerces to its **current** value in any
+ *   value context (`series * 2`, `series > x`, `` `${series}` ``,
+ *   `Math.max(series, …)`). This is what lets `bar.close` be used both as a
+ *   scalar and indexed as a series. Coercion is harmless for non-numeric
+ *   buffers — nothing coerces those. Note `Number.isFinite(series)` is still
+ *   `false` (it does not coerce) and `series === 42` is `false` (object vs
+ *   number); use `series.current` / `+series` there.
  * - `series[n]` (string coerces to a non-negative integer) → `buf.at(n)`
  * - any other key → `undefined`
  *
@@ -30,30 +38,47 @@ import type { RingBufferLike } from "./ringBuffer.js";
  */
 export declare function makeSeriesView<T>(buf: RingBufferLike<T>): Series<T>;
 /**
- * Offset-shifted variant of {@link makeSeriesView}. `offset === 0`
- * returns the same Proxy shape (and is the identity-preserving fast
- * path callers should special-case at the call site). For
- * `offset === k > 0`, `view.current === buf.at(k)` — i.e. the value
- * `k` bars ago, matching `lib/applyOffset`'s
- * `out[i] = values[i − offset]` semantics. For `offset === -k`,
- * `view.current === buf.at(-k)` — an OOR read returning the underlying
- * sentinel (NaN for `Float64RingBuffer`, `undefined` for object
- * `RingBuffer`).
+ * Offset-tagging variant of {@link makeSeriesView}. It returns the
+ * **unshifted** view (delegating to {@link makeSeriesView}) and, for a
+ * non-zero `offset`, records `view → offset` in a module-level
+ * `WeakMap` side-table read by `plot()` via {@link seriesOffsetOf}. The
+ * offset is **presentation-only** — `view.current` is `buf.at(0)`, not a
+ * value `offset` bars ago — so both shift directions are expressible and
+ * alerts / `state.*` see the unshifted value. `offset === 0` records
+ * nothing (byte-identical to a plain {@link makeSeriesView}).
  *
- * The shift is applied on every read — no allocation, no per-bar
- * work. Callers cache the returned Proxy per `(slot, offset)` pair so
- * the view's identity stays stable across bars.
+ * Callers cache the returned view per `(slot, offset)` pair so the
+ * view's identity — and therefore its recorded offset — stays stable
+ * across bars.
  *
  * @since 0.2
+ * @stable
  * @example
- *     // import { Float64RingBuffer, makeShiftedSeriesView }
+ *     // import { Float64RingBuffer, makeShiftedSeriesView, seriesOffsetOf }
  *     //     from "@invinite-org/chartlang-runtime";
  *     // const buf = new Float64RingBuffer(8);
  *     // buf.append(10); buf.append(20); buf.append(30);
- *     // const view = makeShiftedSeriesView<number>(buf, 1);
- *     // view.current; // 20 (one bar ago)
- *     // view[0];      // 20
- *     // view[1];      // 10
+ *     // const view = makeShiftedSeriesView<number>(buf, 5);
+ *     // view.current;          // 30 (unshifted — the offset does NOT lag the read)
+ *     // seriesOffsetOf(view);  // 5 (presentation x-shift carried to the emission)
  */
 export declare function makeShiftedSeriesView<T>(buf: RingBufferLike<T>, offset: number): Series<T>;
+/**
+ * Read the presentation x-shift recorded for `series` by
+ * {@link makeShiftedSeriesView}, or `0` when the series is untagged (a
+ * plain {@link makeSeriesView} view, an `offset === 0` view, or any
+ * non-runtime Series). `plot()` calls this to populate
+ * `PlotEmission.xShift`; a `0` result omits the field so a no-offset
+ * plot stays byte-identical to today.
+ *
+ * @since 0.2
+ * @stable
+ * @example
+ *     // import { Float64RingBuffer, makeShiftedSeriesView, seriesOffsetOf }
+ *     //     from "@invinite-org/chartlang-runtime";
+ *     // const buf = new Float64RingBuffer(8);
+ *     // const shifted = makeShiftedSeriesView<number>(buf, -3);
+ *     // seriesOffsetOf(shifted); // -3
+ */
+export declare function seriesOffsetOf(series: Series<unknown>): number;
 //# sourceMappingURL=seriesView.d.ts.map

package/dist/seriesView.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"seriesView.d.ts","sourceRoot":"","sources":["../src/seriesView.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,8BAA8B,CAAC;AAE3D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAEtD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,GAAG,EAAE,cAAc,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAoBnE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,GAAG,EAAE,cAAc,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,CAAC,CAAC,CAqB1F"}
+{"version":3,"file":"seriesView.d.ts","sourceRoot":"","sources":["../src/seriesView.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,8BAA8B,CAAC;AAE3D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAEtD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,GAAG,EAAE,cAAc,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAuBnE;AAcD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,GAAG,EAAE,cAAc,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,CAAC,CAAC,CAI1F;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,CAAC,OAAO,CAAC,GAAG,MAAM,CAE9D"}

package/dist/seriesView.js

@@ -10,6 +10,14 @@
  * Property reads dispatch as follows:
  * - `series.current` → `buf.at(0)`
  * - `series.length` → `buf.length`
+ * - `series.valueOf` / `series[Symbol.toPrimitive]` → a function returning
+ *   `buf.at(0)`, so a numeric series coerces to its **current** value in any
+ *   value context (`series * 2`, `series > x`, `` `${series}` ``,
+ *   `Math.max(series, …)`). This is what lets `bar.close` be used both as a
+ *   scalar and indexed as a series. Coercion is harmless for non-numeric
+ *   buffers — nothing coerces those. Note `Number.isFinite(series)` is still
+ *   `false` (it does not coerce) and `series === 42` is `false` (object vs
+ *   number); use `series.current` / `+series` there.
  * - `series[n]` (string coerces to a non-negative integer) → `buf.at(n)`
  * - any other key → `undefined`
  *
@@ -35,6 +43,10 @@ export function makeSeriesView(buf) {
                 return buf.at(0);
             if (prop === "length")
                 return buf.length;
+            if (prop === "valueOf")
+                return () => buf.at(0);
+            if (prop === Symbol.toPrimitive)
+                return () => buf.at(0);
             if (typeof prop === "string") {
                 const n = Number(prop);
                 if (Number.isInteger(n) && n >= 0)
@@ -45,6 +57,8 @@ export function makeSeriesView(buf) {
         has(_target, prop) {
             if (prop === "current" || prop === "length")
                 return true;
+            if (prop === "valueOf" || prop === Symbol.toPrimitive)
+                return true;
             if (typeof prop === "string") {
                 const n = Number(prop);
                 return Number.isInteger(n) && n >= 0;
@@ -54,56 +68,65 @@ export function makeSeriesView(buf) {
     });
 }
 /**
- * Offset-shifted variant of {@link makeSeriesView}. `offset === 0`
- * returns the same Proxy shape (and is the identity-preserving fast
- * path callers should special-case at the call site). For
- * `offset === k > 0`, `view.current === buf.at(k)` — i.e. the value
- * `k` bars ago, matching `lib/applyOffset`'s
- * `out[i] = values[i − offset]` semantics. For `offset === -k`,
- * `view.current === buf.at(-k)` — an OOR read returning the underlying
- * sentinel (NaN for `Float64RingBuffer`, `undefined` for object
- * `RingBuffer`).
+ * Module-level side-table recording the **presentation x-shift** declared
+ * for an offset-tagged Series view. `offset` is no longer a value-read
+ * transform (Option A, bidirectional-plot-offset): the series value is
+ * always the unshifted `buf.at(0)`; the recorded offset rides the plot
+ * emission as `PlotEmission.xShift` so the adapter renders the series
+ * shifted (`+n` right / future, `−n` left / past) without changing the
+ * numbers alerts and `state.*` see. Keyed weakly on the view object so a
+ * dropped slot's tag is collected with it.
+ */
+const seriesOffsets = new WeakMap();
+/**
+ * Offset-tagging variant of {@link makeSeriesView}. It returns the
+ * **unshifted** view (delegating to {@link makeSeriesView}) and, for a
+ * non-zero `offset`, records `view → offset` in a module-level
+ * `WeakMap` side-table read by `plot()` via {@link seriesOffsetOf}. The
+ * offset is **presentation-only** — `view.current` is `buf.at(0)`, not a
+ * value `offset` bars ago — so both shift directions are expressible and
+ * alerts / `state.*` see the unshifted value. `offset === 0` records
+ * nothing (byte-identical to a plain {@link makeSeriesView}).
  *
- * The shift is applied on every read — no allocation, no per-bar
- * work. Callers cache the returned Proxy per `(slot, offset)` pair so
- * the view's identity stays stable across bars.
+ * Callers cache the returned view per `(slot, offset)` pair so the
+ * view's identity — and therefore its recorded offset — stays stable
+ * across bars.
  *
  * @since 0.2
+ * @stable
  * @example
- *     // import { Float64RingBuffer, makeShiftedSeriesView }
+ *     // import { Float64RingBuffer, makeShiftedSeriesView, seriesOffsetOf }
  *     //     from "@invinite-org/chartlang-runtime";
  *     // const buf = new Float64RingBuffer(8);
  *     // buf.append(10); buf.append(20); buf.append(30);
- *     // const view = makeShiftedSeriesView<number>(buf, 1);
- *     // view.current; // 20 (one bar ago)
- *     // view[0];      // 20
- *     // view[1];      // 10
+ *     // const view = makeShiftedSeriesView<number>(buf, 5);
+ *     // view.current;          // 30 (unshifted — the offset does NOT lag the read)
+ *     // seriesOffsetOf(view);  // 5 (presentation x-shift carried to the emission)
  */
 export function makeShiftedSeriesView(buf, offset) {
-    if (offset === 0)
-        return makeSeriesView(buf);
-    return new Proxy({}, {
-        get(_target, prop) {
-            if (prop === "current")
-                return buf.at(offset);
-            if (prop === "length")
-                return buf.length;
-            if (typeof prop === "string") {
-                const n = Number(prop);
-                if (Number.isInteger(n) && n >= 0)
-                    return buf.at(n + offset);
-            }
-            return undefined;
-        },
-        has(_target, prop) {
-            if (prop === "current" || prop === "length")
-                return true;
-            if (typeof prop === "string") {
-                const n = Number(prop);
-                return Number.isInteger(n) && n >= 0;
-            }
-            return false;
-        },
-    });
+    const view = makeSeriesView(buf);
+    if (offset !== 0)
+        seriesOffsets.set(view, offset);
+    return view;
+}
+/**
+ * Read the presentation x-shift recorded for `series` by
+ * {@link makeShiftedSeriesView}, or `0` when the series is untagged (a
+ * plain {@link makeSeriesView} view, an `offset === 0` view, or any
+ * non-runtime Series). `plot()` calls this to populate
+ * `PlotEmission.xShift`; a `0` result omits the field so a no-offset
+ * plot stays byte-identical to today.
+ *
+ * @since 0.2
+ * @stable
+ * @example
+ *     // import { Float64RingBuffer, makeShiftedSeriesView, seriesOffsetOf }
+ *     //     from "@invinite-org/chartlang-runtime";
+ *     // const buf = new Float64RingBuffer(8);
+ *     // const shifted = makeShiftedSeriesView<number>(buf, -3);
+ *     // seriesOffsetOf(shifted); // -3
+ */
+export function seriesOffsetOf(series) {
+    return seriesOffsets.get(series) ?? 0;
 }
 //# sourceMappingURL=seriesView.js.map

package/dist/seriesView.js.map

@@ -1 +1 @@
-{"version":3,"file":"seriesView.js","sourceRoot":"","sources":["../src/seriesView.ts"],"names":[],"mappings":"AAAA,+DAA+D;AAC/D,+DAA+D;AAM/D;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,UAAU,cAAc,CAAI,GAAsB;IACpD,OAAO,IAAI,KAAK,CAAC,EAAe,EAAE;QAC9B,GAAG,CAAC,OAAO,EAAE,IAAI;YACb,IAAI,IAAI,KAAK,SAAS;gBAAE,OAAO,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;YACzC,IAAI,IAAI,KAAK,QAAQ;gBAAE,OAAO,GAAG,CAAC,MAAM,CAAC;YACzC,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE,CAAC;gBAC3B,MAAM,CAAC,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC;gBACvB,IAAI,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC;oBAAE,OAAO,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;YACxD,CAAC;YACD,OAAO,SAAS,CAAC;QACrB,CAAC;QACD,GAAG,CAAC,OAAO,EAAE,IAAI;YACb,IAAI,IAAI,KAAK,SAAS,IAAI,IAAI,KAAK,QAAQ;gBAAE,OAAO,IAAI,CAAC;YACzD,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE,CAAC;gBAC3B,MAAM,CAAC,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC;gBACvB,OAAO,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACzC,CAAC;YACD,OAAO,KAAK,CAAC;QACjB,CAAC;KACJ,CAAC,CAAC;AACP,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,UAAU,qBAAqB,CAAI,GAAsB,EAAE,MAAc;IAC3E,IAAI,MAAM,KAAK,CAAC;QAAE,OAAO,cAAc,CAAI,GAAG,CAAC,CAAC;IAChD,OAAO,IAAI,KAAK,CAAC,EAAe,EAAE;QAC9B,GAAG,CAAC,OAAO,EAAE,IAAI;YACb,IAAI,IAAI,KAAK,SAAS;gBAAE,OAAO,GAAG,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC;YAC9C,IAAI,IAAI,KAAK,QAAQ;gBAAE,OAAO,GAAG,CAAC,MAAM,CAAC;YACzC,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE,CAAC;gBAC3B,MAAM,CAAC,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC;gBACvB,IAAI,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC;oBAAE,OAAO,GAAG,CAAC,EAAE,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC;YACjE,CAAC;YACD,OAAO,SAAS,CAAC;QACrB,CAAC;QACD,GAAG,CAAC,OAAO,EAAE,IAAI;YACb,IAAI,IAAI,KAAK,SAAS,IAAI,IAAI,KAAK,QAAQ;gBAAE,OAAO,IAAI,CAAC;YACzD,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE,CAAC;gBAC3B,MAAM,CAAC,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC;gBACvB,OAAO,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACzC,CAAC;YACD,OAAO,KAAK,CAAC;QACjB,CAAC;KACJ,CAAC,CAAC;AACP,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 { Series } from \"@invinite-org/chartlang-core\";\n\nimport type { RingBufferLike } from \"./ringBuffer.js\";\n\n/**\n * Wrap a `RingBufferLike<T>` in the user-facing `Series<T>` Proxy shape\n *. The Proxy is created **once per backing buffer**\n * at stream/slot construction time and re-used across every bar — its\n * identity is stable so script authors can keep `const ema = ta.ema(...)`\n * at the top of `compute` and reference `ema` the same way every bar.\n *\n * Property reads dispatch as follows:\n * - `series.current` → `buf.at(0)`\n * - `series.length` → `buf.length`\n * - `series[n]` (string coerces to a non-negative integer) → `buf.at(n)`\n * - any other key → `undefined`\n *\n * For numeric buffers (`Float64RingBuffer`) out-of-range reads return\n * `NaN`; for object buffers they return `undefined`. The Proxy passes\n * the underlying sentinel through verbatim.\n *\n * @since 0.1\n * @example\n *     // import { Float64RingBuffer, makeSeriesView }\n *     //     from \"@invinite-org/chartlang-runtime\";\n *     // const buf = new Float64RingBuffer(8);\n *     // const view = makeSeriesView<number>(buf);\n *     // buf.append(42);\n *     // view.current; // 42\n *     // view[0];      // 42\n *     // view.length;  // 1\n */\nexport function makeSeriesView<T>(buf: RingBufferLike<T>): Series<T> {\n    return new Proxy({} as Series<T>, {\n        get(_target, prop) {\n            if (prop === \"current\") return buf.at(0);\n            if (prop === \"length\") return buf.length;\n            if (typeof prop === \"string\") {\n                const n = Number(prop);\n                if (Number.isInteger(n) && n >= 0) return buf.at(n);\n            }\n            return undefined;\n        },\n        has(_target, prop) {\n            if (prop === \"current\" || prop === \"length\") return true;\n            if (typeof prop === \"string\") {\n                const n = Number(prop);\n                return Number.isInteger(n) && n >= 0;\n            }\n            return false;\n        },\n    });\n}\n\n/**\n * Offset-shifted variant of {@link makeSeriesView}. `offset === 0`\n * returns the same Proxy shape (and is the identity-preserving fast\n * path callers should special-case at the call site). For\n * `offset === k > 0`, `view.current === buf.at(k)` — i.e. the value\n * `k` bars ago, matching `lib/applyOffset`'s\n * `out[i] = values[i − offset]` semantics. For `offset === -k`,\n * `view.current === buf.at(-k)` — an OOR read returning the underlying\n * sentinel (NaN for `Float64RingBuffer`, `undefined` for object\n * `RingBuffer`).\n *\n * The shift is applied on every read — no allocation, no per-bar\n * work. Callers cache the returned Proxy per `(slot, offset)` pair so\n * the view's identity stays stable across bars.\n *\n * @since 0.2\n * @example\n *     // import { Float64RingBuffer, makeShiftedSeriesView }\n *     //     from \"@invinite-org/chartlang-runtime\";\n *     // const buf = new Float64RingBuffer(8);\n *     // buf.append(10); buf.append(20); buf.append(30);\n *     // const view = makeShiftedSeriesView<number>(buf, 1);\n *     // view.current; // 20 (one bar ago)\n *     // view[0];      // 20\n *     // view[1];      // 10\n */\nexport function makeShiftedSeriesView<T>(buf: RingBufferLike<T>, offset: number): Series<T> {\n    if (offset === 0) return makeSeriesView<T>(buf);\n    return new Proxy({} as Series<T>, {\n        get(_target, prop) {\n            if (prop === \"current\") return buf.at(offset);\n            if (prop === \"length\") return buf.length;\n            if (typeof prop === \"string\") {\n                const n = Number(prop);\n                if (Number.isInteger(n) && n >= 0) return buf.at(n + offset);\n            }\n            return undefined;\n        },\n        has(_target, prop) {\n            if (prop === \"current\" || prop === \"length\") return true;\n            if (typeof prop === \"string\") {\n                const n = Number(prop);\n                return Number.isInteger(n) && n >= 0;\n            }\n            return false;\n        },\n    });\n}\n"]}
+{"version":3,"file":"seriesView.js","sourceRoot":"","sources":["../src/seriesView.ts"],"names":[],"mappings":"AAAA,+DAA+D;AAC/D,+DAA+D;AAM/D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,MAAM,UAAU,cAAc,CAAI,GAAsB;IACpD,OAAO,IAAI,KAAK,CAAC,EAAe,EAAE;QAC9B,GAAG,CAAC,OAAO,EAAE,IAAI;YACb,IAAI,IAAI,KAAK,SAAS;gBAAE,OAAO,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;YACzC,IAAI,IAAI,KAAK,QAAQ;gBAAE,OAAO,GAAG,CAAC,MAAM,CAAC;YACzC,IAAI,IAAI,KAAK,SAAS;gBAAE,OAAO,GAAG,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;YAC/C,IAAI,IAAI,KAAK,MAAM,CAAC,WAAW;gBAAE,OAAO,GAAG,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;YACxD,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE,CAAC;gBAC3B,MAAM,CAAC,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC;gBACvB,IAAI,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC;oBAAE,OAAO,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;YACxD,CAAC;YACD,OAAO,SAAS,CAAC;QACrB,CAAC;QACD,GAAG,CAAC,OAAO,EAAE,IAAI;YACb,IAAI,IAAI,KAAK,SAAS,IAAI,IAAI,KAAK,QAAQ;gBAAE,OAAO,IAAI,CAAC;YACzD,IAAI,IAAI,KAAK,SAAS,IAAI,IAAI,KAAK,MAAM,CAAC,WAAW;gBAAE,OAAO,IAAI,CAAC;YACnE,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE,CAAC;gBAC3B,MAAM,CAAC,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC;gBACvB,OAAO,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACzC,CAAC;YACD,OAAO,KAAK,CAAC;QACjB,CAAC;KACJ,CAAC,CAAC;AACP,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,aAAa,GAAG,IAAI,OAAO,EAA2B,CAAC;AAE7D;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,UAAU,qBAAqB,CAAI,GAAsB,EAAE,MAAc;IAC3E,MAAM,IAAI,GAAG,cAAc,CAAI,GAAG,CAAC,CAAC;IACpC,IAAI,MAAM,KAAK,CAAC;QAAE,aAAa,CAAC,GAAG,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;IAClD,OAAO,IAAI,CAAC;AAChB,CAAC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,cAAc,CAAC,MAAuB;IAClD,OAAO,aAAa,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;AAC1C,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 { Series } from \"@invinite-org/chartlang-core\";\n\nimport type { RingBufferLike } from \"./ringBuffer.js\";\n\n/**\n * Wrap a `RingBufferLike<T>` in the user-facing `Series<T>` Proxy shape\n *. The Proxy is created **once per backing buffer**\n * at stream/slot construction time and re-used across every bar — its\n * identity is stable so script authors can keep `const ema = ta.ema(...)`\n * at the top of `compute` and reference `ema` the same way every bar.\n *\n * Property reads dispatch as follows:\n * - `series.current` → `buf.at(0)`\n * - `series.length` → `buf.length`\n * - `series.valueOf` / `series[Symbol.toPrimitive]` → a function returning\n *   `buf.at(0)`, so a numeric series coerces to its **current** value in any\n *   value context (`series * 2`, `series > x`, `` `${series}` ``,\n *   `Math.max(series, …)`). This is what lets `bar.close` be used both as a\n *   scalar and indexed as a series. Coercion is harmless for non-numeric\n *   buffers — nothing coerces those. Note `Number.isFinite(series)` is still\n *   `false` (it does not coerce) and `series === 42` is `false` (object vs\n *   number); use `series.current` / `+series` there.\n * - `series[n]` (string coerces to a non-negative integer) → `buf.at(n)`\n * - any other key → `undefined`\n *\n * For numeric buffers (`Float64RingBuffer`) out-of-range reads return\n * `NaN`; for object buffers they return `undefined`. The Proxy passes\n * the underlying sentinel through verbatim.\n *\n * @since 0.1\n * @example\n *     // import { Float64RingBuffer, makeSeriesView }\n *     //     from \"@invinite-org/chartlang-runtime\";\n *     // const buf = new Float64RingBuffer(8);\n *     // const view = makeSeriesView<number>(buf);\n *     // buf.append(42);\n *     // view.current; // 42\n *     // view[0];      // 42\n *     // view.length;  // 1\n */\nexport function makeSeriesView<T>(buf: RingBufferLike<T>): Series<T> {\n    return new Proxy({} as Series<T>, {\n        get(_target, prop) {\n            if (prop === \"current\") return buf.at(0);\n            if (prop === \"length\") return buf.length;\n            if (prop === \"valueOf\") return () => buf.at(0);\n            if (prop === Symbol.toPrimitive) return () => buf.at(0);\n            if (typeof prop === \"string\") {\n                const n = Number(prop);\n                if (Number.isInteger(n) && n >= 0) return buf.at(n);\n            }\n            return undefined;\n        },\n        has(_target, prop) {\n            if (prop === \"current\" || prop === \"length\") return true;\n            if (prop === \"valueOf\" || prop === Symbol.toPrimitive) return true;\n            if (typeof prop === \"string\") {\n                const n = Number(prop);\n                return Number.isInteger(n) && n >= 0;\n            }\n            return false;\n        },\n    });\n}\n\n/**\n * Module-level side-table recording the **presentation x-shift** declared\n * for an offset-tagged Series view. `offset` is no longer a value-read\n * transform (Option A, bidirectional-plot-offset): the series value is\n * always the unshifted `buf.at(0)`; the recorded offset rides the plot\n * emission as `PlotEmission.xShift` so the adapter renders the series\n * shifted (`+n` right / future, `−n` left / past) without changing the\n * numbers alerts and `state.*` see. Keyed weakly on the view object so a\n * dropped slot's tag is collected with it.\n */\nconst seriesOffsets = new WeakMap<Series<unknown>, number>();\n\n/**\n * Offset-tagging variant of {@link makeSeriesView}. It returns the\n * **unshifted** view (delegating to {@link makeSeriesView}) and, for a\n * non-zero `offset`, records `view → offset` in a module-level\n * `WeakMap` side-table read by `plot()` via {@link seriesOffsetOf}. The\n * offset is **presentation-only** — `view.current` is `buf.at(0)`, not a\n * value `offset` bars ago — so both shift directions are expressible and\n * alerts / `state.*` see the unshifted value. `offset === 0` records\n * nothing (byte-identical to a plain {@link makeSeriesView}).\n *\n * Callers cache the returned view per `(slot, offset)` pair so the\n * view's identity — and therefore its recorded offset — stays stable\n * across bars.\n *\n * @since 0.2\n * @stable\n * @example\n *     // import { Float64RingBuffer, makeShiftedSeriesView, seriesOffsetOf }\n *     //     from \"@invinite-org/chartlang-runtime\";\n *     // const buf = new Float64RingBuffer(8);\n *     // buf.append(10); buf.append(20); buf.append(30);\n *     // const view = makeShiftedSeriesView<number>(buf, 5);\n *     // view.current;          // 30 (unshifted — the offset does NOT lag the read)\n *     // seriesOffsetOf(view);  // 5 (presentation x-shift carried to the emission)\n */\nexport function makeShiftedSeriesView<T>(buf: RingBufferLike<T>, offset: number): Series<T> {\n    const view = makeSeriesView<T>(buf);\n    if (offset !== 0) seriesOffsets.set(view, offset);\n    return view;\n}\n\n/**\n * Read the presentation x-shift recorded for `series` by\n * {@link makeShiftedSeriesView}, or `0` when the series is untagged (a\n * plain {@link makeSeriesView} view, an `offset === 0` view, or any\n * non-runtime Series). `plot()` calls this to populate\n * `PlotEmission.xShift`; a `0` result omits the field so a no-offset\n * plot stays byte-identical to today.\n *\n * @since 0.2\n * @stable\n * @example\n *     // import { Float64RingBuffer, makeShiftedSeriesView, seriesOffsetOf }\n *     //     from \"@invinite-org/chartlang-runtime\";\n *     // const buf = new Float64RingBuffer(8);\n *     // const shifted = makeShiftedSeriesView<number>(buf, -3);\n *     // seriesOffsetOf(shifted); // -3\n */\nexport function seriesOffsetOf(series: Series<unknown>): number {\n    return seriesOffsets.get(series) ?? 0;\n}\n"]}

package/dist/state/index.d.ts

@@ -1,5 +1,6 @@
-export { commitStateSlots, flushStateSlots, restoreStateSlots, resetTentativeStateSlots, serialiseStateSlots, } from "./lifecycle.js";
+export { advanceSeriesSlots, commitSeriesSlots, commitStateSlots, flushStateSlots, resetSeriesHeads, restoreStateSlots, resetTentativeStateSlots, serialiseStateSlots, } from "./lifecycle.js";
 export type { StateSlotSnapshot } from "./lifecycle.js";
+export { isSeriesSlotSnapshotKey, restoreSeriesSlots, serialiseSeriesSlots, } from "./seriesPersistence.js";
 export { buildStateNamespace } from "./stateNamespace.js";
 export type { StateSlotSerialisers } from "./stateSlot.js";
 export { asMutableSlot, StateSlot } from "./stateSlot.js";

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

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

package/dist/state/index.js

@@ -1,6 +1,7 @@
 // Copyright (c) 2026 Invinite. Licensed under the MIT License.
 // See the LICENSE file in the repo root for full license text.
-export { commitStateSlots, flushStateSlots, restoreStateSlots, resetTentativeStateSlots, serialiseStateSlots, } from "./lifecycle.js";
+export { advanceSeriesSlots, commitSeriesSlots, commitStateSlots, flushStateSlots, resetSeriesHeads, restoreStateSlots, resetTentativeStateSlots, serialiseStateSlots, } from "./lifecycle.js";
+export { isSeriesSlotSnapshotKey, restoreSeriesSlots, serialiseSeriesSlots, } from "./seriesPersistence.js";
 export { buildStateNamespace } from "./stateNamespace.js";
 export { asMutableSlot, StateSlot } from "./stateSlot.js";
 //# sourceMappingURL=index.js.map

package/dist/state/index.js.map

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

package/dist/state/lifecycle.d.ts

@@ -72,4 +72,44 @@ export declare function serialiseStateSlots(ctx: RuntimeContext): Readonly<Recor
  *     void restored;
  */
 export declare function restoreStateSlots(ctx: RuntimeContext, slots: Readonly<Record<string, unknown>>): void;
+/**
+ * Advance every `state.series` ring once for a new close bar — append a
+ * fresh `NaN` head so the prior committed head slides to index 1. Runs
+ * BEFORE compute on close, so a slot first allocated mid-compute (already
+ * holding its seeded head) is not present here and is not double-advanced.
+ *
+ * @since 0.9
+ * @stable
+ * @example
+ *     // advanceSeriesSlots(ctx);
+ *     const advanced = true;
+ *     void advanced;
+ */
+export declare function advanceSeriesSlots(ctx: RuntimeContext): void;
+/**
+ * Commit every `state.series` live head as its bar-close value after
+ * close compute, so the next advance retains it and a tick can reset to
+ * it.
+ *
+ * @since 0.9
+ * @stable
+ * @example
+ *     // commitSeriesSlots(ctx);
+ *     const committed = true;
+ *     void committed;
+ */
+export declare function commitSeriesSlots(ctx: RuntimeContext): void;
+/**
+ * Reset every `state.series` live head to its last committed value before
+ * tick compute, so a re-write refines from the committed baseline and a
+ * tick without a write reads the committed head. Does NOT advance length.
+ *
+ * @since 0.9
+ * @stable
+ * @example
+ *     // resetSeriesHeads(ctx);
+ *     const reset = true;
+ *     void reset;
+ */
+export declare function resetSeriesHeads(ctx: RuntimeContext): void;
 //# sourceMappingURL=lifecycle.d.ts.map

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

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

package/dist/state/lifecycle.js

@@ -1,5 +1,6 @@
 // Copyright (c) 2026 Invinite. Licensed under the MIT License.
 // See the LICENSE file in the repo root for full license text.
+import { advanceSeriesSlot, commitSeriesSlot, resetSeriesSlotHead } from "./seriesSlot.js";
 /**
  * Reset all non-`state.tick.*` tentative values before tick compute.
  *
@@ -84,4 +85,56 @@ export function restoreStateSlots(ctx, slots) {
         ctx.stateStore.set(key, value);
     }
 }
+/**
+ * Advance every `state.series` ring once for a new close bar — append a
+ * fresh `NaN` head so the prior committed head slides to index 1. Runs
+ * BEFORE compute on close, so a slot first allocated mid-compute (already
+ * holding its seeded head) is not present here and is not double-advanced.
+ *
+ * @since 0.9
+ * @stable
+ * @example
+ *     // advanceSeriesSlots(ctx);
+ *     const advanced = true;
+ *     void advanced;
+ */
+export function advanceSeriesSlots(ctx) {
+    for (const slot of ctx.seriesSlots.values()) {
+        advanceSeriesSlot(slot);
+    }
+}
+/**
+ * Commit every `state.series` live head as its bar-close value after
+ * close compute, so the next advance retains it and a tick can reset to
+ * it.
+ *
+ * @since 0.9
+ * @stable
+ * @example
+ *     // commitSeriesSlots(ctx);
+ *     const committed = true;
+ *     void committed;
+ */
+export function commitSeriesSlots(ctx) {
+    for (const slot of ctx.seriesSlots.values()) {
+        commitSeriesSlot(slot);
+    }
+}
+/**
+ * Reset every `state.series` live head to its last committed value before
+ * tick compute, so a re-write refines from the committed baseline and a
+ * tick without a write reads the committed head. Does NOT advance length.
+ *
+ * @since 0.9
+ * @stable
+ * @example
+ *     // resetSeriesHeads(ctx);
+ *     const reset = true;
+ *     void reset;
+ */
+export function resetSeriesHeads(ctx) {
+    for (const slot of ctx.seriesSlots.values()) {
+        resetSeriesSlotHead(slot);
+    }
+}
 //# sourceMappingURL=lifecycle.js.map

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":"AAAA,+DAA+D;AAC/D,+DAA+D;AAG/D,OAAO,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAqB3F;;;;;;;;;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;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,kBAAkB,CAAC,GAAmB;IAClD,KAAK,MAAM,IAAI,IAAI,GAAG,CAAC,WAAW,CAAC,MAAM,EAAE,EAAE,CAAC;QAC1C,iBAAiB,CAAC,IAAI,CAAC,CAAC;IAC5B,CAAC;AACL,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,iBAAiB,CAAC,GAAmB;IACjD,KAAK,MAAM,IAAI,IAAI,GAAG,CAAC,WAAW,CAAC,MAAM,EAAE,EAAE,CAAC;QAC1C,gBAAgB,CAAC,IAAI,CAAC,CAAC;IAC3B,CAAC;AACL,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,gBAAgB,CAAC,GAAmB;IAChD,KAAK,MAAM,IAAI,IAAI,GAAG,CAAC,WAAW,CAAC,MAAM,EAAE,EAAE,CAAC;QAC1C,mBAAmB,CAAC,IAAI,CAAC,CAAC;IAC9B,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\";\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"]}

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"]}