pond-ts 0.34.0 → 0.35.0

package/CHANGELOG.md

@@ -8,7 +8,9 @@ The `@pond-ts` packages — `pond-ts`, `@pond-ts/react`, `@pond-ts/charts`, and
 them all. Pre-1.0: minor bumps may include new features and type-level changes;
 patch bumps are strictly additive.
 
-[Unreleased]: https://github.com/pjm17971/pond-ts/compare/v0.34.0...HEAD
+[Unreleased]: https://github.com/pjm17971/pond-ts/compare/v0.35.0...HEAD
+[0.35.0]: https://github.com/pjm17971/pond-ts/compare/v0.34.1...v0.35.0
+[0.34.1]: https://github.com/pjm17971/pond-ts/compare/v0.34.0...v0.34.1
 [0.34.0]: https://github.com/pjm17971/pond-ts/compare/v0.33.0...v0.34.0
 [0.33.0]: https://github.com/pjm17971/pond-ts/compare/v0.32.0...v0.33.0
 [0.32.0]: https://github.com/pjm17971/pond-ts/compare/v0.31.2...v0.32.0
@@ -29,6 +31,46 @@ patch bumps are strictly additive.
 [0.19.0]: https://github.com/pjm17971/pond-ts/compare/v0.18.0...v0.19.0
 [0.18.0]: https://github.com/pjm17971/pond-ts/compare/v0.17.1...v0.18.0
 
+## [0.35.0] — 2026-07-02
+
+A `@pond-ts/charts` release: per-series line dash patterns. `pond-ts`,
+`@pond-ts/react`, and `@pond-ts/fit` carry no code changes — republished in
+lock-step (their `pond-ts` / `@pond-ts/react` peer ranges widen to `^0.35.0`).
+
+### Added
+
+- **Charts — per-series line dash (`LineStyle.dash`).** A theme's line style
+  accepts an optional `dash?: readonly number[]` — a px on/off pattern
+  (`[6, 4]` dashed, `[2, 3]` ≈ dotted; omit or `[]` = solid) applied to the
+  series stroke. Lets a theme set a **modeled / forecast** line (e.g. GARCH
+  vol) apart from an observed one at a glance. Distinct from a `GapMode`'s
+  inferred gap-bridge dashing (which marks *missing data*, not the whole
+  line). Additive: existing themes are unaffected; a solid line never touches
+  `setLineDash`. New `Charts/LineChart → LineStyles` story. (#313)
+
+## [0.34.1] — 2026-07-01
+
+A `pond-ts` core patch: fixes a performance regression introduced in 0.34.0.
+`@pond-ts/react`, `@pond-ts/charts`, and `@pond-ts/fit` carry no code
+changes — republished in lock-step; their `^0.34.0` peer ranges already
+admit this patch.
+
+### Fixed
+
+- **`TimeSeries.fromColumns` — `number[]` column conversion was ~7-18x
+  slower than intended.** The `null`/`NaN`-gap parity fix in 0.34.0
+  converted `number[]` columns via `Float64Array.from(raw, mapFn)`.
+  Supplying a map function forces V8's generic iterable-protocol path even
+  for a plain array, dramatically slower than a manual loop into a
+  preallocated buffer at 100k-element scale. Found while pointing the
+  `pond-columnar-ingest` wire-format spike at the real published package
+  instead of a local build. Fixed with a manual `for` loop in both the
+  key-column and value-column conversion paths — no behavior change, same
+  gap semantics, all 12 `fromColumns` tests unchanged and green. Added
+  `scripts/perf-from-columns.mjs` as the durable regression benchmark.
+  Measured: 100k × 7 cols, `number[]` columns, dense — 21.5ms → 2.9ms.
+  (#311)
+
 ## [0.34.0] — 2026-07-01
 
 A `pond-ts` core release: the columnar/typed-array ingress driven by the

package/dist/batch/time-series.js

@@ -535,10 +535,22 @@ export class TimeSeries {
         if (keyRaw === undefined) {
             throw new ValidationError(`fromColumns: missing key column '${keyDef.name}'`);
         }
-        // epoch-ms buffer; TimeKeyColumn asserts all finite.
-        const begin = keyRaw instanceof Float64Array
-            ? keyRaw
-            : Float64Array.from(keyRaw, (v) => (v == null ? NaN : Number(v)));
+        // epoch-ms buffer; TimeKeyColumn asserts all finite. A manual loop, not
+        // `Float64Array.from(arr, mapFn)`: supplying a map function forces V8's
+        // generic iterable-protocol path even for a plain array, ~15-20x slower
+        // than a preallocated-buffer copy at 100k-element scale — measured, not
+        // theoretical (see the pond-columnar-ingest spike's ingest regression).
+        let begin;
+        if (keyRaw instanceof Float64Array) {
+            begin = keyRaw;
+        }
+        else {
+            begin = new Float64Array(keyRaw.length);
+            for (let j = 0; j < keyRaw.length; j += 1) {
+                const v = keyRaw[j];
+                begin[j] = v == null ? NaN : Number(v);
+            }
+        }
         const count = begin.length;
         // Throws on any non-finite timestamp.
         const keys = new TimeKeyColumn(begin, count);
@@ -579,9 +591,19 @@ export class TimeSeries {
             // the `Float64Array` branch's `Number.isFinite` gap signal — the same
             // wire value would silently mean different things depending on which
             // array type decoded it.
-            const values = raw instanceof Float64Array
-                ? raw
-                : Float64Array.from(raw, (v) => (v == null ? NaN : v));
+            // Manual loop, not `Float64Array.from(arr, mapFn)` — see the key-column
+            // comment above; the cost applies identically here.
+            let values;
+            if (raw instanceof Float64Array) {
+                values = raw;
+            }
+            else {
+                values = new Float64Array(count);
+                for (let j = 0; j < count; j += 1) {
+                    const v = raw[j];
+                    values[j] = v == null ? NaN : v;
+                }
+            }
             const validity = validityFromPredicate(count, (j) => Number.isFinite(values[j]));
             columnMap.set(def.name, new Float64Column(values, count, validity, validity === undefined));
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pond-ts",
-  "version": "0.34.0",
+  "version": "0.35.0",
   "description": "TypeScript-first time series primitives",
   "license": "MIT",
   "repository": {