@pond-ts/process 0.69.0 → 0.70.0

package/API.md

@@ -716,31 +716,31 @@ Typed dataflow graphs for pipelines whose **shape is data** (runtime-assembled,
 user-edited, one computation fanned out to several consumers). Chaining stays
 the default for pipelines known at authoring time — see the package README.
 
-| Group                   | Exports                                                                                                                                                                                                                                                                                                                                                                                                               | Source                                               |
-| ----------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------- |
-| Worker pool (Node)      | `HostPool` (`start`, `run`, `close`, `size`, `inFlight`); types `HostPoolOptions`, `PoolSetup`, `PoolSetupConfig`; `toWire` / `fromWire`, types `WireResult`, `WireColumn` — subpath `@pond-ts/process/pool`                                                                                                                                                                                                          | `packages/process/src/pool/index.ts`                 |
-| Ports                   | `Inlet`, `Outlet` (typed fields on `node.in` / `node.out`; `get()`, `peek()`, `version`, `connect`, `disconnect`)                                                                                                                                                                                                                                                                                                     | `packages/process/src/port.ts`                       |
-| Nodes                   | `Node` (`in`, `out`, `dirty`, `error`, `invalidate()`), `defineNode` (reusable multi-output node type), `derive` (single-output, wired inline)                                                                                                                                                                                                                                                                        | `packages/process/src/node.ts`                       |
-| Port declaration        | `port<T>({ equals, defaultValue })`; types `PortSpec`, `PortSpecMap`, `PortValue`, `PortValues`                                                                                                                                                                                                                                                                                                                       | `packages/process/src/types.ts`                      |
-| Sources                 | `source<T>()` → `SourceNode` (`set()`), `fromLive(liveSource)` → `LiveSourceNode` (`dispose()`); `GraphSource` (bind contract — looser than core's `LiveSource`, accepts `LiveAggregation`), `SnapshotSource`, `NoInputs`                                                                                                                                                                                             | `packages/process/src/source.ts`                     |
-| Graph view              | `Graph` (`Graph.from(...roots)`, `nodes`, `order()`, `edges()`, `toJSON()`); types `GraphEdge`, `GraphJson`, `GraphNodeJson`, `GraphEdgeJson`                                                                                                                                                                                                                                                                         | `packages/process/src/graph.ts`                      |
-| Range output buffers    | `prepareRange(length, keep, prior)` → `RangeOutput` (`values`, `bits`, `set`, `clear`) carrying `[0, keep)` forward as blocks — values **and** validity; `sealRange(out, length)` → `Float64Column`; `validityByteCount`. Reached from an op as `ctx.out[n]`                                                                                                                                                          | `packages/process/src/column.ts`                     |
-| Ranged recompute        | `graph.setSourceFrom(series, changedFrom)` — declares which row first changed; `graph.recomputes` → `{ ranged, full }`. An op opts in with `OpDef.runRange(ctx)`, receiving `{ from, to, previous, previousView, out }` (type `RangeContext`) — write into `out` and return nothing for the block path alongside the usual context. Requires `lookback`. Falls back to a full `run` whenever anything is missing      | `packages/process/src/plan/graph.ts`                 |
-| Node budget             | `bind(series, { registry, budgetBytes })` — engine-wide cap on retained node values, LRU, enforced after each `run`; `graph.retainedBytes` / `graph.evictions` / `graph.enforceBudget()`. Unbounded when omitted. Skips a node whose consumer still holds its outlet                                                                                                                                                  | `packages/process/src/plan/graph.ts`                 |
-| Plan history            | `requiredHistory(registry, plan)` → `{ known, rows?, undeclared, byOp }` — the minimum safe tail in rows, folded from per-op `OpDef.lookback`. Sums along nesting, maxes across siblings. `known: false` names ops with no declared lookback rather than defaulting to zero (type `HistoryResult`)                                                                                                                    | `packages/process/src/plan/history.ts`               |
-| Column values           | `packColumn` (values → packed `Float64Column`, NaN = missing), `columnBytes` (retained size, for a byte budget), `appendColumn` (column → series; boxing-free when gapless), `columnBuffers` / `columnFromBuffers` (the buffer pair a column is, for an isolate boundary; type `ColumnBuffers`), `columnView` (zero-copy borrowed read view for in-process folds; type `ColumnView`)                                  | `packages/process/src/column.ts`                     |
-| Plan — registry         | `createRegistry({ folds })` / `Registry` (`define`, `get`, `foldFor`, `outputsOf`, `resolveParams` (`{ validate: false }` applies defaults and skips every check), `byFamily`, `describe`, `toJsonSchema`), param builders `int` / `num` / `choice` / `flag`, `UnknownOpError`, `ParamError`                                                                                                                          | `packages/process/src/plan/registry.ts`, `params.ts` |
-| Plan — identity         | `specId(registry, spec, { validate })` (content-addressed, param-order invariant, defaults materialized; `validate: false` is **total** — names a spec that would not compile in a separate `p1?:` namespace that cannot collide with a valid id; a valid spec's id is identical either way), `SpecIdOptions`, `refToId`, `explain`, `unitOf`, `columnsOf`, `dependsOn`, `outputKey`                                  | `packages/process/src/plan/identity.ts`              |
-| Plan — types            | `Spec`, `Plan`, `Input` (column name \| `Spec` \| `PickedOutput`), `SpecRef`, `Def` (`OpDef` \| `FoldDef`), `OpContext`, `OpResult`, `FoldContext`, `FactBody`, `isFold`, `ParamDef`, `Params`, `Units`, `InputDef`, `OutputDef`                                                                                                                                                                                      | `packages/process/src/plan/types.ts`                 |
-| Plan — bind / run       | `bind(series, { registry, units })` → `BoundGraph` (`compile`, `setSource`, `ids`, `series`, `columnOf`), `run(graph, { plan, select, onError })` → `RunResult`, `UnitError`, `UnknownColumnError` (a raw string input naming no column of the bound series, checked over the whole closure and re-checked on the warm path)                                                                                          | `packages/process/src/plan/graph.ts`, `run.ts`       |
-| Plan — request/response | `RunRequest` (`PlanRequest` \| `SlotRequest`), `RunOptions`, `RunResult`, `Select` (`{ on, output?, name? }` — points at a node; what comes back is what that node produces), `ErrorPolicy`, `Fact` (carries `op`), `OutputInfo`, `Skipped` (`spec`, `select`, `reason`, `code` — the failure's kind, matching the error class a throw would have carried), `NodeTiming` (`slot`, `pulled`, `cached`, `ms`, `inputs`) | `packages/process/src/plan/run.ts`                   |
-| Plan — host             | `createHost({ registry, units, sources })` → `Host` (`add`, `has`, `datasets`, `graphFor`, `run`, `runAsync`), `toWire`, `UnknownDatasetError`; local-string `Envelope` (`PlanEnvelope` \| `SlotEnvelope`), remote-capable `AsyncEnvelope` (`AsyncPlanEnvelope` \| `AsyncSlotEnvelope` \| `Envelope`), `DatasetInfo`, `WireResult`                                                                                    | `packages/process/src/plan/host.ts`                  |
-| Plan — slots            | `expandSlots(slots, columns)` → `Map<slot, Spec>` (expands to the nested form, so ids match by construction; `slot#Output` picks one output), `SlotError`; types `SlotDef` (`{ op, params, in }`), `Slots`                                                                                                                                                                                                            | `packages/process/src/plan/slots.ts`                 |
-| Plan — builder          | `plan(from)` → low-level `PlanBuilder`; `process(registry, from)` → typed fluent `ProcessBuilder` (`column`, op methods, `outputs`), `BuilderError`; types `NodeHandle`, `OutputHandle`, `FluentColumnRef`, `SingleColumnNode`, `MultiColumnNode`, `ColumnSelection`, `FactRef`, `BuiltRequest`                                                                                                                       | `packages/process/src/plan/builder.ts`, `fluent.ts`  |
-| Plan — async sources    | `defineSource({ name, load })`, `createSourceRegistry()` / `SourceRegistry`, `sourceId`, `UnknownSourceError`; types `SourceRef`, `SourceParams`, `LoadedSource` (value + revision), `SourceLoadContext`, `SourceDef`                                                                                                                                                                                                 | `packages/process/src/plan/source.ts`                |
-| Plan — folds            | `STANDARD_FOLDS` and the four it holds — `last`, `extremes`, `percentileRank`, `shape` — pre-registered by `createRegistry()`; each a plain `FoldDef`, so a consumer can `define` over one                                                                                                                                                                                                                            | `packages/process/src/plan/folds.ts`                 |
-| Errors                  | `ProcessError` (base; `code` — a stable per-class literal, minification-proof, also surfaced on `Skipped`), `CycleError`, `UnconnectedInputError`, `MissingOutputError`, `UnsetSourceError`                                                                                                                                                                                                                           | `packages/process/src/errors.ts`                     |
-| Node type helpers       | `NodeSpec`, `NodeFactory`, `InletsFor`, `OutletsFor`, `OutletValue`, `SpecsForOutlets`, `DerivedOutput`                                                                                                                                                                                                                                                                                                               | `packages/process/src/node.ts`                       |
+| Group                   | Exports                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | Source                                               |
+| ----------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------- |
+| Worker pool (Node)      | `HostPool` (`start`, `run`, `close`, `size`, `inFlight`); types `HostPoolOptions`, `PoolSetup`, `PoolSetupConfig`; `toWire` / `fromWire`, types `WireResult`, `WireColumn` — subpath `@pond-ts/process/pool`                                                                                                                                                                                                                                                                     | `packages/process/src/pool/index.ts`                 |
+| Ports                   | `Inlet`, `Outlet` (typed fields on `node.in` / `node.out`; `get()`, `peek()`, `version`, `connect`, `disconnect`)                                                                                                                                                                                                                                                                                                                                                                | `packages/process/src/port.ts`                       |
+| Nodes                   | `Node` (`in`, `out`, `dirty`, `error`, `invalidate()`), `defineNode` (reusable multi-output node type), `derive` (single-output, wired inline)                                                                                                                                                                                                                                                                                                                                   | `packages/process/src/node.ts`                       |
+| Port declaration        | `port<T>({ equals, defaultValue })`; types `PortSpec`, `PortSpecMap`, `PortValue`, `PortValues`                                                                                                                                                                                                                                                                                                                                                                                  | `packages/process/src/types.ts`                      |
+| Sources                 | `source<T>()` → `SourceNode` (`set()`), `fromLive(liveSource)` → `LiveSourceNode` (`dispose()`); `GraphSource` (bind contract — looser than core's `LiveSource`, accepts `LiveAggregation`), `SnapshotSource`, `NoInputs`                                                                                                                                                                                                                                                        | `packages/process/src/source.ts`                     |
+| Graph view              | `Graph` (`Graph.from(...roots)`, `nodes`, `order()`, `edges()`, `toJSON()`); types `GraphEdge`, `GraphJson`, `GraphNodeJson`, `GraphEdgeJson`                                                                                                                                                                                                                                                                                                                                    | `packages/process/src/graph.ts`                      |
+| Range output buffers    | `prepareRange(length, keep, prior)` → `RangeOutput` (`values`, `bits`, `set`, `clear`) carrying `[0, keep)` forward as blocks — values **and** validity; `sealRange(out, length)` → `Float64Column`; `validityByteCount`. Reached from an op as `ctx.out[n]`                                                                                                                                                                                                                     | `packages/process/src/column.ts`                     |
+| Ranged recompute        | `graph.setSourceFrom(series, changedFrom)` — declares which row first changed; `graph.recomputes` → `{ ranged, full }`. An op opts in with `OpDef.runRange(ctx)`, receiving `{ from, to, previous, previousView, out }` (type `RangeContext`) — write into `out` and return nothing for the block path alongside the usual context. Requires `lookback`. Falls back to a full `run` whenever anything is missing                                                                 | `packages/process/src/plan/graph.ts`                 |
+| Node budget             | `bind(series, { registry, budgetBytes })` — engine-wide cap on retained node values, LRU, enforced after each `run`; `graph.retainedBytes` / `graph.evictions` / `graph.enforceBudget()`. Unbounded when omitted. Skips a node whose consumer still holds its outlet                                                                                                                                                                                                             | `packages/process/src/plan/graph.ts`                 |
+| Plan history            | `requiredHistory(registry, plan)` → `{ known, rows?, undeclared, byOp }` — the minimum safe tail in rows, folded from per-op `OpDef.lookback`. Sums along nesting, maxes across siblings. `known: false` names ops with no declared lookback rather than defaulting to zero (type `HistoryResult`)                                                                                                                                                                               | `packages/process/src/plan/history.ts`               |
+| Column values           | `packColumn` (values → packed `Float64Column`, NaN = missing), `columnBytes` (retained size, for a byte budget), `appendColumn` (column → series; boxing-free when gapless), `columnBuffers` / `columnFromBuffers` (the buffer pair a column is, for an isolate boundary; type `ColumnBuffers`), `columnView` (zero-copy borrowed read view for in-process folds; type `ColumnView`)                                                                                             | `packages/process/src/column.ts`                     |
+| Plan — registry         | `createRegistry({ folds })` / `Registry` (`define`, `get`, `foldFor`, `outputsOf`, `resolveParams` (`{ validate: false }` applies defaults and skips every check), `byFamily`, `describe`, `toJsonSchema`, `checkArity`), param builders `int` / `num` / `choice` / `flag`, `UnknownOpError`, `ParamError`, `ArityError`                                                                                                                                                         | `packages/process/src/plan/registry.ts`, `params.ts` |
+| Plan — identity         | `specId(registry, spec, { validate })` (content-addressed, param-order invariant, defaults materialized; `validate: false` is **total over arbitrary JSON** — names a spec that would not compile, including malformed shapes, in a separate `p1?:` namespace that cannot collide with a valid id; a valid spec's id is identical either way. Judges op existence, params **and arity**), `SpecIdOptions`, `refToId`, `explain`, `unitOf`, `columnsOf`, `dependsOn`, `outputKey` | `packages/process/src/plan/identity.ts`              |
+| Plan — types            | `Spec`, `Plan`, `Input` (column name \| `Spec` \| `PickedOutput`), `SpecRef`, `Def` (`OpDef` \| `FoldDef`), `OpContext`, `OpResult`, `FoldContext`, `FactBody`, `isFold`, `ParamDef`, `Params`, `Units`, `InputDef`, `OutputDef`                                                                                                                                                                                                                                                 | `packages/process/src/plan/types.ts`                 |
+| Plan — bind / run       | `bind(series, { registry, units })` → `BoundGraph` (`compile`, `setSource`, `ids`, `series`, `columnOf`), `run(graph, { plan, select, onError })` → `RunResult`, `UnitError`, `UnknownColumnError` (a raw string input naming no column of the bound series, checked over the whole closure and re-checked on the warm path)                                                                                                                                                     | `packages/process/src/plan/graph.ts`, `run.ts`       |
+| Plan — request/response | `RunRequest` (`PlanRequest` \| `SlotRequest`), `RunOptions`, `RunResult`, `Select` (`{ on, output?, name? }` — points at a node; what comes back is what that node produces), `ErrorPolicy`, `Fact` (carries `op`), `OutputInfo`, `Skipped` (`spec` — echoed verbatim, `params`/`inputs` typed `unknown`; `select`, `reason`, `code` — the failure's kind, matching the error class a throw would have carried), `NodeTiming` (`slot`, `pulled`, `cached`, `ms`, `inputs`)       | `packages/process/src/plan/run.ts`                   |
+| Plan — host             | `createHost({ registry, units, sources })` → `Host` (`add`, `has`, `datasets`, `graphFor`, `run`, `runAsync`), `toWire`, `UnknownDatasetError`; local-string `Envelope` (`PlanEnvelope` \| `SlotEnvelope`), remote-capable `AsyncEnvelope` (`AsyncPlanEnvelope` \| `AsyncSlotEnvelope` \| `Envelope`), `DatasetInfo`, `WireResult`                                                                                                                                               | `packages/process/src/plan/host.ts`                  |
+| Plan — slots            | `expandSlots(slots, columns)` → `Map<slot, Spec>` (expands to the nested form, so ids match by construction; `slot#Output` picks one output), `SlotError`; types `SlotDef` (`{ op, params, in }`), `Slots`                                                                                                                                                                                                                                                                       | `packages/process/src/plan/slots.ts`                 |
+| Plan — builder          | `plan(from)` → low-level `PlanBuilder`; `process(registry, from)` → typed fluent `ProcessBuilder` (`column`, op methods, `outputs`), `BuilderError`; types `NodeHandle`, `OutputHandle`, `FluentColumnRef`, `SingleColumnNode`, `MultiColumnNode`, `ColumnSelection`, `FactRef`, `BuiltRequest`                                                                                                                                                                                  | `packages/process/src/plan/builder.ts`, `fluent.ts`  |
+| Plan — async sources    | `defineSource({ name, load })`, `createSourceRegistry()` / `SourceRegistry`, `sourceId`, `UnknownSourceError`; types `SourceRef`, `SourceParams`, `LoadedSource` (value + revision), `SourceLoadContext`, `SourceDef`                                                                                                                                                                                                                                                            | `packages/process/src/plan/source.ts`                |
+| Plan — folds            | `STANDARD_FOLDS` and the four it holds — `last`, `extremes`, `percentileRank`, `shape` — pre-registered by `createRegistry()`; each a plain `FoldDef`, so a consumer can `define` over one                                                                                                                                                                                                                                                                                       | `packages/process/src/plan/folds.ts`                 |
+| Errors                  | `ProcessError` (base; `code` — a stable per-class literal, minification-proof, also surfaced on `Skipped`), `CycleError`, `UnconnectedInputError`, `MissingOutputError`, `UnsetSourceError`                                                                                                                                                                                                                                                                                      | `packages/process/src/errors.ts`                     |
+| Node type helpers       | `NodeSpec`, `NodeFactory`, `InletsFor`, `OutletsFor`, `OutletValue`, `SpecsForOutlets`, `DerivedOutput`                                                                                                                                                                                                                                                                                                                                                                          | `packages/process/src/node.ts`                       |
 
 Note: this package's `npm test` includes a `test:dts` step that typechecks the
 **emitted** `dist/*.d.ts` from a consumer's perspective (`test-dts/`,

package/CHANGELOG.md

@@ -8,7 +8,8 @@ The `@pond-ts` packages — `pond-ts`, `@pond-ts/react`, `@pond-ts/charts`,
 under a single `v*` tag, so this file covers them all. Pre-1.0: minor bumps may
 include new features and type-level changes; patch bumps are strictly additive.
 
-[Unreleased]: https://github.com/pond-ts/pond/compare/v0.69.0...HEAD
+[Unreleased]: https://github.com/pond-ts/pond/compare/v0.70.0...HEAD
+[0.70.0]: https://github.com/pond-ts/pond/compare/v0.69.0...v0.70.0
 [0.69.0]: https://github.com/pond-ts/pond/compare/v0.68.0...v0.69.0
 [0.68.0]: https://github.com/pond-ts/pond/compare/v0.67.0...v0.68.0
 [0.67.0]: https://github.com/pond-ts/pond/compare/v0.66.0...v0.67.0
@@ -72,6 +73,71 @@ include new features and type-level changes; patch bumps are strictly additive.
 
 ## [Unreleased]
 
+## [0.70.0] — 2026-09-18
+
+### Added
+
+- `@pond-ts/charts`: **`<BandChart sessionBreaks>`** — the same trading-axis
+  session break `<LineChart>` has had since v0.45.0. On a discontinuous
+  (`discontinuities` / `calendar`) axis the fill previously ran a near-vertical
+  sliver from one session's last sample to the next session's first, because
+  the collapsed overnight gap put them a pixel apart; `sessionBreaks` ends the
+  envelope at the close and re-starts it at the open, so a band and its centre
+  line break in step. A **scale** break, orthogonal to the NaN **data** gaps a
+  band always breaks at; default `false` (unchanged output). Decimation
+  composes: `decimateBand` folds each break instant into the pixel-column
+  edges and bakes a `NaN` sample at it, so no column merges two sessions'
+  envelopes. Stories `Axes/TradingTimeAxis / SessionBreaksBand` and
+  `Performance/Decimation / TradingSessionBreaksBand`.
+- `@pond-ts/process`: **`ArityError`**, and **arity is now part of what `specId`
+  can judge**. A spec whose `inputs` count does not match the op's — including
+  one carrying no `inputs` at all — was named `p1:sma(;period=20)`, a _valid_
+  id for something that cannot compile, and then died at `compile` as a bare
+  `TypeError` reading `.length` of `undefined`, reaching the consumer as a
+  `Skipped` with **no `code`** (which under that contract means "op code
+  threw"). Arity is decidable from the registry alone, so strict `specId` now
+  raises `ArityError` and lenient mode marks the id `p1?:`.
+  `Registry.checkArity(op, inputs)` is the shared check `compile` uses too.
+
+### Changed
+
+- `@pond-ts/financial`: **`StudyOutput.id` documents the `@pond-ts/process`
+  bridge**, and a new `test/catalog-process.test.ts` pins it. The field is a
+  *financial column suffix*; process's `OutputDef.id` is a *process outlet
+  id*; they share a name and are different namespaces. Process names its own
+  columns (`specId + OutputDef.id`) and matches an op's return to its outputs
+  positionally, so a study's own column names never reach it — which means a
+  registry bridging the two chooses its own suffixes, and for the **twelve**
+  multi-output studies that claim the bare prefix (`trix`, `superTrend`,
+  `klinger`, …) it must: process rejects `''` on a multi-output op, because
+  there the column would be named exactly the spec id, itself a legal column
+  reference. The map is `outputs.length > 1 && id === ''` → `'value'` — not
+  `id === ''`, which would rename all seventy-odd single-output columns for
+  nothing. Reported by a consumer that hit the throw at module load and
+  worked around it by hand. No API change: the descriptors, the studies and
+  the guard are all unchanged, and the round-trip test is what stops the two
+  packages drifting — `catalog.test.ts` validates a descriptor against its
+  *study*, so it is structurally blind to a cross-package disagreement.
+- `@pond-ts/process`: **`Skipped.spec` echoes the request verbatim**, and its
+  `params` / `inputs` are typed `unknown` accordingly. The plan pass normalized
+  `params: null` to `{}`, so recomputing an id from the echo produced the
+  _defaulted spec's valid id_ — keying a broken persisted entry's report onto a
+  legitimate node. The selector pass echoed the original all along, so the two
+  passes disagreed. **Migration:** a consumer reading `entry.spec.params` now
+  narrows it (`entry.spec.params as Record<string, unknown>`, or a guard) —
+  which is the point, since the value may be exactly the malformed thing that
+  failed.
+- `@pond-ts/process`: `specId(…, { validate: false })` is **total over
+  arbitrary JSON**, not just over well-typed specs. `params: null`, a
+  non-array `inputs`, and an input entry that is neither a column name nor a
+  spec each used to raise a `TypeError`; they are now named in the `p1?:`
+  namespace, distinctly enough that two differently-broken specs stay two ids.
+  Strict mode reports them as `ParamError` / `ArityError` / `ProcessError`
+  rather than crashing.
+
+  (All three reported by Tidal against 0.62.0, after adopting it.)
+
+
 ## [0.69.0] — 2026-09-13
 
 ### Added

package/dist/index.d.ts

@@ -36,7 +36,7 @@ export { Graph } from './graph.js';
 export type { GraphEdge, GraphJson, GraphNodeJson, GraphEdgeJson, } from './graph.js';
 export { ProcessError, CycleError, UnconnectedInputError, MissingOutputError, } from './errors.js';
 export { createRegistry, Registry, int, num, choice, flag, } from './plan/registry.js';
-export { UnknownOpError, ParamError } from './plan/registry.js';
+export { UnknownOpError, ParamError, ArityError } from './plan/registry.js';
 export type { DefMap } from './plan/registry.js';
 export { isFold } from './plan/types.js';
 export { STANDARD_FOLDS, last, extremes, percentileRank, shape, } from './plan/folds.js';

package/dist/index.js

@@ -31,7 +31,7 @@ export { Graph } from './graph.js';
 export { ProcessError, CycleError, UnconnectedInputError, MissingOutputError, } from './errors.js';
 // ─── Plan layer ([PND-DEMOM0]) ──────────────────────────────────
 export { createRegistry, Registry, int, num, choice, flag, } from './plan/registry.js';
-export { UnknownOpError, ParamError } from './plan/registry.js';
+export { UnknownOpError, ParamError, ArityError } from './plan/registry.js';
 export { isFold } from './plan/types.js';
 export { STANDARD_FOLDS, last, extremes, percentileRank, shape, } from './plan/folds.js';
 export { specId, refToId, explain, unitOf, columnsOf, dependsOn, outputKey, } from './plan/identity.js';

package/dist/plan/graph.d.ts

@@ -142,8 +142,8 @@ export declare class BoundGraph {
      * one, nothing is ever evicted.
      *
      * Validation happens here rather than at pull time so a bad plan is
-     * rejected before any work: params first, then arity, then the typed
-     * input check.
+     * rejected before any work: the op must exist, then arity, then params
+     * (all three via strict `specId`), then the typed input check.
      */
     compile(spec: Spec): Compiled;
     /** Reads one output column of a compiled spec, by output suffix. */

package/dist/plan/graph.js

@@ -381,8 +381,8 @@ export class BoundGraph {
      * one, nothing is ever evicted.
      *
      * Validation happens here rather than at pull time so a bad plan is
-     * rejected before any work: params first, then arity, then the typed
-     * input check.
+     * rejected before any work: the op must exist, then arity, then params
+     * (all three via strict `specId`), then the typed input check.
      */
     compile(spec) {
         const id = specId(this.registry, spec);
@@ -413,9 +413,7 @@ export class BoundGraph {
         }
         const op = this.registry.get(spec.op);
         const params = this.registry.resolveParams(op, spec.params);
-        if (spec.inputs.length !== op.inputs.length) {
-            throw new ProcessError(`${spec.op} takes ${op.inputs.length} input(s), got ${spec.inputs.length}`);
-        }
+        this.registry.checkArity(op, spec.inputs);
         // After arity — an input index past the declared list is an arity
         // problem, not a column one — and before the typed-unit pass, whose
         // answer for an absent column is a misleading 'unitless'.

package/dist/plan/identity.d.ts

@@ -34,13 +34,13 @@
  *
  * Both are pinned by tests.
  */
-import type { Registry } from './registry.js';
+import { type Registry } from './registry.js';
 import type { Params, Spec, SpecRef, Units } from './types.js';
 /** Options for {@link specId}. */
 export interface SpecIdOptions {
     /**
-     * Whether the op must exist and its params must be legal — default
-     * `true`.
+     * Whether the op must exist, its params must be legal, and its
+     * `inputs` count must match the op's arity — default `true`.
      *
      * Pass `false` to name a spec that would not compile. See
      * {@link specId} for why identity is separable from validity.
@@ -70,8 +70,10 @@ export interface SpecIdOptions {
  *
  * So `specId(registry, spec, { validate: false })` is **total**: an
  * unknown op keeps its given params verbatim, a known one still gets
- * its defaults applied and its keys sorted, and nothing throws.
- * Validity stays `compile`'s job.
+ * its defaults applied and its keys sorted, and nothing throws — a
+ * malformed shape is **named** (marked `p1?:`), not rejected. Validity
+ * stays `compile`'s job, with one exception decidable from the registry
+ * alone: arity, which strict mode judges here too (`ArityError`).
  *
  * **A valid spec has one id under either mode.** Canonicalization is
  * the same code path and `checkParam` never coerces, so the lenient id

package/dist/plan/identity.js

@@ -34,6 +34,8 @@
  *
  * Both are pinned by tests.
  */
+import { ProcessError } from '../errors.js';
+import { ParamError } from './registry.js';
 import { isFold, isPicked, specOf } from './types.js';
 /** Id format version. Bumping it invalidates persisted ids deliberately. */
 const VERSION = 'p1';
@@ -51,6 +53,14 @@ function esc(v) {
  * after the version and can never equal one, whatever its params say.
  */
 const UNVALIDATED = '?';
+/**
+ * Key under which a malformed `params` or `inputs` value is recorded in
+ * an unvalidated id, so the shape it actually had survives.
+ *
+ * Only ever emitted inside a `p1?:` id, so it cannot be confused with a
+ * declared param — and it is escaped like any other key there.
+ */
+const MALFORMED = '!malformed';
 /**
  * Type-preserving encoding, used **only** inside an unvalidated id.
  *
@@ -93,8 +103,10 @@ function typedEsc(v) {
  *
  * So `specId(registry, spec, { validate: false })` is **total**: an
  * unknown op keeps its given params verbatim, a known one still gets
- * its defaults applied and its keys sorted, and nothing throws.
- * Validity stays `compile`'s job.
+ * its defaults applied and its keys sorted, and nothing throws — a
+ * malformed shape is **named** (marked `p1?:`), not rejected. Validity
+ * stays `compile`'s job, with one exception decidable from the registry
+ * alone: arity, which strict mode judges here too (`ArityError`).
  *
  * **A valid spec has one id under either mode.** Canonicalization is
  * the same code path and `checkParam` never coerces, so the lenient id
@@ -116,53 +128,129 @@ function typedEsc(v) {
 export function specId(registry, spec, options = {}) {
     return build(registry, spec, options.validate === false).id;
 }
-/** An id, and whether anything in its closure failed validation. */
+/** True for an object literal a spec's `params` could legally be. */
+function isParamBag(v) {
+    return typeof v === 'object' && v !== null && !Array.isArray(v);
+}
+/** True for an input that is a nested spec or a picked output. */
+function isSpecLike(v) {
+    return (typeof v === 'object' &&
+        v !== null &&
+        ('op' in v || 'from' in v) &&
+        !Array.isArray(v));
+}
+/**
+ * An id, and whether anything in its closure failed validation.
+ *
+ * **Totality is over arbitrary JSON, not over well-typed `Spec`s.** The
+ * whole reason a consumer reaches for leniency is a persisted object
+ * that no longer fits — a dropped `inputs` key, a `null` where a param
+ * bag belongs, an input that came back as a bare `null`. Answering those
+ * with a `TypeError` is the same failure as throwing `ParamError`, one
+ * layer down, so each malformed shape is **named** here rather than
+ * crashed on: marked unvalidated, and encoded distinctly enough that two
+ * differently-broken specs stay two ids (Tidal, on 0.62.0).
+ */
 function build(registry, spec, lenient) {
     let unvalidated = false;
-    // Inputs first: a nested spec that did not validate marks this one,
-    // and the mark has to be known before the params are encoded.
-    //
-    // `?? []` because a spec arriving from persistence may be missing the
-    // field entirely, and a mode whose promise is totality cannot answer a
-    // dropped key with a TypeError. Strict mode reaches `compile`'s arity
-    // check instead, which says what is actually wrong.
-    const inputs = (spec.inputs ?? [])
+    const bad = () => {
+        unvalidated = true;
+    };
+    // The op first, because arity needs it. An unknown op under leniency
+    // leaves `op` undefined and nothing further is decidable about params
+    // or arity — both are declared BY the definition.
+    const op = lenient && !registry.has(spec.op) ? undefined : registry.get(spec.op);
+    if (op === undefined)
+        bad();
+    // Arity is part of validity, and decidable from the registry alone —
+    // so a spec that fails it must not be named in the valid namespace.
+    // It used to be checked only at `compile`, which meant `p1:sma(;…)`
+    // named a spec that could not exist, and then `compile` read `.length`
+    // off `undefined` and raised a codeless `TypeError` (Tidal, 0.62.0).
+    if (op !== undefined) {
+        try {
+            registry.checkArity(op, spec.inputs);
+        }
+        catch (e) {
+            if (!lenient)
+                throw e;
+            bad();
+        }
+    }
+    // Inputs next: a nested spec that did not validate marks this one, and
+    // the mark has to be known before the params are encoded.
+    const rawInputs = Array.isArray(spec.inputs)
+        ? spec.inputs
+        : spec.inputs === undefined
+            ? // The key was dropped. Reads as an empty input list, which is
+                // what it is — the arity check above has already marked it.
+                (bad(), [])
+            : // Present but not a list. Encoded as one token so the shape it
+                // actually had survives rather than being flattened to "empty".
+                (bad(), [{ [MALFORMED]: spec.inputs }]);
+    const inputs = rawInputs
         .map((i) => {
         if (typeof i === 'string')
             return esc(i);
-        // `#Lower` rather than a separate field: an input picking a
-        // different output is a different computation, and the id is what
-        // says so.
-        const base = build(registry, specOf(i), lenient);
-        if (base.unvalidated)
-            unvalidated = true;
-        return isPicked(i) ? `${base.id}#${esc(i.output)}` : base.id;
+        if (isSpecLike(i)) {
+            // `#Lower` rather than a separate field: an input picking a
+            // different output is a different computation, and the id is
+            // what says so.
+            const base = build(registry, specOf(i), lenient);
+            if (base.unvalidated)
+                unvalidated = true;
+            return isPicked(i)
+                ? `${base.id}#${esc(i.output)}`
+                : base.id;
+        }
+        // Neither a column name nor a spec — `null`, a number, an array.
+        if (!lenient) {
+            throw new ProcessError(`input of '${spec.op}' must be a column name or a spec, got ${JSON.stringify(i) ?? typeof i}`);
+        }
+        bad();
+        // A non-array `inputs` was wrapped above so its shape survives; keep
+        // the marker in the token, or `{ inputs: null }` and `{ inputs: [null] }`
+        // would mint the same id — two differently-broken specs, one chip.
+        return isParamBag(i) && MALFORMED in i
+            ? esc(`${MALFORMED}:${typeof i[MALFORMED]}:${String(i[MALFORMED])}`)
+            : typedEsc(i);
     })
         .join('+');
-    let params;
-    if (lenient && !registry.has(spec.op)) {
-        unvalidated = true;
-        params = spec.params ?? {};
+    // Params last, so the mark is settled before they are encoded.
+    let entries;
+    if (op === undefined) {
+        entries = Object.entries(isParamBag(spec.params) ? spec.params : {});
+        if (spec.params !== undefined && !isParamBag(spec.params)) {
+            bad();
+            entries = [[MALFORMED, spec.params]];
+        }
+    }
+    else if (spec.params !== undefined && !isParamBag(spec.params)) {
+        // `resolveParams` would read keys off it and throw a `TypeError`.
+        if (!lenient) {
+            throw new ParamError(`${spec.op} params must be an object, got ${JSON.stringify(spec.params) ?? typeof spec.params}`);
+        }
+        bad();
+        entries = [[MALFORMED, spec.params]];
     }
     else {
-        const op = registry.get(spec.op);
         try {
             // The strict resolve first even under leniency: when it succeeds
             // the id is byte-identical to the validating one, which is the
             // whole contract. Only its failure moves this spec into the
             // unvalidated namespace.
-            params = registry.resolveParams(op, spec.params);
+            entries = Object.entries(registry.resolveParams(op, spec.params));
         }
         catch (e) {
             if (!lenient)
                 throw e;
-            unvalidated = true;
-            params = registry.resolveParams(op, spec.params, { validate: false });
+            bad();
+            entries = Object.entries(registry.resolveParams(op, spec.params, { validate: false }));
         }
     }
     const encodeKey = unvalidated ? esc : (k) => k;
     const encodeValue = unvalidated ? typedEsc : esc;
-    const p = Object.entries(params)
+    const p = entries
         .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))
         .map(([k, v]) => `${encodeKey(k)}=${encodeValue(v)}`)
         .join(',');

package/dist/plan/registry.d.ts

@@ -32,6 +32,22 @@ export declare class UnknownOpError extends ProcessError {
 export declare class ParamError extends ProcessError {
     static readonly code: string;
 }
+/**
+ * Thrown when a spec's input list does not match the op's declared
+ * arity — including a spec carrying no `inputs` at all.
+ *
+ * Its own class because arity is decidable from the **registry alone**,
+ * with no data bound: it is part of what `specId` can judge, and a spec
+ * that fails it must not be named in the valid id namespace. Before
+ * this, a spec with no `inputs` was named `p1:sma(;period=20)` — a valid
+ * id for something that cannot compile — and then died at `compile` as a
+ * bare `TypeError` reading `.length` of undefined, reaching the consumer
+ * as a `Skipped` with no `code` at all, which under that contract means
+ * "op code threw" (Tidal, on 0.62.0).
+ */
+export declare class ArityError extends ProcessError {
+    static readonly code: string;
+}
 /** Op metadata as a picker or a tool catalog wants it. */
 export interface OpDescriptor {
     readonly name: string;
@@ -103,6 +119,14 @@ export declare class Registry<Defs extends DefMap = {}> {
     resolveParams(op: Def, given?: Readonly<Record<string, ParamValue>>, options?: {
         validate?: boolean;
     }): Params;
+    /**
+     * Checks a spec's input list against the op's declared arity.
+     *
+     * Lives here beside `get` and `resolveParams` — the three things
+     * decidable about a spec from the definition alone, before any data is
+     * bound — so `specId` and `compile` ask the same question once.
+     */
+    checkArity(op: Def, inputs: unknown): void;
     /** Grouped for a picker. */
     byFamily(): Map<string, OpDescriptor[]>;
     describe(): OpDescriptor[];

package/dist/plan/registry.js

@@ -24,6 +24,22 @@ export class UnknownOpError extends ProcessError {
 export class ParamError extends ProcessError {
     static code = 'ParamError';
 }
+/**
+ * Thrown when a spec's input list does not match the op's declared
+ * arity — including a spec carrying no `inputs` at all.
+ *
+ * Its own class because arity is decidable from the **registry alone**,
+ * with no data bound: it is part of what `specId` can judge, and a spec
+ * that fails it must not be named in the valid id namespace. Before
+ * this, a spec with no `inputs` was named `p1:sma(;period=20)` — a valid
+ * id for something that cannot compile — and then died at `compile` as a
+ * bare `TypeError` reading `.length` of undefined, reaching the consumer
+ * as a `Skipped` with no `code` at all, which under that contract means
+ * "op code threw" (Tidal, on 0.62.0).
+ */
+export class ArityError extends ProcessError {
+    static code = 'ArityError';
+}
 /**
  * Validates one param and returns it.
  *
@@ -206,6 +222,22 @@ export class Registry {
         }
         return out;
     }
+    /**
+     * Checks a spec's input list against the op's declared arity.
+     *
+     * Lives here beside `get` and `resolveParams` — the three things
+     * decidable about a spec from the definition alone, before any data is
+     * bound — so `specId` and `compile` ask the same question once.
+     */
+    checkArity(op, inputs) {
+        const want = op.inputs.length;
+        if (!Array.isArray(inputs)) {
+            throw new ArityError(`${op.name} takes ${want} input(s), got none — 'inputs' is ${inputs === undefined ? 'missing' : (JSON.stringify(inputs) ?? 'unset')}`);
+        }
+        if (inputs.length !== want) {
+            throw new ArityError(`${op.name} takes ${want} input(s), got ${inputs.length}`);
+        }
+    }
     /** Grouped for a picker. */
     byFamily() {
         const out = new Map();

package/dist/plan/run.d.ts

@@ -20,7 +20,7 @@
 import type { Column, SeriesSchema, TimeSeries } from 'pond-ts';
 import type { BoundGraph } from './graph.js';
 import { type Slots } from './slots.js';
-import type { Input, Plan, SpecRef } from './types.js';
+import type { Plan, SpecRef } from './types.js';
 /** What to do when a spec or a selector fails. Covers both, not just resolution. */
 export type ErrorPolicy = 'throw' | 'skip' | 'collect';
 /**
@@ -160,14 +160,22 @@ export interface NodeTiming {
 }
 export interface Skipped {
     /**
-     * The spec that failed, echoed back — including `inputs`, because a
-     * plan may hold two specs of the same op and a caller retrying needs
-     * to know which one it was.
+     * The spec that failed, echoed back **verbatim** — including `inputs`,
+     * because a plan may hold two specs of the same op and a caller
+     * retrying needs to know which one it was.
+     *
+     * `params` and `inputs` are typed `unknown` because this is an echo of
+     * whatever arrived, and what arrives is exactly what may be malformed.
+     * The plan pass used to normalize — `params: null` came back as `{}` —
+     * which was not merely lossy: recomputing an id from the echo then
+     * produced the **defaulted spec's valid id**, so a broken persisted
+     * entry's report keyed onto a legitimate node (Tidal, on 0.62.0). The
+     * selector pass echoed the original all along, so the two disagreed.
      */
     readonly spec?: {
         op: string;
-        params: Record<string, unknown>;
-        inputs: readonly Input[];
+        params?: unknown;
+        inputs?: unknown;
     };
     readonly select?: Select;
     readonly reason: string;

package/dist/plan/run.js

@@ -127,11 +127,7 @@ export function run(graph, request) {
         }
         catch (e) {
             fail(e, {
-                spec: {
-                    op: spec.op,
-                    params: { ...(spec.params ?? {}) },
-                    inputs: spec.inputs,
-                },
+                spec: { op: spec.op, params: spec.params, inputs: spec.inputs },
             });
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pond-ts/process",
-  "version": "0.69.0",
+  "version": "0.70.0",
   "description": "Computations as data over pond-ts: processing graphs authored fluently or composed as JSON, resolved against a declared op vocabulary with content-addressed caching, provenance, and per-node timings. Experimental, pre-1.0.",
   "keywords": [
     "time-series",
@@ -62,7 +62,7 @@
     "verify": "npm run format:check && npm run build && npm test"
   },
   "peerDependencies": {
-    "pond-ts": "^0.69.0"
+    "pond-ts": "^0.70.0"
   },
   "devDependencies": {
     "typescript": "^5.6.3",