pond-ts 0.20.0 → 0.22.0

package/dist/batch/operators/diff-rate.js

@@ -0,0 +1,99 @@
+import { float64ColumnFromArray, withColumnReplaced, withRowRange, } from '../../columnar/index.js';
+/**
+ * **Step 4 — column-native `diff` / `rate` / `pctChange` (extracted
+ * operator).** Successive differences per target column, computed
+ * straight off the columnar store: read each target's cells
+ * (storage-agnostic `read(i)`), fold the per-row difference, replace
+ * the column — no `series.events` materialization, no per-row
+ * `Event`. Non-target columns + the key axis pass through untouched
+ * (`withColumnReplaced` references the unchanged columns + keys
+ * zero-copy).
+ *
+ * Matches the row path's semantics exactly:
+ * - Row 0 has no predecessor, so each target is `undefined` there.
+ * - Row `i ≥ 1`: with both `prev` and `curr` defined numbers,
+ *   `delta = curr - prev`; `diff` emits `delta`, `rate` emits
+ *   `delta / dt` (`dt` = `(begin[i] − begin[i−1]) / 1000` seconds,
+ *   `undefined` when `dt === 0`), `pctChange` emits `delta / prev`
+ *   (`undefined` when `prev === 0`). If either side is missing /
+ *   non-numeric, the output is `undefined`. A stored `NaN` is a
+ *   defined number (`typeof raw === 'number'`), so it participates.
+ *
+ * **`drop`.** `drop: false` (default) keeps the predecessor-less
+ * first row (its targets `undefined`, its other columns + key
+ * intact). `drop: true` removes that row entirely — every column
+ * **and** the key slice to `[1, n)` via `withRowRange`, the row-range
+ * substrate built for exactly this. The full-length result is built
+ * first (the `drop: false` shape); `drop: true` just appends the
+ * trailing one-row slice, so the two paths share all the fold logic.
+ *
+ * Returns the reshaped store + the output schema (targets widened to
+ * optional `number`). The result-schema cast is the single trust
+ * boundary; the `TimeSeries` method wraps the store via
+ * `#fromTrustedStore`.
+ *
+ * A non-numeric target name is unreachable through the typed surface
+ * (`NumericColumnNameForSchema<S>`); defeating that constraint makes
+ * the all-`undefined` replacement column `kind: 'number'`, so
+ * `withColumnReplaced`'s kind guard throws a `RangeError` naming the
+ * column — fail-fast over the old path's silent all-`undefined`.
+ */
+export function diffRateOp(store, schema, mode, cols, drop) {
+    if (cols.length === 0) {
+        throw new Error(`${mode}() requires at least one column name`);
+    }
+    const targetSet = new Set(cols);
+    const outSchema = Object.freeze(schema.map((col, i) => i === 0 || !targetSet.has(col.name)
+        ? col
+        : { ...col, kind: 'number', required: false }));
+    const n = store.length;
+    // For `rate`, the elapsed-seconds divisor depends only on the row
+    // index, not the target — precompute it once rather than per
+    // (target, row). dt[0] is unused (row 0 has no predecessor).
+    let dt;
+    if (mode === 'rate' && n > 0) {
+        dt = new Float64Array(n);
+        for (let i = 1; i < n; i += 1) {
+            dt[i] = (store.beginAt(i) - store.beginAt(i - 1)) / 1000;
+        }
+    }
+    let result = store;
+    for (const name of cols) {
+        const col = store.columns.get(name);
+        const out = new Array(n);
+        if (n > 0)
+            out[0] = undefined; // first row: no predecessor
+        for (let i = 1; i < n; i += 1) {
+            const prev = col.read(i - 1);
+            const curr = col.read(i);
+            if (typeof curr === 'number' && typeof prev === 'number') {
+                const delta = curr - prev;
+                if (mode === 'pctChange') {
+                    out[i] = prev !== 0 ? delta / prev : undefined;
+                }
+                else if (mode === 'rate') {
+                    const d = dt[i];
+                    out[i] = d !== 0 ? delta / d : undefined;
+                }
+                else {
+                    out[i] = delta;
+                }
+            }
+            else {
+                out[i] = undefined;
+            }
+        }
+        result = withColumnReplaced(result, name, float64ColumnFromArray(out));
+    }
+    // drop:true removes the predecessor-less first row from every column
+    // + the key. (n === 0 has no row to drop; the guard keeps the empty
+    // store untouched rather than slicing [1, 0).)
+    if (drop && n > 0) {
+        result = withRowRange(result, 1, n);
+    }
+    return {
+        store: result,
+        schema: outSchema,
+    };
+}
+//# sourceMappingURL=diff-rate.js.map

package/dist/batch/operators/diff-rate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff-rate.js","sourceRoot":"","sources":["../../../src/batch/operators/diff-rate.ts"],"names":[],"mappings":"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"}

package/dist/batch/operators/fill.d.ts

@@ -0,0 +1,66 @@
+import { type ColumnarStore } from '../../columnar/index.js';
+import type { FillStrategy } from '../../schema/reshape.js';
+import type { ScalarValue, SeriesSchema } from '../../schema/index.js';
+/**
+ * A fill strategy resolved to its operator-ready form: a built-in
+ * strategy keyword, or a literal value to place in every gap cell.
+ * (The method resolves the public `FillStrategy | FillMapping` input
+ * into a per-column map of these before delegating.)
+ */
+export type ResolvedFillSpec = {
+    mode: FillStrategy;
+} | {
+    mode: 'literal';
+    value: ScalarValue;
+};
+/**
+ * **Step 4 — column-native `fill` (extracted operator).** Gap-fills
+ * value columns straight off the columnar store: read each target's
+ * cells (storage-agnostic `read(i)`), walk contiguous `undefined`
+ * runs, apply the per-column strategy, and replace only the columns
+ * that actually changed — no `series.events` materialization, no
+ * per-row `Event`. Untouched columns + the key axis pass through by
+ * reference.
+ *
+ * Matches the row path's semantics exactly:
+ * - **Gap walk.** Each maximal run of `undefined` cells is one gap.
+ *   `linear` needs both neighbors, `hold` needs a left neighbor,
+ *   `bfill` needs a right neighbor; `zero` / `literal` need none. A
+ *   gap missing its required neighbor is left unfilled.
+ * - **`limit` / `maxGap`** are all-or-nothing per gap: a gap longer
+ *   than `limit` cells, or whose temporal span exceeds `maxGap` ms,
+ *   is skipped entirely. The span uses both neighbors for interior
+ *   gaps, the available neighbor + the gap edge for edge gaps.
+ * - **Strategies.** `hold` carries the left value, `bfill` the right;
+ *   `zero` writes 0; `literal` writes the supplied value; `linear`
+ *   interpolates by time (`tspan === 0` ⇒ the left value). `zero` and
+ *   `linear` are **numeric-only** — on a non-numeric column they
+ *   silently skip (the column is left untouched, not rebuilt).
+ *
+ * Unlike the numeric folds (`cumulative`, `diff`), `fill` preserves
+ * each column's **kind** — `hold` / `bfill` / `literal` apply to any
+ * kind — so a changed column is rebuilt with the kind-appropriate
+ * builder (`buildFilledColumn`). A `literal` whose runtime type
+ * doesn't match the column kind throws a `RangeError` naming the
+ * column when it would be placed (gap-dependent).
+ *
+ * **This throw is a deliberate behavior change, not parity.** The old
+ * events path did NOT throw on a kind-mismatched literal: it stored
+ * the literal in the event cache *and* coerced it into the numeric
+ * buffer, yielding an internally-inconsistent series (`.get()`
+ * returned the string, `.column().sum()` returned `NaN`). Column-
+ * native has a single representation, so that dual-view inconsistency
+ * is unreproducible — failing fast on the nonsensical input (a kind-
+ * mismatched literal is only writable because `FillMapping` values
+ * are the broad `FillStrategy | ScalarValue`) is the principled
+ * replacement.
+ *
+ * The schema is unchanged (fill never widens or drops); the cast is
+ * the single trust boundary, and the `TimeSeries.fill` method wraps
+ * the store via `#fromTrustedStore`.
+ */
+export declare function fillOp<S extends SeriesSchema>(store: ColumnarStore<S>, schema: S, specs: ReadonlyMap<string, ResolvedFillSpec>, limit: number | undefined, maxGapMs: number | undefined): {
+    store: ColumnarStore<S>;
+    schema: S;
+};
+//# sourceMappingURL=fill.d.ts.map

package/dist/batch/operators/fill.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fill.d.ts","sourceRoot":"","sources":["../../../src/batch/operators/fill.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,aAAa,EAOnB,MAAM,yBAAyB,CAAC;AACjC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAEvE;;;;;GAKG;AACH,MAAM,MAAM,gBAAgB,GACxB;IAAE,IAAI,EAAE,YAAY,CAAA;CAAE,GACtB;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,KAAK,EAAE,WAAW,CAAA;CAAE,CAAC;AAmC5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,wBAAgB,MAAM,CAAC,CAAC,SAAS,YAAY,EAC3C,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,MAAM,EAAE,CAAC,EACT,KAAK,EAAE,WAAW,CAAC,MAAM,EAAE,gBAAgB,CAAC,EAC5C,KAAK,EAAE,MAAM,GAAG,SAAS,EACzB,QAAQ,EAAE,MAAM,GAAG,SAAS,GAC3B;IAAE,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,CAAC;IAAC,MAAM,EAAE,CAAC,CAAA;CAAE,CA6IxC"}

package/dist/batch/operators/fill.js

@@ -0,0 +1,219 @@
+import { arrayColumnFromArray, booleanColumnFromArray, float64ColumnFromArray, stringColumnFromArray, withColumnReplaced, } from '../../columnar/index.js';
+/** Does `value`'s runtime type match the column's declared kind? */
+function valueMatchesKind(value, kind) {
+    switch (kind) {
+        case 'number':
+            return typeof value === 'number';
+        case 'string':
+            return typeof value === 'string';
+        case 'boolean':
+            return typeof value === 'boolean';
+        case 'array':
+            return Array.isArray(value);
+        default:
+            return false;
+    }
+}
+/** Rebuilds a filled value array into a column of the given kind. */
+function buildFilledColumn(kind, values) {
+    switch (kind) {
+        case 'number':
+            return float64ColumnFromArray(values);
+        case 'string':
+            return stringColumnFromArray(values);
+        case 'boolean':
+            return booleanColumnFromArray(values);
+        case 'array':
+            // ArrayValue cells; the cast is the kind dispatch's trust point.
+            return arrayColumnFromArray(values);
+        default:
+            throw new TypeError(`fill: unsupported column kind '${kind}'`);
+    }
+}
+/**
+ * **Step 4 — column-native `fill` (extracted operator).** Gap-fills
+ * value columns straight off the columnar store: read each target's
+ * cells (storage-agnostic `read(i)`), walk contiguous `undefined`
+ * runs, apply the per-column strategy, and replace only the columns
+ * that actually changed — no `series.events` materialization, no
+ * per-row `Event`. Untouched columns + the key axis pass through by
+ * reference.
+ *
+ * Matches the row path's semantics exactly:
+ * - **Gap walk.** Each maximal run of `undefined` cells is one gap.
+ *   `linear` needs both neighbors, `hold` needs a left neighbor,
+ *   `bfill` needs a right neighbor; `zero` / `literal` need none. A
+ *   gap missing its required neighbor is left unfilled.
+ * - **`limit` / `maxGap`** are all-or-nothing per gap: a gap longer
+ *   than `limit` cells, or whose temporal span exceeds `maxGap` ms,
+ *   is skipped entirely. The span uses both neighbors for interior
+ *   gaps, the available neighbor + the gap edge for edge gaps.
+ * - **Strategies.** `hold` carries the left value, `bfill` the right;
+ *   `zero` writes 0; `literal` writes the supplied value; `linear`
+ *   interpolates by time (`tspan === 0` ⇒ the left value). `zero` and
+ *   `linear` are **numeric-only** — on a non-numeric column they
+ *   silently skip (the column is left untouched, not rebuilt).
+ *
+ * Unlike the numeric folds (`cumulative`, `diff`), `fill` preserves
+ * each column's **kind** — `hold` / `bfill` / `literal` apply to any
+ * kind — so a changed column is rebuilt with the kind-appropriate
+ * builder (`buildFilledColumn`). A `literal` whose runtime type
+ * doesn't match the column kind throws a `RangeError` naming the
+ * column when it would be placed (gap-dependent).
+ *
+ * **This throw is a deliberate behavior change, not parity.** The old
+ * events path did NOT throw on a kind-mismatched literal: it stored
+ * the literal in the event cache *and* coerced it into the numeric
+ * buffer, yielding an internally-inconsistent series (`.get()`
+ * returned the string, `.column().sum()` returned `NaN`). Column-
+ * native has a single representation, so that dual-view inconsistency
+ * is unreproducible — failing fast on the nonsensical input (a kind-
+ * mismatched literal is only writable because `FillMapping` values
+ * are the broad `FillStrategy | ScalarValue`) is the principled
+ * replacement.
+ *
+ * The schema is unchanged (fill never widens or drops); the cast is
+ * the single trust boundary, and the `TimeSeries.fill` method wraps
+ * the store via `#fromTrustedStore`.
+ */
+export function fillOp(store, schema, specs, limit, maxGapMs) {
+    const n = store.length;
+    if (n === 0 || specs.size === 0) {
+        return { store, schema };
+    }
+    const colKind = new Map();
+    for (let i = 1; i < schema.length; i += 1) {
+        colKind.set(schema[i].name, schema[i].kind);
+    }
+    // Times are needed only for `linear` and `maxGap`; build once, lazily.
+    let times;
+    const getTimes = () => {
+        if (times === undefined) {
+            times = new Array(n);
+            for (let i = 0; i < n; i += 1)
+                times[i] = store.beginAt(i);
+        }
+        return times;
+    };
+    let result = store;
+    for (const [name, spec] of specs) {
+        const col = store.columns.get(name);
+        if (col === undefined)
+            continue;
+        const kind = colKind.get(name);
+        // `zero` / `linear` are numeric-only: skip non-numeric columns
+        // entirely (leave the original column, no rebuild).
+        if ((spec.mode === 'zero' || spec.mode === 'linear') && kind !== 'number') {
+            continue;
+        }
+        const values = new Array(n);
+        for (let i = 0; i < n; i += 1)
+            values[i] = col.read(i);
+        let changed = false;
+        let i = 0;
+        while (i < n) {
+            if (values[i] !== undefined) {
+                i += 1;
+                continue;
+            }
+            const start = i;
+            while (i < n && values[i] === undefined)
+                i += 1;
+            const end = i; // exclusive
+            const length = end - start;
+            const hasPrev = start > 0;
+            const hasNext = end < n;
+            let strategyOk;
+            switch (spec.mode) {
+                case 'linear':
+                    strategyOk = hasPrev && hasNext;
+                    break;
+                case 'hold':
+                    strategyOk = hasPrev;
+                    break;
+                case 'bfill':
+                    strategyOk = hasNext;
+                    break;
+                default:
+                    strategyOk = true; // zero, literal
+            }
+            if (!strategyOk)
+                continue;
+            if (limit !== undefined && length > limit)
+                continue;
+            if (maxGapMs !== undefined) {
+                const t = getTimes();
+                let span;
+                if (hasPrev && hasNext) {
+                    span = t[end] - t[start - 1];
+                }
+                else if (hasPrev) {
+                    span = t[end - 1] - t[start - 1];
+                }
+                else if (hasNext) {
+                    span = t[end] - t[start];
+                }
+                else {
+                    span = 0;
+                }
+                if (span > maxGapMs)
+                    continue;
+            }
+            switch (spec.mode) {
+                case 'hold': {
+                    const v = values[start - 1];
+                    for (let j = start; j < end; j += 1)
+                        values[j] = v;
+                    changed = true;
+                    break;
+                }
+                case 'bfill': {
+                    const v = values[end];
+                    for (let j = start; j < end; j += 1)
+                        values[j] = v;
+                    changed = true;
+                    break;
+                }
+                case 'zero': {
+                    for (let j = start; j < end; j += 1)
+                        values[j] = 0;
+                    changed = true;
+                    break;
+                }
+                case 'literal': {
+                    // Gap-dependent kind check: throws exactly when a kind-broken
+                    // literal would be placed (matching the old SeriesStore-intake
+                    // error), with a clearer column-named message.
+                    if (!valueMatchesKind(spec.value, kind)) {
+                        throw new RangeError(`fill: literal value ${JSON.stringify(spec.value)} for column '${name}' does not match its kind '${kind}'`);
+                    }
+                    for (let j = start; j < end; j += 1)
+                        values[j] = spec.value;
+                    changed = true;
+                    break;
+                }
+                case 'linear': {
+                    const before = values[start - 1];
+                    const after = values[end];
+                    const t = getTimes();
+                    const t0 = t[start - 1];
+                    const t1 = t[end];
+                    const tspan = t1 - t0;
+                    for (let j = start; j < end; j += 1) {
+                        values[j] =
+                            tspan === 0
+                                ? before
+                                : before + (after - before) * ((t[j] - t0) / tspan);
+                    }
+                    changed = true;
+                    break;
+                }
+            }
+        }
+        if (changed) {
+            result = withColumnReplaced(result, name, buildFilledColumn(kind, values));
+        }
+    }
+    return { store: result, schema };
+}
+//# sourceMappingURL=fill.js.map

package/dist/batch/operators/fill.js.map

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

package/dist/batch/operators/map.d.ts

@@ -0,0 +1,56 @@
+import { type ColumnarStore } from '../../columnar/index.js';
+import type { SeriesSchema } from '../../schema/index.js';
+/**
+ * A per-cell value transform: `(value) => newValue`, where the output
+ * is the **same kind** as the input (number→number, string→string,
+ * …). The `TimeSeries.mapColumns` method types each column's mapper
+ * against that column's value type; the operator erases to
+ * `(value: unknown) => unknown` at the trust boundary.
+ */
+export type ColumnMapper = (value: unknown) => unknown;
+/**
+ * **Step 4 — column-native `mapColumns` (extracted operator).** Applies
+ * a per-cell value transform to one or more columns, straight off the
+ * columnar store: read each target's cells (storage-agnostic
+ * `read(i)`), apply the mapper to each **defined** value, rebuild the
+ * column — no `series.events` materialization, no per-row `Event`.
+ * Non-mapped columns + the key axis pass through by reference.
+ *
+ * Semantics:
+ * - **Missing cells carry.** The mapper is called only on defined
+ *   values; a missing (`undefined`) cell stays missing (the mapper is
+ *   not invoked).
+ * - **Numeric results must be finite.** For a `number` column, a mapper
+ *   result of `NaN` or `±Infinity` throws a `RangeError` at write —
+ *   matching construction intake (`assertCellKind`), which rejects
+ *   non-finite numbers. This keeps packed numeric columns NaN-free, so
+ *   the columnar fast-path and the row-path reducers can never diverge
+ *   on the same bucket (the bug audit v2 §1.3 reproduced). A stored
+ *   `NaN` *is* a defined value, so the mapper is still invoked on it —
+ *   use that to clean it (map `NaN` to a finite number, or to
+ *   `undefined` for a missing cell). (Array columns are not
+ *   element-checked here; they don't feed the numeric reducers.)
+ * - **Same kind, schema-stable.** The mapper returns the column's own
+ *   kind (the method's type enforces `(value: T) => T`), so the output
+ *   column keeps its kind and the schema is unchanged. The result is
+ *   rebuilt with the kind-appropriate builder.
+ *
+ * The schema is returned unchanged; the cast is the single trust
+ * boundary, and the `TimeSeries.mapColumns` method wraps the store via
+ * `#fromTrustedStore`.
+ *
+ * A mapper that — only by defeating the `(value: T) => T` type —
+ * returns `undefined`, or a value of the wrong kind (e.g. a string
+ * from a numeric mapper via an `as` cast), produces a cell the
+ * same-kind builder can't store: `columnFromValuesByKind` coerces it
+ * to missing, so the cell reads back as a gap the declared schema may
+ * not advertise. Both are type-illegal inputs, not handled specially.
+ * (A non-finite *number* from a numeric mapper is the one same-kind
+ * case that throws rather than coerces — it would corrupt the packed
+ * column, not read back as a gap.)
+ */
+export declare function mapOp<S extends SeriesSchema>(store: ColumnarStore<S>, schema: S, spec: ReadonlyMap<string, ColumnMapper>): {
+    store: ColumnarStore<S>;
+    schema: S;
+};
+//# sourceMappingURL=map.d.ts.map

package/dist/batch/operators/map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"map.d.ts","sourceRoot":"","sources":["../../../src/batch/operators/map.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,aAAa,EAOnB,MAAM,yBAAyB,CAAC;AACjC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAE1D;;;;;;GAMG;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC;AAyBvD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,wBAAgB,KAAK,CAAC,CAAC,SAAS,YAAY,EAC1C,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,MAAM,EAAE,CAAC,EACT,IAAI,EAAE,WAAW,CAAC,MAAM,EAAE,YAAY,CAAC,GACtC;IAAE,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,CAAC;IAAC,MAAM,EAAE,CAAC,CAAA;CAAE,CAqDxC"}

package/dist/batch/operators/map.js

@@ -0,0 +1,109 @@
+import { arrayColumnFromArray, booleanColumnFromArray, float64ColumnFromArray, stringColumnFromArray, withColumnReplaced, } from '../../columnar/index.js';
+/**
+ * Rebuilds a mapped value array into a column of the given kind.
+ *
+ * NB: this is the same kind→builder dispatch as `fillOp`'s
+ * `buildFilledColumn`. Two callers now (fill + map) — a candidate for
+ * a shared `columnFromValuesByKind` helper in a follow-up; kept local
+ * here to keep this PR focused on the new operator.
+ */
+function columnFromValuesByKind(kind, values) {
+    switch (kind) {
+        case 'number':
+            return float64ColumnFromArray(values);
+        case 'string':
+            return stringColumnFromArray(values);
+        case 'boolean':
+            return booleanColumnFromArray(values);
+        case 'array':
+            return arrayColumnFromArray(values);
+        default:
+            throw new TypeError(`mapColumns: unsupported column kind '${kind}'`);
+    }
+}
+/**
+ * **Step 4 — column-native `mapColumns` (extracted operator).** Applies
+ * a per-cell value transform to one or more columns, straight off the
+ * columnar store: read each target's cells (storage-agnostic
+ * `read(i)`), apply the mapper to each **defined** value, rebuild the
+ * column — no `series.events` materialization, no per-row `Event`.
+ * Non-mapped columns + the key axis pass through by reference.
+ *
+ * Semantics:
+ * - **Missing cells carry.** The mapper is called only on defined
+ *   values; a missing (`undefined`) cell stays missing (the mapper is
+ *   not invoked).
+ * - **Numeric results must be finite.** For a `number` column, a mapper
+ *   result of `NaN` or `±Infinity` throws a `RangeError` at write —
+ *   matching construction intake (`assertCellKind`), which rejects
+ *   non-finite numbers. This keeps packed numeric columns NaN-free, so
+ *   the columnar fast-path and the row-path reducers can never diverge
+ *   on the same bucket (the bug audit v2 §1.3 reproduced). A stored
+ *   `NaN` *is* a defined value, so the mapper is still invoked on it —
+ *   use that to clean it (map `NaN` to a finite number, or to
+ *   `undefined` for a missing cell). (Array columns are not
+ *   element-checked here; they don't feed the numeric reducers.)
+ * - **Same kind, schema-stable.** The mapper returns the column's own
+ *   kind (the method's type enforces `(value: T) => T`), so the output
+ *   column keeps its kind and the schema is unchanged. The result is
+ *   rebuilt with the kind-appropriate builder.
+ *
+ * The schema is returned unchanged; the cast is the single trust
+ * boundary, and the `TimeSeries.mapColumns` method wraps the store via
+ * `#fromTrustedStore`.
+ *
+ * A mapper that — only by defeating the `(value: T) => T` type —
+ * returns `undefined`, or a value of the wrong kind (e.g. a string
+ * from a numeric mapper via an `as` cast), produces a cell the
+ * same-kind builder can't store: `columnFromValuesByKind` coerces it
+ * to missing, so the cell reads back as a gap the declared schema may
+ * not advertise. Both are type-illegal inputs, not handled specially.
+ * (A non-finite *number* from a numeric mapper is the one same-kind
+ * case that throws rather than coerces — it would corrupt the packed
+ * column, not read back as a gap.)
+ */
+export function mapOp(store, schema, spec) {
+    const n = store.length;
+    if (n === 0 || spec.size === 0) {
+        return { store, schema };
+    }
+    const colKind = new Map();
+    for (let i = 1; i < schema.length; i += 1) {
+        colKind.set(schema[i].name, schema[i].kind);
+    }
+    let result = store;
+    for (const [name, fn] of spec) {
+        const col = store.columns.get(name);
+        if (col === undefined)
+            continue;
+        const kind = colKind.get(name);
+        // Numeric columns reject a non-finite (NaN / ±Infinity) mapper result at
+        // write, matching construction intake (assertCellKind). A packed NaN would
+        // otherwise be unreachable-by-assumption for the reduce kernels and diverge
+        // the fast path from the row path (audit v2 §1.3). Hoisted out of the loop
+        // so non-numeric columns pay nothing.
+        const rejectNonFinite = kind === 'number';
+        const out = new Array(n);
+        for (let i = 0; i < n; i += 1) {
+            const v = col.read(i);
+            if (v === undefined) {
+                out[i] = undefined;
+                continue;
+            }
+            const mapped = fn(v);
+            if (rejectNonFinite &&
+                typeof mapped === 'number' &&
+                !Number.isFinite(mapped)) {
+                throw new RangeError(`mapColumns: the mapper for column '${name}' returned a non-finite ` +
+                    `number (${mapped}) at row ${i}. Numeric columns reject NaN and ` +
+                    `±Infinity at write, consistent with intake — a packed NaN would ` +
+                    `diverge the fast-path and row-path reducers on the same data. ` +
+                    `Map to a finite number, or to undefined for a missing cell.`);
+            }
+            out[i] = mapped;
+        }
+        result = withColumnReplaced(result, name, columnFromValuesByKind(kind, out));
+    }
+    return { store: result, schema };
+}
+//# sourceMappingURL=map.js.map

package/dist/batch/operators/map.js.map

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

package/dist/batch/operators/shift.d.ts

@@ -0,0 +1,31 @@
+import { type ColumnarStore } from '../../columnar/index.js';
+import type { SeriesSchema } from '../../schema/index.js';
+/**
+ * **Step 4 — column-native `shift` (extracted operator).** Shifts each
+ * target numeric column's values by `n` rows, straight off the
+ * columnar store: row `i` takes the value at row `i − n` (storage-
+ * agnostic `col.read`), or `undefined` when that source row is out of
+ * range — no `series.events` materialization, no per-row `Event`.
+ * Non-target columns + the key axis pass through by reference.
+ *
+ * `n > 0` shifts forward (a lag: the first `n` rows pad to
+ * `undefined`); `n < 0` shifts backward (a lead: the last `|n|` rows
+ * pad); `n === 0` is identity. `n` beyond the row count pads the whole
+ * column. The padding is why targets widen to optional `number` in the
+ * output schema.
+ *
+ * Returns the reshaped store + the output schema; the result-schema
+ * cast is the single trust boundary, and the `TimeSeries.shift` method
+ * wraps the store via `#fromTrustedStore`.
+ *
+ * A non-numeric target is unreachable through the typed surface
+ * (`NumericColumnNameForSchema<S>`); defeating that constraint makes the
+ * `Float64Column` replacement collide with the existing column's kind, so
+ * `withColumnReplaced`'s kind guard throws a `RangeError` naming the column
+ * — fail-fast, matching `cumulativeOp` / `diffRateOp`.
+ */
+export declare function shiftOp<S extends SeriesSchema, OutSchema extends SeriesSchema>(store: ColumnarStore<S>, schema: S, cols: readonly string[], n: number): {
+    store: ColumnarStore<OutSchema>;
+    schema: OutSchema;
+};
+//# sourceMappingURL=shift.d.ts.map

package/dist/batch/operators/shift.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shift.d.ts","sourceRoot":"","sources":["../../../src/batch/operators/shift.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,aAAa,EAInB,MAAM,yBAAyB,CAAC;AACjC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAE1D;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,OAAO,CAAC,CAAC,SAAS,YAAY,EAAE,SAAS,SAAS,YAAY,EAC5E,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,MAAM,EAAE,CAAC,EACT,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,CAAC,EAAE,MAAM,GACR;IAAE,KAAK,EAAE,aAAa,CAAC,SAAS,CAAC,CAAC;IAAC,MAAM,EAAE,SAAS,CAAA;CAAE,CAmCxD"}