@pond-ts/process 0.54.0

package/dist/column.js

@@ -0,0 +1,306 @@
+/**
+ * Column-valued node support — [PND-PROCCOL].
+ *
+ * An op computes a study by calling into the corpus, which returns a
+ * `TimeSeries` whose new column is already **packed** (a `Float64Array`
+ * plus a validity bitmap). The obvious adapter then unpacks that into a
+ * boxed `Array<number | undefined>` to use as the node's value. Keeping
+ * the `Column` instead is worth doing for **memory and sizeability**: 20
+ * SMAs over 500k rows cost 271 MB of GC-managed heap boxed versus 42 MB
+ * as columns (rss 466 MB vs 353 MB — the bytes move to `arrayBuffers`
+ * rather than vanish).
+ *
+ * It is **not** worth doing for read throughput, which measurement
+ * contradicted: folding a max over 500k cells took 0.91 ms over the boxed
+ * array, 0.96 ms walking the buffer plus validity bits, and 4.27 ms via
+ * `Column.scan()` — whose per-cell callback costs more than either. A
+ * reduction on a hot path should walk `toFloat64Array()` and the bits
+ * directly rather than call `scan`.
+ *
+ * What that needs, and pond does not expose, is here:
+ *
+ * - {@link columnBytes} — a value's retained size, so a cache budget can
+ *   be expressed in bytes rather than entries ([PND-PROCCACHE]).
+ * - {@link packColumn} — build a packed column from loose values, for an
+ *   op whose kernel hands back an array.
+ * - {@link appendColumn} — put a column back onto a series for the
+ *   renderer path, avoiding the round trip where the column is gapless.
+ * - {@link columnBuffers} / {@link columnFromBuffers} — the buffer pair a
+ *   column *is*, for moving one across an isolate boundary
+ *   ([PND-PROCPAR]).
+ */
+import { Float64Column } from 'pond-ts';
+/** Bytes a validity bitmap needs for `length` cells. */
+function bitmapByteCount(length) {
+    return Math.ceil(length / 8);
+}
+/**
+ * A `ValidityBitmap` built outside core.
+ *
+ * The interface is structural — `bits` / `length` / `definedCount` /
+ * `isDefined` / `countInRange`, all public — so a producer can implement
+ * it without reaching into `pond-ts`'s internals. Core's own factory
+ * (`createValidityBitmap`) is deliberately not exported; this is the
+ * supported way to construct one from outside.
+ */
+class PackedValidity {
+    bits;
+    length;
+    definedCount;
+    constructor(bits, length, definedCount) {
+        this.bits = bits;
+        this.length = length;
+        this.definedCount = definedCount;
+    }
+    isDefined(i) {
+        if (i < 0 || i >= this.length)
+            return false;
+        return (this.bits[i >> 3] & (1 << (i & 7))) !== 0;
+    }
+    countInRange(start, end) {
+        const lo = Math.max(0, start);
+        const hi = Math.min(this.length, end);
+        let n = 0;
+        for (let i = lo; i < hi; i += 1)
+            if (this.isDefined(i))
+                n += 1;
+        return n;
+    }
+}
+/**
+ * Retained size of a column value, in bytes.
+ *
+ * Approximate by construction — it counts the backing buffers a packed
+ * column owns, which is what a cache budget is actually trying to bound,
+ * and ignores per-object overhead. A chunked column reports the sum of
+ * its chunks. A column whose kind this cannot size returns `0` rather
+ * than guessing, so a budget treats it as free instead of evicting on a
+ * fabricated number.
+ *
+ * Bytes rather than entries is the point: a 500k-row result and a scalar
+ * both count as one entry, and only one of them matters.
+ */
+export function columnBytes(column) {
+    const anyColumn = column;
+    // The aggregate bitmap's REAL bytes, not the minimum its cell count
+    // implies: a bitmap over a larger buffer retains that buffer.
+    const validity = anyColumn.validity;
+    const validityBytes = validity === undefined
+        ? 0
+        : (validity.bits?.length ?? bitmapByteCount(validity.length));
+    // A chunked column owns no value buffer of its own — its bytes are its
+    // chunks' (each a packed column, sized recursively) plus the aggregate
+    // validity bitmap and the chunk-offset index built at construction.
+    // Reading `_values` here returned 0 for every chunked column, while
+    // the doc above promised the sum — an undercount a byte budget would
+    // treat as free.
+    const chunks = anyColumn.chunks;
+    if (Array.isArray(chunks)) {
+        const offsets = anyColumn.chunkOffsets;
+        let total = validityBytes +
+            (offsets === undefined
+                ? 0
+                : offsets.length * (offsets.BYTES_PER_ELEMENT ?? 4));
+        for (const chunk of chunks)
+            total += columnBytes(chunk);
+        return total;
+    }
+    const values = anyColumn._values;
+    if (values === undefined)
+        return 0;
+    const perElement = values.BYTES_PER_ELEMENT ?? 8;
+    // The BACKING buffer's capacity, not the column's logical length — a
+    // one-row column viewing an 8 MB buffer retains 8 MB, and sizing it
+    // at 8 bytes is exactly the undercount that defeats a byte budget.
+    return values.length * perElement + validityBytes;
+}
+/**
+ * Packs loose values into a `Float64Column`.
+ *
+ * For an op whose kernel returns an array — the financial kernels are
+ * array-out (`rollingValues`, `emaValues`) — this confines the boxing to
+ * one pass, instead of the boxed array being retained as the node value.
+ *
+ * `NaN` is treated as **missing**, matching what a study's warm-up
+ * means, and never packed as a defined cell: core's reducer non-finite
+ * policy requires that a column flagged `allFinite` contain no `NaN`,
+ * and a wrongly-set flag makes reducers take an unguarded path and
+ * silently return a wrong result. `allFinite` is therefore computed by
+ * inspecting every defined cell, not assumed.
+ */
+export function packColumn(values) {
+    const length = values.length;
+    const buffer = new Float64Array(length);
+    const bits = new Uint8Array(bitmapByteCount(length));
+    let defined = 0;
+    let allFinite = true;
+    for (let i = 0; i < length; i += 1) {
+        const v = values[i];
+        if (v === undefined || v === null || Number.isNaN(v))
+            continue;
+        buffer[i] = v;
+        bits[i >> 3] |= 1 << (i & 7);
+        defined += 1;
+        if (!Number.isFinite(v))
+            allFinite = false;
+    }
+    // No gaps: omit the bitmap entirely rather than carry an all-ones one.
+    // A gapless column is also the case `appendColumn` can round-trip
+    // without boxing, so this is worth detecting.
+    if (defined === length)
+        return new Float64Column(buffer, length, undefined, allFinite);
+    return new Float64Column(buffer, length, new PackedValidity(bits, length, defined), allFinite);
+}
+/**
+ * Appends a column to a series under `name` — the renderer path, where a
+ * caller genuinely wants one `TimeSeries` carrying several studies.
+ *
+ * **A gapless column round-trips without boxing**, via the column's own
+ * `Float64Array`. A column *with* gaps cannot: core's `withColumn` takes
+ * values, not a column, and rejects a non-finite cell, so a warm-up has
+ * to be expressed as `undefined` in a boxed array. Core appends columns
+ * directly internally (`withColumnAppended`) but does not expose it;
+ * until it does, a gapped column pays one boxing pass here.
+ *
+ * Since most studies have a warm-up, that fallback is the common case —
+ * which is exactly why assembly should be requested rather than assumed
+ * ([PND-PROCTERM]). A facts-only request never calls this.
+ */
+export function appendColumn(series, name, column) {
+    if (column.length !== series.length) {
+        throw new RangeError(`appendColumn '${name}': column length ${column.length} does not match series length ${series.length}`);
+    }
+    const wide = series;
+    const packed = column;
+    if (packed.validity === undefined &&
+        typeof packed.toFloat64Array === 'function') {
+        return wide.withColumn(name, packed.toFloat64Array());
+    }
+    const boxed = new Array(column.length);
+    for (let i = 0; i < column.length; i += 1) {
+        const v = column.at(i);
+        boxed[i] = v === undefined || Number.isNaN(v) ? undefined : v;
+    }
+    return wide.withColumn(name, boxed);
+}
+export function columnBuffers(column) {
+    const packed = column;
+    if (packed.kind !== 'number' || packed.storage !== 'packed')
+        return undefined;
+    const values = packed._values;
+    if (!(values instanceof Float64Array))
+        return undefined;
+    const length = packed.length;
+    const validity = packed.validity;
+    return {
+        length,
+        // `slice`, not `subarray`: the result is transferred, and transferring
+        // a view detaches the buffer it borrows from — here, the live memo.
+        values: values.slice(0, length),
+        ...(validity === undefined
+            ? {}
+            : { bits: validity.bits.slice(0, bitmapByteCount(length)) }),
+        definedCount: validity === undefined ? length : validity.definedCount,
+        allFinite: packed.allFinite ?? false,
+    };
+}
+/** Rebuilds a column from {@link columnBuffers}, adopting both buffers. */
+export function columnFromBuffers(wire) {
+    return new Float64Column(wire.values, wire.length, wire.bits === undefined
+        ? undefined
+        : new PackedValidity(wire.bits, wire.length, wire.definedCount), wire.allFinite);
+}
+export function columnView(column) {
+    const packed = column;
+    if (packed.kind !== 'number' || packed.storage !== 'packed')
+        return undefined;
+    const values = packed._values;
+    if (!(values instanceof Float64Array))
+        return undefined;
+    const length = packed.length;
+    const validity = packed.validity;
+    const view = values.subarray(0, length);
+    if (validity === undefined) {
+        return {
+            length,
+            values: view,
+            definedCount: length,
+            defined: () => true,
+            at: (i) => (i >= 0 && i < length ? view[i] : undefined),
+        };
+    }
+    const bits = validity.bits;
+    // LSB-first, one bit per cell — pond's layout, and Arrow's.
+    const defined = (i) => i >= 0 && i < length && (bits[i >> 3] & (1 << (i & 7))) !== 0;
+    return {
+        length,
+        values: view,
+        bits,
+        definedCount: validity.definedCount,
+        defined,
+        at: (i) => (defined(i) ? view[i] : undefined),
+    };
+}
+/** Bytes needed for `length` validity bits. */
+export function validityByteCount(length) {
+    return (length + 7) >> 3;
+}
+/**
+ * Prepares a {@link RangeOutput} of `length`, carrying `[0, keep)` from
+ * `prior` — a `Float64Array.set` for the values and a byte-wise copy for
+ * the bitmap, with the straddling byte masked.
+ */
+export function prepareRange(length, keep, prior) {
+    const values = new Float64Array(length);
+    const bits = new Uint8Array(validityByteCount(length));
+    // Clamped to `length` as well as to the prior: a series that SHRANK
+    // gives `keep > length`, and `values.set` then throws
+    // `RangeError: offset is out of bounds` before the op ever runs.
+    const copy = prior === undefined ? 0 : Math.min(keep, prior.length, length);
+    if (prior !== undefined && copy > 0) {
+        values.set(prior.values.subarray(0, copy));
+        if (prior.bits === undefined) {
+            // No bitmap ⇒ every prior cell was defined.
+            for (let i = 0; i < copy; i += 1)
+                bits[i >> 3] |= 1 << (i & 7);
+        }
+        else {
+            const whole = copy >> 3;
+            bits.set(prior.bits.subarray(0, whole));
+            // The byte straddling `copy` carries bits past it that belong to
+            // rows this range is about to rewrite — mask them off.
+            const rest = copy & 7;
+            if (rest !== 0)
+                bits[whole] = prior.bits[whole] & ((1 << rest) - 1);
+        }
+    }
+    return {
+        values,
+        bits,
+        set(i, v) {
+            values[i] = v;
+            bits[i >> 3] |= 1 << (i & 7);
+        },
+        clear(i) {
+            values[i] = 0;
+            bits[i >> 3] &= ~(1 << (i & 7));
+        },
+    };
+}
+/** Seals a {@link RangeOutput} into a column, counting validity once. */
+export function sealRange(out, length) {
+    const bits = out.bits;
+    let defined = 0;
+    let allFinite = true;
+    for (let i = 0; i < length; i += 1) {
+        if ((bits[i >> 3] & (1 << (i & 7))) === 0)
+            continue;
+        defined += 1;
+        if (!Number.isFinite(out.values[i]))
+            allFinite = false;
+    }
+    if (defined === length)
+        return new Float64Column(out.values, length, undefined, allFinite);
+    return new Float64Column(out.values, length, new PackedValidity(bits, length, defined), allFinite);
+}
+//# sourceMappingURL=column.js.map

package/dist/errors.d.ts

@@ -0,0 +1,22 @@
+/** Errors thrown by the graph engine. */
+/** Base class for every error this package throws. */
+export declare class ProcessError extends Error {
+    constructor(message: string);
+}
+/**
+ * Thrown by `connect()` when the edge would close a cycle. The graph is
+ * kept acyclic by construction rather than detected during evaluation,
+ * so a cycle surfaces at the line that wires it, not at some later pull.
+ */
+export declare class CycleError extends ProcessError {
+}
+/** Thrown when pulling through an inlet with no connection and no default. */
+export declare class UnconnectedInputError extends ProcessError {
+}
+/**
+ * Thrown when a node's `compute` omits a declared output, or when an
+ * outlet is read before anything has produced a value for it.
+ */
+export declare class MissingOutputError extends ProcessError {
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.js

@@ -0,0 +1,25 @@
+/** Errors thrown by the graph engine. */
+/** Base class for every error this package throws. */
+export class ProcessError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = new.target.name;
+    }
+}
+/**
+ * Thrown by `connect()` when the edge would close a cycle. The graph is
+ * kept acyclic by construction rather than detected during evaluation,
+ * so a cycle surfaces at the line that wires it, not at some later pull.
+ */
+export class CycleError extends ProcessError {
+}
+/** Thrown when pulling through an inlet with no connection and no default. */
+export class UnconnectedInputError extends ProcessError {
+}
+/**
+ * Thrown when a node's `compute` omits a declared output, or when an
+ * outlet is read before anything has produced a value for it.
+ */
+export class MissingOutputError extends ProcessError {
+}
+//# sourceMappingURL=errors.js.map

package/dist/graph.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Graph-level inspection: enumerate what's wired to what, get a
+ * topological order, dump the structure.
+ *
+ * Nodes work standalone — connections live on the ports, and evaluation
+ * never consults a container. `Graph` is a read-only view over an
+ * already-wired set of nodes, for the cases where you need the whole
+ * picture: rendering a node editor, logging evaluation order, asserting
+ * on structure in tests.
+ */
+import type { Inlet, Outlet } from './port.js';
+import type { Node } from './node.js';
+/** One connection between two nodes. */
+export interface GraphEdge {
+    readonly from: Outlet<any>;
+    readonly to: Inlet<any>;
+}
+/** Serialized form of one node. Structure only — no values. */
+export interface GraphNodeJson {
+    readonly id: string;
+    readonly kind: string;
+    readonly inputs: readonly string[];
+    readonly outputs: readonly string[];
+}
+/** Serialized form of one edge, by node id and port name. */
+export interface GraphEdgeJson {
+    readonly from: {
+        readonly node: string;
+        readonly port: string;
+    };
+    readonly to: {
+        readonly node: string;
+        readonly port: string;
+    };
+}
+/** Structural dump of a graph. See {@link Graph.toJSON}. */
+export interface GraphJson {
+    readonly nodes: readonly GraphNodeJson[];
+    readonly edges: readonly GraphEdgeJson[];
+}
+/** A read-only view over a wired set of nodes. */
+export declare class Graph {
+    #private;
+    constructor(nodes: Iterable<Node<any, any>>);
+    /**
+     * Discovers every node reachable from `roots`, following connections
+     * in both directions.
+     *
+     * ```ts
+     * const graph = Graph.from(sink);
+     * graph.order().map((node) => node.kind);
+     * ```
+     */
+    static from(...roots: readonly Node<any, any>[]): Graph;
+    /** Every node in the graph, in discovery order. */
+    get nodes(): readonly Node<any, any>[];
+    /**
+     * Every connection, grouped by producing node in {@link order}. Like
+     * `order()`, the result is independent of how the graph was
+     * discovered.
+     */
+    edges(): readonly GraphEdge[];
+    /**
+     * Nodes in dependency order — every node appears after the nodes
+     * feeding it. Evaluation doesn't need this (pulling is recursive and
+     * finds its own order); it's for display and for reasoning about a
+     * graph you didn't build.
+     *
+     * The DFS is seeded in node-id order rather than discovery order, so
+     * the result depends only on which nodes are in the graph — not on
+     * which node `Graph.from` happened to start from. Several topological
+     * orders are usually valid; this picks the same one every time.
+     */
+    order(): readonly Node<any, any>[];
+    /**
+     * Structural dump: node ids, kinds, port names, and edges.
+     *
+     * Nodes come out in {@link order}, not discovery order, so the dump of
+     * a given graph is the same whichever node `Graph.from` started at —
+     * which is what makes it safe to diff two dumps against each other.
+     *
+     * This is a **description, not a serialization** — there is no
+     * `fromJSON`. Rebuilding a graph from JSON needs a registry mapping
+     * `kind` to a factory, plus per-node config in the dump; neither
+     * exists yet. Use this for inspection, diffing, and rendering.
+     */
+    toJSON(): GraphJson;
+}
+//# sourceMappingURL=graph.d.ts.map

package/dist/graph.js

@@ -0,0 +1,133 @@
+/**
+ * Graph-level inspection: enumerate what's wired to what, get a
+ * topological order, dump the structure.
+ *
+ * Nodes work standalone — connections live on the ports, and evaluation
+ * never consults a container. `Graph` is a read-only view over an
+ * already-wired set of nodes, for the cases where you need the whole
+ * picture: rendering a node editor, logging evaluation order, asserting
+ * on structure in tests.
+ */
+/** A read-only view over a wired set of nodes. */
+export class Graph {
+    #nodes;
+    constructor(nodes) {
+        this.#nodes = [...new Set(nodes)];
+    }
+    /**
+     * Discovers every node reachable from `roots`, following connections
+     * in both directions.
+     *
+     * ```ts
+     * const graph = Graph.from(sink);
+     * graph.order().map((node) => node.kind);
+     * ```
+     */
+    static from(...roots) {
+        const seen = new Set();
+        const queue = [...roots];
+        while (queue.length > 0) {
+            const node = queue.shift();
+            if (seen.has(node))
+                continue;
+            seen.add(node);
+            for (const inlet of node.inletList()) {
+                const upstream = inlet.source;
+                if (upstream !== undefined)
+                    queue.push(upstream.node);
+            }
+            for (const outlet of node.outletList()) {
+                for (const inlet of outlet.connections)
+                    queue.push(inlet.node);
+            }
+        }
+        return new Graph(seen);
+    }
+    /** Every node in the graph, in discovery order. */
+    get nodes() {
+        return this.#nodes;
+    }
+    /**
+     * Every connection, grouped by producing node in {@link order}. Like
+     * `order()`, the result is independent of how the graph was
+     * discovered.
+     */
+    edges() {
+        const edges = [];
+        for (const node of this.order()) {
+            for (const outlet of node.outletList()) {
+                const consumers = [...outlet.connections].sort((a, b) => byId(a.node, b.node));
+                for (const inlet of consumers)
+                    edges.push({ from: outlet, to: inlet });
+            }
+        }
+        return edges;
+    }
+    /**
+     * Nodes in dependency order — every node appears after the nodes
+     * feeding it. Evaluation doesn't need this (pulling is recursive and
+     * finds its own order); it's for display and for reasoning about a
+     * graph you didn't build.
+     *
+     * The DFS is seeded in node-id order rather than discovery order, so
+     * the result depends only on which nodes are in the graph — not on
+     * which node `Graph.from` happened to start from. Several topological
+     * orders are usually valid; this picks the same one every time.
+     */
+    order() {
+        const known = new Set(this.#nodes);
+        const visited = new Set();
+        const ordered = [];
+        const seeds = [...this.#nodes].sort(byId);
+        const visit = (node) => {
+            if (visited.has(node))
+                return;
+            visited.add(node);
+            for (const inlet of node.inletList()) {
+                const upstream = inlet.source?.node;
+                // Skip dependencies outside this graph — `order()` sorts the
+                // nodes it was given, it doesn't silently widen the set.
+                if (upstream !== undefined && known.has(upstream))
+                    visit(upstream);
+            }
+            ordered.push(node);
+        };
+        for (const node of seeds)
+            visit(node);
+        return ordered;
+    }
+    /**
+     * Structural dump: node ids, kinds, port names, and edges.
+     *
+     * Nodes come out in {@link order}, not discovery order, so the dump of
+     * a given graph is the same whichever node `Graph.from` started at —
+     * which is what makes it safe to diff two dumps against each other.
+     *
+     * This is a **description, not a serialization** — there is no
+     * `fromJSON`. Rebuilding a graph from JSON needs a registry mapping
+     * `kind` to a factory, plus per-node config in the dump; neither
+     * exists yet. Use this for inspection, diffing, and rendering.
+     */
+    toJSON() {
+        return {
+            nodes: this.order().map((node) => ({
+                id: node.id,
+                kind: node.kind,
+                inputs: node.inletList().map((inlet) => inlet.name),
+                outputs: node.outletList().map((outlet) => outlet.name),
+            })),
+            edges: this.edges().map((edge) => ({
+                from: { node: edge.from.node.id, port: edge.from.name },
+                to: { node: edge.to.node.id, port: edge.to.name },
+            })),
+        };
+    }
+}
+/**
+ * Orders nodes by creation sequence. Node ids are `n1`, `n2`, … so a
+ * plain string sort would put `n10` before `n2`; compare numerically.
+ */
+function byId(a, b) {
+    return a.id.localeCompare(b.id, undefined, { numeric: true });
+}
+//# sourceMappingURL=graph.js.map

package/dist/index.d.ts

@@ -0,0 +1,59 @@
+/**
+ * `@pond-ts/process` — a typed dataflow graph over pond values.
+ *
+ * Where the rest of pond is chain-first (`series.rolling(...).aggregate(...)`),
+ * this package is for the case chaining can't express: when the pipeline
+ * itself is **data** — assembled at runtime, reshaped by a user, rendered
+ * as a node editor, or shared as one computation with several outputs.
+ *
+ * The chain API remains the primary way to use pond. Reach for a graph
+ * only when the topology isn't known at authoring time.
+ *
+ * ```ts
+ * import { source, derive } from '@pond-ts/process';
+ *
+ * const raw = source<TimeSeries<Schema>>();
+ * const hourly = derive({ s: raw.out.value }, ({ s }) =>
+ *   s.aggregate(Sequence.every('1h'), { cpu: 'avg' }),
+ * );
+ *
+ * raw.set(series);
+ * hourly.out.value.get();
+ * ```
+ */
+export { Inlet, Outlet } from './port.js';
+export { Node, defineNode, derive } from './node.js';
+export type { NodeSpec, NodeFactory, InletsFor, OutletsFor, OutletValue, SpecsForOutlets, DerivedOutput, } from './node.js';
+export { port } from './types.js';
+export type { PortSpec, PortSpecMap, PortValue, PortValues } from './types.js';
+export { source, fromLive, SourceNode, LiveSourceNode, UnsetSourceError, } from './source.js';
+export type { NoInputs, GraphSource, SnapshotSource } from './source.js';
+export { columnBytes, packColumn, appendColumn, columnBuffers, columnFromBuffers, columnView, prepareRange, sealRange, validityByteCount, } from './column.js';
+export type { ColumnBuffers, ColumnView, RangeOutput } from './column.js';
+export { requiredHistory } from './plan/history.js';
+export type { HistoryResult } from './plan/history.js';
+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 type { DefMap } from './plan/registry.js';
+export { isFold } from './plan/types.js';
+export { STANDARD_FOLDS, last, extremes, percentileRank, shape, } from './plan/folds.js';
+export type { OpDescriptor } from './plan/registry.js';
+export { specId, refToId, explain, unitOf, columnsOf, dependsOn, outputKey, } from './plan/identity.js';
+export { bind, BoundGraph, UnitError } from './plan/graph.js';
+export { expandSlots, SlotError } from './plan/slots.js';
+export { plan, PlanBuilder, BuilderError } from './plan/builder.js';
+export type { NodeHandle, OutputHandle, InputRef, BuiltRequest, } from './plan/builder.js';
+export { process, ProcessBuilder } from './plan/fluent.js';
+export type { BuildOptions, FluentColumnRef, SelectedColumnRef, SingleColumnNode, MultiColumnNode, ColumnSelection, FactRef, FluentRequest, } from './plan/fluent.js';
+export { createSourceRegistry, defineSource, sourceId, SourceRegistry, UnknownSourceError, } from './plan/source.js';
+export type { SourceParams, SourceRef, LoadedSource, SourceLoadContext, SourceDef, } from './plan/source.js';
+export type { SlotDef, Slots } from './plan/slots.js';
+export { createHost, Host, toWire, UnknownDatasetError } from './plan/host.js';
+export type { Envelope, AsyncEnvelope, PlanEnvelope, SlotEnvelope, AsyncPlanEnvelope, AsyncSlotEnvelope, DatasetInfo, WireResult, } from './plan/host.js';
+export { run } from './plan/run.js';
+export type { ErrorPolicy, RunOptions, PlanRequest, SlotRequest, Select, RunRequest, RunResult, NodeTiming, OutputInfo, Fact, Skipped, } from './plan/run.js';
+export type { Spec, Plan, Input, SpecRef, ParamValue, ParamDef, NumberParam, EnumParam, BooleanParam, Params, Units, UnitSpec, InputDef, OutputDef, OpContext, OpResult, OpDef, Def, FoldDef, FoldContext, FactBody, } from './plan/types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,45 @@
+/**
+ * `@pond-ts/process` — a typed dataflow graph over pond values.
+ *
+ * Where the rest of pond is chain-first (`series.rolling(...).aggregate(...)`),
+ * this package is for the case chaining can't express: when the pipeline
+ * itself is **data** — assembled at runtime, reshaped by a user, rendered
+ * as a node editor, or shared as one computation with several outputs.
+ *
+ * The chain API remains the primary way to use pond. Reach for a graph
+ * only when the topology isn't known at authoring time.
+ *
+ * ```ts
+ * import { source, derive } from '@pond-ts/process';
+ *
+ * const raw = source<TimeSeries<Schema>>();
+ * const hourly = derive({ s: raw.out.value }, ({ s }) =>
+ *   s.aggregate(Sequence.every('1h'), { cpu: 'avg' }),
+ * );
+ *
+ * raw.set(series);
+ * hourly.out.value.get();
+ * ```
+ */
+export { Inlet, Outlet } from './port.js';
+export { Node, defineNode, derive } from './node.js';
+export { port } from './types.js';
+export { source, fromLive, SourceNode, LiveSourceNode, UnsetSourceError, } from './source.js';
+export { columnBytes, packColumn, appendColumn, columnBuffers, columnFromBuffers, columnView, prepareRange, sealRange, validityByteCount, } from './column.js';
+export { requiredHistory } from './plan/history.js';
+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 { 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';
+export { bind, BoundGraph, UnitError } from './plan/graph.js';
+export { expandSlots, SlotError } from './plan/slots.js';
+export { plan, PlanBuilder, BuilderError } from './plan/builder.js';
+export { process, ProcessBuilder } from './plan/fluent.js';
+export { createSourceRegistry, defineSource, sourceId, SourceRegistry, UnknownSourceError, } from './plan/source.js';
+export { createHost, Host, toWire, UnknownDatasetError } from './plan/host.js';
+export { run } from './plan/run.js';
+//# sourceMappingURL=index.js.map