@pond-ts/process 0.54.0

package/dist/plan/history.d.ts

@@ -0,0 +1,61 @@
+import type { Registry } from './registry.js';
+import { type Spec } from './types.js';
+/**
+ * The minimum safe tail for a plan, in rows — [PND-PROCHIST].
+ *
+ * ## Why this is not the consumer's call
+ *
+ * The hot leading edge is the design's worst cliff: an 8-study stack over
+ * 500k rows costs **765 ms/tick**, saturating at ~1.3 ticks/sec. The same
+ * stack over a 5,000-row tail runs at **5.4 ms/tick**. So a consumer
+ * watching a live edge should slice, and the only question is where.
+ *
+ * The RFC left that to the consumer. It should not be a guess in either
+ * direction: too short silently truncates a study's warm-up and reports
+ * `undefined` where a value exists, too long gives the cliff back. The
+ * registry already knows every op's lookback, so `display range +
+ * requiredHistory(plan)` is *provably* sufficient.
+ *
+ * ## Lookbacks sum along a chain; they do not max
+ *
+ * This is the part worth getting right. `sma(20)` over `sma(50)` does not
+ * need 50 rows of history — it needs 50 for the inner study to produce
+ * anything, and then a further 19 rows of *that output* before the outer
+ * one does. 69, not 50. Taking the max across a nested chain
+ * under-provisions by exactly the amount that makes the bug subtle: the
+ * answer is defined, plausible, and computed from a truncated window.
+ *
+ * Across *independent* specs in a plan it is a max, because the plan
+ * needs whichever branch reaches furthest back.
+ *
+ * ## Unknown is not zero
+ *
+ * An op that does not declare `lookback` makes this return
+ * `{ known: false }` with the offending ops named, rather than a number.
+ * A missing declaration and a genuinely element-wise op are the same
+ * value and opposite meanings, and defaulting to zero would hand back a
+ * confidently wrong slice. An element-wise op should declare `() => 0`.
+ */
+export interface HistoryResult {
+    /** False when any op in the plan does not declare a lookback. */
+    readonly known: boolean;
+    /**
+     * Rows of history the plan needs before a requested range. Present
+     * only when {@link known} — there is no safe default to report.
+     */
+    readonly rows?: number;
+    /** Ops with no declared lookback, deduplicated, in encounter order. */
+    readonly undeclared: readonly string[];
+    /**
+     * The deepest history any spec of a given op needed, by op name.
+     *
+     * Not per spec: `sma(5)` and `sma(100)` in one plan collapse to
+     * `{ sma: 99 }`. That is a diagnostic aid for `explain`-style output,
+     * not something to slice against — {@link rows} is the number a caller
+     * uses. The doc previously said "per-spec depth … keyed by op name",
+     * which is self-contradictory and was flagged in review.
+     */
+    readonly byOp: Readonly<Record<string, number>>;
+}
+export declare function requiredHistory(registry: Registry, plan: readonly Spec[]): HistoryResult;
+//# sourceMappingURL=history.d.ts.map

package/dist/plan/history.js

@@ -0,0 +1,82 @@
+import { ProcessError } from '../errors.js';
+import { isFold, isPicked, } from './types.js';
+export function requiredHistory(registry, plan) {
+    const undeclared = [];
+    const seen = new Set();
+    const byOp = {};
+    // A plan is a DAG of shared specs, so the same subtree is reachable by
+    // many paths. Memoize on identity — two structurally equal specs are
+    // separate objects here, and both give the same answer anyway.
+    const depth = new Map();
+    const of = (spec) => {
+        const cached = depth.get(spec);
+        if (cached !== undefined)
+            return cached;
+        const def = registry.get(spec.op);
+        let own = 0;
+        if (isFold(def)) {
+            // A fold reads a whole column and emits a fact. It adds no warm-up
+            // of its own — but a truncated tail still changes its answer, which
+            // is a windowing question rather than a history one.
+            own = 0;
+        }
+        else if (def.lookback === undefined) {
+            if (!seen.has(spec.op)) {
+                seen.add(spec.op);
+                undeclared.push(spec.op);
+            }
+        }
+        else {
+            own = def.lookback(paramsOf(registry, spec));
+            if (!Number.isFinite(own) || own < 0) {
+                throw new ProcessError(`op '${spec.op}' declared a lookback of ${String(own)}; ` +
+                    `it must be a non-negative finite row count`);
+            }
+            own = Math.ceil(own);
+        }
+        // Sum along nesting, max across sibling inputs: a spec with two
+        // nested inputs waits for whichever arrives latest, and then needs
+        // its own warm-up on top of that.
+        let deepest = 0;
+        for (const input of spec.inputs ?? []) {
+            if (typeof input === 'string')
+                continue; // a source column: no warm-up
+            const nested = of(specOf(input));
+            if (nested > deepest)
+                deepest = nested;
+        }
+        const total = own + deepest;
+        depth.set(spec, total);
+        byOp[spec.op] = Math.max(byOp[spec.op] ?? 0, total);
+        return total;
+    };
+    let rows = 0;
+    for (const spec of plan) {
+        const d = of(spec);
+        if (d > rows)
+            rows = d;
+    }
+    return undeclared.length > 0
+        ? { known: false, undeclared, byOp }
+        : { known: true, rows, undeclared: [], byOp };
+}
+/**
+ * A nested input is either a spec or a picked output of one.
+ *
+ * The picked form nests under `from`, not `spec` — an earlier guess at
+ * the field name silently produced `undefined` here, which only surfaced
+ * once this ran on a plan using multi-output studies.
+ */
+function specOf(input) {
+    return isPicked(input) ? input.from : input;
+}
+/**
+ * Params with defaults applied, which is what a lookback must see: `sma`
+ * with no `period` still has one, and reading `spec.params` directly
+ * would hand the lookback an `undefined` to multiply.
+ */
+function paramsOf(registry, spec) {
+    const def = registry.get(spec.op);
+    return registry.resolveParams(def, spec.params);
+}
+//# sourceMappingURL=history.js.map

package/dist/plan/host.d.ts

@@ -0,0 +1,173 @@
+/**
+ * The long-lived host — [PND-DEMOM1].
+ *
+ * A `Host` owns `Map<datasetId, BoundGraph>` and **outlives requests**.
+ * That is the whole architectural claim: a graph built per request starts
+ * cold, and a cold graph is a fold with extra steps. Every caching figure
+ * behind this design assumes a warm binding.
+ *
+ * Where the host runs is a separate question — a long-lived worker proves
+ * client-side execution with an unblocked main thread; a server process
+ * proves one cache shared across sessions. Both satisfy the invariant;
+ * neither is expressed here, because this is the part they share.
+ */
+import { ProcessError } from '../errors.js';
+import type { SeriesSchema, TimeSeries } from 'pond-ts';
+import { BoundGraph } from './graph.js';
+import type { Registry } from './registry.js';
+import { type RunResult, type Select, type ErrorPolicy } from './run.js';
+import type { Slots } from './slots.js';
+import { type SourceRef, type SourceRegistry } from './source.js';
+import type { Plan, Units } from './types.js';
+/** Thrown when a request names a dataset the host has not been given. */
+export declare class UnknownDatasetError extends ProcessError {
+}
+/**
+ * A request as it arrives over a wire.
+ *
+ * `from` is the binding key, and the multi-source hook — widening it to
+ * an array later ([PND-PROCJOIN]) should be an addition rather than a
+ * break. `as` **names** the output so a later request can refer to it; it
+ * deliberately does not window one, or the request would have two places
+ * that slice time and they would eventually disagree.
+ */
+interface EnvelopeBase<From extends string | SourceRef> {
+    readonly from: From;
+    readonly as?: string;
+    readonly onError?: ErrorPolicy;
+    /** See {@link RunOptions.assemble}. A wire consumer wants `false`. */
+    readonly assemble?: boolean;
+}
+/** The original form: a plan of nested specs, selected inline. */
+export interface PlanEnvelope extends EnvelopeBase<string> {
+    readonly process: Plan;
+    readonly select?: readonly Select[];
+}
+/**
+ * The slot form — [PND-PROCSLOT].
+ *
+ * `nodes` is keyed by names the caller owns and `outputs` by names it
+ * will read back, so both survive a param edit that moves every derived
+ * id. What a `PlanBuilder` emits.
+ */
+export interface SlotEnvelope extends EnvelopeBase<string> {
+    readonly nodes: Slots;
+    readonly outputs?: Readonly<Record<string, Select>>;
+}
+export type Envelope = PlanEnvelope | SlotEnvelope;
+/** Nested-plan request whose source must be resolved asynchronously. */
+export interface AsyncPlanEnvelope extends EnvelopeBase<SourceRef> {
+    readonly process: Plan;
+    readonly select?: readonly Select[];
+}
+/** Slot request whose source must be resolved asynchronously. */
+export interface AsyncSlotEnvelope extends EnvelopeBase<SourceRef> {
+    readonly nodes: Slots;
+    readonly outputs?: Readonly<Record<string, Select>>;
+}
+/** What `Host.runAsync` accepts: local requests too, for composable callers. */
+export type AsyncEnvelope = Envelope | AsyncPlanEnvelope | AsyncSlotEnvelope;
+export interface DatasetInfo {
+    readonly id: string;
+    readonly rows: number;
+    readonly columns: readonly string[];
+    /** Nodes compiled against this binding so far. */
+    readonly nodes: number;
+}
+export declare class Host {
+    #private;
+    readonly registry: Registry;
+    constructor(options: {
+        registry: Registry;
+        units?: Units;
+        sources?: SourceRegistry;
+        /**
+         * Cap on retained node values **per bound graph**, in bytes — see
+         * {@link bind}. Without one, a host accepting runtime plans retains
+         * every distinct spec ever asked of every dataset, so memory scales
+         * with questions asked rather than with anything bounded. A host
+         * whose plans arrive from callers it does not control should set
+         * this.
+         *
+         * What bounds the *number* of graphs is a separate question with two
+         * answers. Datasets registered with {@link add} are the host
+         * author's own, bounded by what the author adds and released with
+         * {@link remove}. Sources resolved through a source registry by
+         * `runAsync` are **request-driven** — every distinct `SourceRef` a
+         * caller supplies binds another graph — so a host exposed to
+         * untrusted callers must also set {@link maxSources}. The retained
+         * total is then at most `budgetBytes × (author datasets +
+         * maxSources)`.
+         */
+        budgetBytes?: number;
+        /**
+         * Cap on sources resolved through the source registry, LRU — the
+         * request-driven half of the host's footprint. `runAsync` binds a
+         * graph per distinct `SourceRef`, and a caller chooses the refs, so
+         * without a cap an untrusted caller grows the host without bound.
+         * Author-added datasets ({@link add}) are never evicted by this.
+         * Unbounded when omitted — acceptable only when every `SourceRef`
+         * the host will see comes from code the author controls.
+         */
+        maxSources?: number;
+    });
+    /**
+     * Registers a dataset. The graph is built lazily on first use, so
+     * seeding many datasets is cheap.
+     */
+    add(id: string, series: TimeSeries<SeriesSchema>): this;
+    has(id: string): boolean;
+    get datasets(): DatasetInfo[];
+    /** The bound graph for a dataset, built on first use and kept. */
+    graphFor(id: string): BoundGraph;
+    /**
+     * Forgets a dataset: its source, its graph, and every cached node
+     * value with them. The explicit end of a binding's lifecycle — the
+     * counterpart to {@link add} for a host that cycles datasets, where
+     * "kept until the process dies" is not a policy.
+     *
+     * Returns whether the dataset was known. A load in flight for the
+     * same source id **discards its result** rather than resurrecting the
+     * removed dataset — its `runAsync` callers get `UnknownDatasetError`,
+     * which is what asking for a concurrently-removed dataset means.
+     */
+    remove(id: string): boolean;
+    /** Resolves an envelope against its dataset's long-lived graph. */
+    run(envelope: Envelope): RunResult;
+    /**
+     * Resolves either a preloaded dataset or an opaque asynchronous source.
+     *
+     * Equal revisions preserve the graph untouched. A changed revision updates
+     * its source in place, retaining compiled nodes while normal invalidation
+     * propagates from the new value.
+     */
+    runAsync(envelope: AsyncEnvelope): Promise<RunResult>;
+}
+export declare function createHost(options: {
+    registry: Registry;
+    units?: Units;
+    sources?: SourceRegistry;
+    /** Per-graph cap on retained node values, in bytes — see {@link Host}. */
+    budgetBytes?: number;
+    /** LRU cap on registry-loaded sources — see {@link Host}. */
+    maxSources?: number;
+}): Host;
+/** A response with the in-process values dropped — what crosses a wire. */
+export interface WireResult extends Omit<RunResult, 'series' | 'columns'> {
+    readonly as?: string;
+    /** Whether a `columns` selector asked for drawable values. */
+    readonly hasSeries: boolean;
+}
+/**
+ * Projects a result for transport.
+ *
+ * The renderer path hands back a live `TimeSeries` on purpose — a chart
+ * draws every point, and serializing 10⁶ of them per frame is the failure
+ * this split exists to avoid. `toWire` is for the other caller, and the
+ * useful property is that it is **only lossy when columns were asked
+ * for**: a facts-only response is already JSON-safe, so this is a no-op
+ * on exactly the requests that cross a wire.
+ */
+export declare function toWire(result: RunResult, as?: string): WireResult;
+export {};
+//# sourceMappingURL=host.d.ts.map

package/dist/plan/host.js

@@ -0,0 +1,234 @@
+/**
+ * The long-lived host — [PND-DEMOM1].
+ *
+ * A `Host` owns `Map<datasetId, BoundGraph>` and **outlives requests**.
+ * That is the whole architectural claim: a graph built per request starts
+ * cold, and a cold graph is a fold with extra steps. Every caching figure
+ * behind this design assumes a warm binding.
+ *
+ * Where the host runs is a separate question — a long-lived worker proves
+ * client-side execution with an unblocked main thread; a server process
+ * proves one cache shared across sessions. Both satisfy the invariant;
+ * neither is expressed here, because this is the part they share.
+ */
+import { ProcessError } from '../errors.js';
+import { bind } from './graph.js';
+import { run } from './run.js';
+import { sourceId, } from './source.js';
+/** Thrown when a request names a dataset the host has not been given. */
+export class UnknownDatasetError extends ProcessError {
+}
+function isLocalEnvelope(envelope) {
+    return typeof envelope.from === 'string';
+}
+export class Host {
+    registry;
+    #units;
+    #budgetBytes;
+    #maxSources;
+    #graphs = new Map();
+    #sources = new Map();
+    #sourceRegistry;
+    /** Insertion order is LRU order for {@link Host.#maxSources} eviction. */
+    #loadedSources = new Map();
+    #loadingSources = new Map();
+    /**
+     * Bumped by {@link remove} while a load for that id is in flight, so
+     * the landing load discards its result instead of resurrecting the
+     * dataset. Entries are consumed by the discarding load — the map only
+     * holds ids removed mid-flight.
+     */
+    #sourceEpochs = new Map();
+    constructor(options) {
+        this.registry = options.registry;
+        this.#units = options.units ?? {};
+        this.#budgetBytes = options.budgetBytes;
+        this.#maxSources = options.maxSources;
+        this.#sourceRegistry = options.sources;
+    }
+    /**
+     * Registers a dataset. The graph is built lazily on first use, so
+     * seeding many datasets is cheap.
+     */
+    add(id, series) {
+        this.#sources.set(id, series);
+        const existing = this.#graphs.get(id);
+        // Rebinding an existing dataset updates it in place rather than
+        // discarding the graph — the nodes stay, and dirty marking handles
+        // the rest. Dropping the graph would throw away the cache on every
+        // data refresh, which is exactly what this class exists to avoid.
+        if (existing)
+            existing.setSource(series);
+        return this;
+    }
+    has(id) {
+        return this.#sources.has(id);
+    }
+    get datasets() {
+        return [...this.#sources.entries()].map(([id, series]) => ({
+            id,
+            rows: series.length,
+            columns: series.schema.slice(1).map((c) => c.name),
+            nodes: this.#graphs.get(id)?.ids.length ?? 0,
+        }));
+    }
+    /** The bound graph for a dataset, built on first use and kept. */
+    graphFor(id) {
+        const existing = this.#graphs.get(id);
+        if (existing)
+            return existing;
+        const series = this.#sources.get(id);
+        if (series === undefined) {
+            const have = [...this.#sources.keys()].map((k) => `'${k}'`).join(', ');
+            throw new UnknownDatasetError(`unknown dataset '${id}'${have ? ` — have ${have}` : ''}`);
+        }
+        const graph = bind(series, {
+            registry: this.registry,
+            units: this.#units,
+            ...(this.#budgetBytes !== undefined && {
+                budgetBytes: this.#budgetBytes,
+            }),
+        });
+        this.#graphs.set(id, graph);
+        return graph;
+    }
+    /**
+     * Forgets a dataset: its source, its graph, and every cached node
+     * value with them. The explicit end of a binding's lifecycle — the
+     * counterpart to {@link add} for a host that cycles datasets, where
+     * "kept until the process dies" is not a policy.
+     *
+     * Returns whether the dataset was known. A load in flight for the
+     * same source id **discards its result** rather than resurrecting the
+     * removed dataset — its `runAsync` callers get `UnknownDatasetError`,
+     * which is what asking for a concurrently-removed dataset means.
+     */
+    remove(id) {
+        const known = this.#sources.delete(id);
+        this.#graphs.delete(id);
+        this.#loadedSources.delete(id);
+        if (this.#loadingSources.has(id)) {
+            this.#sourceEpochs.set(id, (this.#sourceEpochs.get(id) ?? 0) + 1);
+        }
+        return known;
+    }
+    /** Resolves an envelope against its dataset's long-lived graph. */
+    run(envelope) {
+        const graph = this.graphFor(envelope.from);
+        const options = {
+            ...(envelope.onError !== undefined && { onError: envelope.onError }),
+            ...(envelope.assemble !== undefined && { assemble: envelope.assemble }),
+        };
+        return 'nodes' in envelope
+            ? run(graph, {
+                nodes: envelope.nodes,
+                ...(envelope.outputs !== undefined && { outputs: envelope.outputs }),
+                ...options,
+            })
+            : run(graph, {
+                plan: envelope.process,
+                ...(envelope.select !== undefined && { select: envelope.select }),
+                ...options,
+            });
+    }
+    /**
+     * Resolves either a preloaded dataset or an opaque asynchronous source.
+     *
+     * Equal revisions preserve the graph untouched. A changed revision updates
+     * its source in place, retaining compiled nodes while normal invalidation
+     * propagates from the new value.
+     */
+    async runAsync(envelope) {
+        if (isLocalEnvelope(envelope))
+            return this.run(envelope);
+        if (this.#sourceRegistry === undefined) {
+            throw new ProcessError(`source '${envelope.from.source}' cannot load — this host has no source registry`);
+        }
+        const id = sourceId(envelope.from);
+        let loading = this.#loadingSources.get(id);
+        if (loading === undefined) {
+            loading = this.#refreshSource(id, envelope.from);
+            this.#loadingSources.set(id, loading);
+        }
+        try {
+            await loading;
+        }
+        finally {
+            if (this.#loadingSources.get(id) === loading) {
+                this.#loadingSources.delete(id);
+            }
+        }
+        return this.run({ ...envelope, from: id });
+    }
+    /**
+     * Loads and applies one source revision as a single in-flight operation.
+     *
+     * `runAsync` shares this promise per canonical source identity. Keeping the
+     * state update inside it means concurrent callers cannot each invalidate the
+     * graph or race to install an older revision.
+     */
+    async #refreshSource(id, ref) {
+        const epoch = this.#sourceEpochs.get(id);
+        const previous = this.#loadedSources.get(id);
+        const loaded = await this.#sourceRegistry.load(ref, previous);
+        if (this.#sourceEpochs.get(id) !== epoch) {
+            // Removed while loading. Installing now would resurrect a dataset
+            // the author explicitly ended; dropping the result is the only
+            // reading of `remove` that means anything. The entry is consumed
+            // so the map holds nothing once the flight lands.
+            this.#sourceEpochs.delete(id);
+            return;
+        }
+        // Delete-then-set keeps `#loadedSources` in recency order whether or
+        // not the revision moved — the LRU the source cap evicts from.
+        this.#loadedSources.delete(id);
+        if (previous === undefined || previous.revision !== loaded.revision) {
+            this.#loadedSources.set(id, loaded);
+            this.add(id, loaded.value);
+        }
+        else {
+            this.#loadedSources.set(id, previous);
+        }
+        this.#enforceSourceCap(id);
+    }
+    /**
+     * Evicts least-recently-used registry-loaded sources over the cap —
+     * whole datasets, via {@link remove}, so the graph and its cached
+     * nodes go with them. Never touches an author-added dataset: those
+     * are not in `#loadedSources`. `current` is exempt — evicting the
+     * source this call just loaded would fail the very request that paid
+     * for it.
+     */
+    #enforceSourceCap(current) {
+        if (this.#maxSources === undefined)
+            return;
+        while (this.#loadedSources.size > this.#maxSources) {
+            const oldest = this.#loadedSources.keys().next().value;
+            if (oldest === undefined || oldest === current)
+                break;
+            this.remove(oldest);
+        }
+    }
+}
+export function createHost(options) {
+    return new Host(options);
+}
+/**
+ * Projects a result for transport.
+ *
+ * The renderer path hands back a live `TimeSeries` on purpose — a chart
+ * draws every point, and serializing 10⁶ of them per frame is the failure
+ * this split exists to avoid. `toWire` is for the other caller, and the
+ * useful property is that it is **only lossy when columns were asked
+ * for**: a facts-only response is already JSON-safe, so this is a no-op
+ * on exactly the requests that cross a wire.
+ */
+export function toWire(result, as) {
+    const { series, columns, ...rest } = result;
+    return {
+        ...rest,
+        ...(as !== undefined && { as }),
+        hasSeries: series !== undefined || columns !== undefined,
+    };
+}
+//# sourceMappingURL=host.js.map

package/dist/plan/identity.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Identity, lineage, and units — and the [PND-PROCIDENT] decision.
+ *
+ * ## Identity is content-addressed, and that is forced
+ *
+ * The investigation weighed content-addressed ids against params-as-Ins
+ * and measured the latter far cheaper under a parameter sweep (1 node vs
+ * 200, 6 MB of buffers vs 310 MB). But writing `run()` settles it the
+ * other way, because the *plan format* decides it:
+ *
+ * A plan may hold `sma(px, 20)` **and** `sma(px, 50)` at once. They are
+ * two entries, they need two nodes, and — decisively — they need two
+ * distinct output **column names**. A column is named by its spec's id,
+ * so an id that excluded params would collide. Params must be in the id.
+ *
+ * The sweep result is still real; it is just an argument about
+ * **lifetime**, not identity. Dragging a slider mints a node per
+ * position, and those nodes stop being referenced by the current plan the
+ * moment it moves on. The answer is a retained set plus a budget
+ * ([PND-PROCCACHE]) — not a different identity model.
+ *
+ * So: **content-addressed identity, budgeted lifetime.**
+ *
+ * ## Two properties that must not regress
+ *
+ * Both are requirements rather than accidents, because a persisted saved
+ * view and a freshly composed request have to land on the same cache
+ * entry:
+ *
+ * - `specId` is **invariant under param key order** — a caller's JSON
+ *   preserves insertion order and two callers will not agree on one.
+ * - An **omitted param collides with its explicit default**, so
+ *   `{op:'sma'}` and `{op:'sma',params:{period:20}}` are one node.
+ *
+ * Both are pinned by tests.
+ */
+import type { Registry } from './registry.js';
+import type { Params, Spec, SpecRef, Units } from './types.js';
+/**
+ * Canonical, versioned id for a spec — simultaneously the **column
+ * name**, the **cache key**, and the **provenance citation**.
+ *
+ * Params are sorted by key and materialized post-defaults, so two
+ * spellings of one computation collide deliberately.
+ */
+export declare function specId(registry: Registry, spec: Spec): string;
+/** Resolves a reference that may be an inline spec or an id string. */
+export declare function refToId(registry: Registry, ref: SpecRef): string;
+/**
+ * Human lineage, folded from the plan and the registry.
+ *
+ * Derived rather than reconstructed by hand — hand-built lineage is
+ * exactly what loses the inner `sma` in `ema(sma(x))`, which the RFC
+ * cites as a live consumer bug.
+ */
+export declare function explain(registry: Registry, spec: Spec): string;
+/**
+ * Unit of a spec's output `n` — declared outright, or folded from input 0.
+ *
+ * `null` means unitless: the consumer supplied no unit for the raw column
+ * at the root of the chain. That is reported rather than guessed.
+ */
+export declare function unitOf(registry: Registry, spec: Spec, units: Units, outputIndex?: number): string | null;
+/**
+ * Column names a spec produces, in output-declaration order.
+ *
+ * A single-output op declares suffix `''`, so its column *is* the id; a
+ * band's three columns share the id as a prefix, which is the corpus's
+ * own convention and needs no mapping layer.
+ */
+export declare function columnsOf(registry: Registry, spec: Spec, id: string): string[];
+/**
+ * Which params an output depends on, defaulting to all of them.
+ *
+ * Declaring a narrower set is what lets a change to one param leave
+ * another output's version untouched ([PND-PROCSEL]).
+ */
+export declare function dependsOn(registry: Registry, spec: Spec, outputIndex: number): string[];
+/** Params reduced to the subset an output depends on — its cache key. */
+export declare function outputKey(params: Params, keys: readonly string[]): string;
+//# sourceMappingURL=identity.d.ts.map