@pond-ts/process 0.54.0

package/dist/pool/pool.js

@@ -0,0 +1,237 @@
+/**
+ * `HostPool` — whole requests across resident workers ([PND-PROCPAR]).
+ *
+ * ## Which parallelism this is
+ *
+ * The worker-threads assessment
+ * (`docs/notes/worker-threads-assessment-2026-07.md`) found two distinct
+ * wins and warned against conflating them:
+ *
+ * - **Latency** of one composite query — split its nodes across workers.
+ *   Measured 2.42× on a 5-study stack, and it needs an engine change: a
+ *   node's value can only be produced by its own `compute`, so a result
+ *   computed elsewhere has nowhere to land. Still ahead of us.
+ * - **Throughput** under concurrent queries — run *whole* requests, each
+ *   single-threaded, on a pool of resident hosts. Near-linear, no
+ *   decomposition, no numeric-semantics questions, **and no engine
+ *   change at all**.
+ *
+ * This is the second. It is deliberately first: the agent workload is
+ * many overlapping questions, so throughput is what it feels, and this
+ * shape cannot get an answer wrong — each request runs the same
+ * single-threaded code it runs today, in a different isolate.
+ *
+ * ## What makes it cheap
+ *
+ * Each worker holds a **long-lived `Host`**, so compiled nodes and
+ * cached columns survive between requests exactly as they do in-process.
+ * The pool is only a router. What crosses the boundary is a plan
+ * (JSON by construction) and a result whose columns travel as
+ * transferable buffers rather than boxed values.
+ *
+ * ## What it is not
+ *
+ * Not a cache-sharing scheme. Each worker warms its own graph, so N
+ * workers hold up to N copies of a hot column and a question already
+ * answered by worker 2 is cold on worker 3. That is the honest cost of
+ * the simple shape: it buys throughput, not deduplication. Route related
+ * requests to the same worker (see {@link HostPool.run}'s `affinity`) if
+ * repeat-hit rate matters more than even spread.
+ */
+import { Worker } from 'node:worker_threads';
+import { existsSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { ProcessError } from '../errors.js';
+import { fromWire } from './wire.js';
+/** Default pool size: leave a core for the main thread. */
+async function defaultSize() {
+    const os = await import('node:os');
+    const cores = os.availableParallelism?.() ?? os.cpus().length;
+    return Math.max(1, cores - 1);
+}
+export class HostPool {
+    #slots;
+    #pending = new Map();
+    #nextId = 1;
+    #closed = false;
+    /**
+     * Set when a worker dies unexpectedly. A dead worker cannot answer, so
+     * every *later* request must fail too — rejecting only the in-flight
+     * ones left a pool that looked alive and swallowed everything sent to
+     * it. A pool is not self-healing: replacing a worker would silently
+     * discard its warm graph, so failing loudly is the honest response.
+     */
+    #fatal;
+    constructor(slots) {
+        this.#slots = slots;
+    }
+    /**
+     * Starts the pool and waits for every worker to be listening.
+     *
+     * Setup modules are imported lazily *inside* each worker on its first
+     * request, so `start` resolving does not mean the registry loaded — a
+     * broken setup module surfaces as that first request's error, where a
+     * caller can read it, rather than as a start-up crash with no
+     * request to attach it to.
+     */
+    static async start(options) {
+        const size = options.size ?? (await defaultSize());
+        if (!Number.isInteger(size) || size < 1) {
+            throw new ProcessError(`HostPool: size must be >= 1, got ${size}`);
+        }
+        const setup = options.setup instanceof URL ? options.setup.href : String(options.setup);
+        // The worker entry sits next to this module in `dist`. Checked
+        // rather than assumed: a caller running the package from TypeScript
+        // source (a test runner, a bundler) resolves this to a `.ts` file no
+        // Node worker can load, and `new Worker` on a missing file fails
+        // asynchronously — which used to leave a pool whose workers were all
+        // dead and whose requests hung forever. A named error at start beats
+        // a silent hang later.
+        const entry = fileURLToPath(new URL('./worker.js', import.meta.url));
+        if (!existsSync(entry)) {
+            throw new ProcessError(`HostPool: worker entry not found at '${entry}'. The pool needs the ` +
+                `built package — run \`npm run build\` and import ` +
+                `'@pond-ts/process/pool' (or dist/pool/index.js) rather than the ` +
+                `TypeScript source, which a worker thread cannot load.`);
+        }
+        const slots = [];
+        for (let i = 0; i < size; i += 1) {
+            const worker = new Worker(entry, {
+                workerData: {
+                    setup,
+                    ...(options.setupOptions !== undefined && {
+                        setupOptions: options.setupOptions,
+                    }),
+                },
+            });
+            // Idle workers must not hold the process open — a pool someone
+            // forgot to close should not stop `node script.js` from exiting.
+            // Re-`ref`'d while a request is in flight (see `#dispatch`),
+            // because a pending promise does *not* keep the event loop alive
+            // on its own: unref'd throughout, a program awaiting `run()` could
+            // exit before its answer arrived.
+            worker.unref();
+            slots.push({ worker, inFlight: 0 });
+        }
+        const pool = new HostPool(slots);
+        for (const slot of slots) {
+            slot.worker.on('message', (m) => pool.#settle(slot, m));
+            slot.worker.on('error', (e) => pool.#die(e));
+            // ANY unexpected exit is fatal, not just a non-zero one. A worker
+            // that left cleanly is exactly as unable to answer as one that
+            // crashed, and treating `code === 0` as benign left every later
+            // request routed to that slot hanging forever — the same silent
+            // hang the fatal latch exists to stop.
+            slot.worker.on('exit', (code) => {
+                if (!pool.#closed) {
+                    pool.#die(new ProcessError(`HostPool: worker exited with code ${code}`));
+                }
+            });
+        }
+        return pool;
+    }
+    /** Workers in the pool. */
+    get size() {
+        return this.#slots.length;
+    }
+    /** Requests dispatched and not yet answered. */
+    get inFlight() {
+        return this.#pending.size;
+    }
+    /**
+     * Runs one envelope on the least-busy worker.
+     *
+     * `assemble` is forced off — the pool answers `columns`, and the caller
+     * assembles a `TimeSeries` from them if it wants one. Assembling
+     * worker-side would build an object that cannot cross the boundary.
+     *
+     * Pass `affinity` to pin related requests to one worker. Requests
+     * sharing an affinity key land on the same host, so its warm nodes are
+     * reused — worth it when a caller re-asks overlapping questions about
+     * one dataset, and pointless when every request is unrelated.
+     */
+    async run(envelope, affinity) {
+        if (this.#closed)
+            throw new ProcessError('HostPool: pool is closed');
+        if (this.#fatal !== undefined)
+            throw this.#fatal;
+        const slot = this.#pick(affinity);
+        const id = this.#nextId++;
+        const request = { id, envelope };
+        return new Promise((resolve, reject) => {
+            this.#pending.set(id, { resolve, reject });
+            if (slot.inFlight === 0)
+                slot.worker.ref();
+            slot.inFlight += 1;
+            slot.worker.postMessage(request);
+        });
+    }
+    /** Terminates every worker. Outstanding requests reject. */
+    async close() {
+        if (this.#closed)
+            return;
+        this.#closed = true;
+        this.#failAll(new ProcessError('HostPool: pool closed'));
+        await Promise.all(this.#slots.map((s) => s.worker.terminate()));
+    }
+    /**
+     * Least-in-flight, not round-robin: requests here differ by orders of
+     * magnitude (a cached fact against a cold 500k-row study), so spreading
+     * by count would queue short work behind long work on the same worker.
+     */
+    #pick(affinity) {
+        if (affinity !== undefined) {
+            let hash = 0;
+            for (let i = 0; i < affinity.length; i += 1) {
+                hash = (hash * 31 + affinity.charCodeAt(i)) | 0;
+            }
+            return this.#slots[Math.abs(hash) % this.#slots.length];
+        }
+        let best = this.#slots[0];
+        for (const slot of this.#slots) {
+            if (slot.inFlight < best.inFlight)
+                best = slot;
+        }
+        return best;
+    }
+    #settle(slot, message) {
+        // Identify the request FIRST. A worker's `parentPort` is in scope for
+        // the caller's own setup module, so a stray `postMessage` from it
+        // reaches here — and decrementing on that would `unref` a worker with
+        // real work outstanding, letting the process exit before the answer
+        // arrived. That is exactly the hang ref/unref exists to prevent, and
+        // a `Math.max(0, …)` guard hides it as an early unref rather than a
+        // negative count. Only a message we are actually waiting on counts.
+        const pending = this.#pending.get(message.id);
+        if (pending === undefined)
+            return;
+        this.#pending.delete(message.id);
+        slot.inFlight = Math.max(0, slot.inFlight - 1);
+        if (slot.inFlight === 0)
+            slot.worker.unref();
+        if (message.ok) {
+            pending.resolve(fromWire(message.wire));
+        }
+        else {
+            const error = new ProcessError(message.error);
+            if (message.name !== undefined)
+                error.name = message.name;
+            pending.reject(error);
+        }
+    }
+    /** A worker died: fail what is outstanding, and everything after it. */
+    #die(error) {
+        this.#fatal ??= error;
+        this.#failAll(error);
+    }
+    #failAll(error) {
+        for (const pending of this.#pending.values())
+            pending.reject(error);
+        this.#pending.clear();
+        for (const slot of this.#slots) {
+            slot.inFlight = 0;
+            slot.worker.unref();
+        }
+    }
+}
+//# sourceMappingURL=pool.js.map

package/dist/pool/protocol.d.ts

@@ -0,0 +1,48 @@
+/**
+ * The pool's worker protocol — [PND-PROCPAR].
+ *
+ * Deliberately tiny: one request shape, one response shape, correlated
+ * by a monotonic id. Everything interesting is already carried by the
+ * plan format.
+ */
+import type { Registry } from '../plan/registry.js';
+import type { SourceRegistry } from '../plan/source.js';
+import type { Units } from '../plan/types.js';
+import type { AsyncEnvelope } from '../plan/host.js';
+import type { WireResult } from './wire.js';
+import type { SeriesSchema, TimeSeries } from 'pond-ts';
+/**
+ * What a worker's setup module returns — the same shape {@link Host}
+ * takes, plus datasets to seed.
+ *
+ * Named as a module specifier rather than passed as a value because a
+ * registry is functions, and functions do not survive structured clone.
+ * Both isolates import the same module; the ops are shared code.
+ */
+export interface PoolSetupConfig {
+    readonly registry: Registry;
+    readonly units?: Units;
+    readonly sources?: SourceRegistry;
+    /**
+     * Datasets to `add` at start-up. Optional — a host with a
+     * `SourceRegistry` can instead load datasets on demand by identity,
+     * which is the shape that avoids sending data to workers at all.
+     */
+    readonly datasets?: Readonly<Record<string, TimeSeries<SeriesSchema>>>;
+}
+export type PoolSetup = (options?: unknown) => PoolSetupConfig | Promise<PoolSetupConfig>;
+export interface WorkerRequest {
+    readonly id: number;
+    readonly envelope: AsyncEnvelope;
+}
+export type WorkerResponse = {
+    readonly id: number;
+    readonly ok: true;
+    readonly wire: WireResult;
+} | {
+    readonly id: number;
+    readonly ok: false;
+    readonly error: string;
+    readonly name?: string;
+};
+//# sourceMappingURL=protocol.d.ts.map

package/dist/pool/protocol.js

@@ -0,0 +1,9 @@
+/**
+ * The pool's worker protocol — [PND-PROCPAR].
+ *
+ * Deliberately tiny: one request shape, one response shape, correlated
+ * by a monotonic id. Everything interesting is already carried by the
+ * plan format.
+ */
+export {};
+//# sourceMappingURL=protocol.js.map

package/dist/pool/wire.d.ts

@@ -0,0 +1,52 @@
+/**
+ * The `RunResult` wire shape — [PND-PROCPAR].
+ *
+ * A `RunResult` is already almost JSON: `outputs`, `facts`, `explain`,
+ * `skipped` and `nodes` are plain data by construction, because the plan
+ * layer exists to be spoken over a wire. Two fields are not:
+ *
+ * - **`columns`** — `Column` instances. Sent as their buffers
+ *   ({@link columnBuffers}) and rebuilt on arrival, so a 500k-row answer
+ *   crosses as two transferable buffers rather than 500k boxed values.
+ * - **`series`** — an assembled `TimeSeries`. **Not sent at all.** A pool
+ *   request runs with `assemble: false`; the caller assembles from
+ *   `columns` if it wants one, which is [PND-PROCTERM]'s position
+ *   anyway (assembly is requested, not assumed) and avoids shipping a
+ *   whole schema-bearing object to rebuild something the columns already
+ *   describe.
+ *
+ * A **numeric** column this cannot express as buffers (chunked storage)
+ * falls back to a boxed array rather than failing the request — a
+ * correct slow answer beats a fast error. A **non-numeric** column has
+ * no wire form at all and is refused; see {@link toWireColumn} for why
+ * boxing one would produce plausible-looking nonsense rather than an
+ * error.
+ */
+import type { ColumnBuffers } from '../column.js';
+import type { RunResult } from '../plan/run.js';
+/** A column on the wire: buffers where possible, boxed where not. */
+export type WireColumn = {
+    readonly kind: 'buffers';
+    readonly data: ColumnBuffers;
+} | {
+    readonly kind: 'boxed';
+    readonly values: readonly (number | undefined)[];
+};
+/** A `RunResult` with its columns flattened. `series` is dropped. */
+export interface WireResult extends Omit<RunResult, 'series' | 'columns'> {
+    readonly columns?: Readonly<Record<string, WireColumn>>;
+}
+/**
+ * Flattens a result for `postMessage`, collecting the buffers that should
+ * be **transferred** rather than copied.
+ *
+ * The buffers are already private copies (see {@link columnBuffers}), so
+ * transferring them detaches nothing the sender still needs.
+ */
+export declare function toWire(result: RunResult): {
+    wire: WireResult;
+    transfer: ArrayBuffer[];
+};
+/** Rebuilds a `RunResult` from the wire. Adopts the arrived buffers. */
+export declare function fromWire(wire: WireResult): RunResult;
+//# sourceMappingURL=wire.d.ts.map

package/dist/pool/wire.js

@@ -0,0 +1,95 @@
+/**
+ * The `RunResult` wire shape — [PND-PROCPAR].
+ *
+ * A `RunResult` is already almost JSON: `outputs`, `facts`, `explain`,
+ * `skipped` and `nodes` are plain data by construction, because the plan
+ * layer exists to be spoken over a wire. Two fields are not:
+ *
+ * - **`columns`** — `Column` instances. Sent as their buffers
+ *   ({@link columnBuffers}) and rebuilt on arrival, so a 500k-row answer
+ *   crosses as two transferable buffers rather than 500k boxed values.
+ * - **`series`** — an assembled `TimeSeries`. **Not sent at all.** A pool
+ *   request runs with `assemble: false`; the caller assembles from
+ *   `columns` if it wants one, which is [PND-PROCTERM]'s position
+ *   anyway (assembly is requested, not assumed) and avoids shipping a
+ *   whole schema-bearing object to rebuild something the columns already
+ *   describe.
+ *
+ * A **numeric** column this cannot express as buffers (chunked storage)
+ * falls back to a boxed array rather than failing the request — a
+ * correct slow answer beats a fast error. A **non-numeric** column has
+ * no wire form at all and is refused; see {@link toWireColumn} for why
+ * boxing one would produce plausible-looking nonsense rather than an
+ * error.
+ */
+import { columnBuffers, columnFromBuffers, packColumn } from '../column.js';
+import { ProcessError } from '../errors.js';
+function toWireColumn(column) {
+    const data = columnBuffers(column);
+    if (data !== undefined)
+        return { kind: 'buffers', data };
+    // The fallback is for a **numeric** column `columnBuffers` cannot take
+    // as buffers — chunked storage, in practice. It is not a general
+    // escape hatch: the boxed form is rebuilt with `packColumn`, which
+    // reads numbers, so a `string` / `boolean` / `array` column would pack
+    // every cell as a defined `NaN` (`Number.isNaN('x')` is false) and
+    // arrive as plausible-looking nonsense. Refusing is the only honest
+    // answer until the wire grows those kinds.
+    if (column.kind !== 'number') {
+        throw new ProcessError(`HostPool: cannot send a '${column.kind}' column across a worker ` +
+            `boundary — only numeric columns have a wire form. Select numeric ` +
+            `outputs, or run this request in-process.`);
+    }
+    const at = column;
+    const values = new Array(column.length);
+    for (let i = 0; i < column.length; i += 1)
+        values[i] = at.at(i);
+    return { kind: 'boxed', values };
+}
+/**
+ * Flattens a result for `postMessage`, collecting the buffers that should
+ * be **transferred** rather than copied.
+ *
+ * The buffers are already private copies (see {@link columnBuffers}), so
+ * transferring them detaches nothing the sender still needs.
+ */
+export function toWire(result) {
+    const transfer = [];
+    let columns;
+    if (result.columns !== undefined) {
+        columns = {};
+        for (const [name, column] of Object.entries(result.columns)) {
+            const wire = toWireColumn(column);
+            columns[name] = wire;
+            if (wire.kind === 'buffers') {
+                transfer.push(wire.data.values.buffer);
+                if (wire.data.bits !== undefined) {
+                    transfer.push(wire.data.bits.buffer);
+                }
+            }
+        }
+    }
+    const { series: _series, columns: _columns, ...rest } = result;
+    return {
+        wire: { ...rest, ...(columns !== undefined && { columns }) },
+        transfer,
+    };
+}
+/** Rebuilds a `RunResult` from the wire. Adopts the arrived buffers. */
+export function fromWire(wire) {
+    // No `columns` key at all ⇒ the two shapes already coincide (every
+    // other field is plain data), so there is nothing to rebuild.
+    if (wire.columns === undefined) {
+        const { columns: _absent, ...rest } = wire;
+        return rest;
+    }
+    const columns = {};
+    for (const [name, value] of Object.entries(wire.columns)) {
+        columns[name] =
+            value.kind === 'buffers'
+                ? columnFromBuffers(value.data)
+                : packColumn(value.values);
+    }
+    return { ...wire, columns };
+}
+//# sourceMappingURL=wire.js.map

package/dist/pool/worker.d.ts

@@ -0,0 +1,22 @@
+/**
+ * The pool's worker entry — [PND-PROCPAR].
+ *
+ * One long-lived {@link Host} per worker, built once from the caller's
+ * setup module, then answering whole envelopes. The **long-lived** part
+ * is the point: a per-request graph would discard every compiled node
+ * and cached column between questions, which is precisely the cost this
+ * package exists to avoid. A worker that rebuilt its host per request
+ * would be slower than not having a pool at all.
+ *
+ * Why a *setup module specifier* rather than a config object: a registry
+ * is functions (`OpDef.run`), and functions do not survive structured
+ * clone. The plan is data and crosses freely; the code behind it has to
+ * be imported at both ends. So the caller names a module, both isolates
+ * import it, and the ops are ordinary shared code.
+ *
+ * This file is only ever loaded *as* a worker. It is Node-only by nature
+ * (`node:worker_threads`), which is why it sits behind its own entry
+ * point rather than in the package index.
+ */
+export {};
+//# sourceMappingURL=worker.d.ts.map

package/dist/pool/worker.js

@@ -0,0 +1,80 @@
+/**
+ * The pool's worker entry — [PND-PROCPAR].
+ *
+ * One long-lived {@link Host} per worker, built once from the caller's
+ * setup module, then answering whole envelopes. The **long-lived** part
+ * is the point: a per-request graph would discard every compiled node
+ * and cached column between questions, which is precisely the cost this
+ * package exists to avoid. A worker that rebuilt its host per request
+ * would be slower than not having a pool at all.
+ *
+ * Why a *setup module specifier* rather than a config object: a registry
+ * is functions (`OpDef.run`), and functions do not survive structured
+ * clone. The plan is data and crosses freely; the code behind it has to
+ * be imported at both ends. So the caller names a module, both isolates
+ * import it, and the ops are ordinary shared code.
+ *
+ * This file is only ever loaded *as* a worker. It is Node-only by nature
+ * (`node:worker_threads`), which is why it sits behind its own entry
+ * point rather than in the package index.
+ */
+import { parentPort, workerData } from 'node:worker_threads';
+import { Host } from '../plan/host.js';
+import { toWire } from './wire.js';
+if (parentPort === null) {
+    throw new Error('@pond-ts/process worker: loaded outside a worker thread');
+}
+const port = parentPort;
+const data = workerData;
+/**
+ * Built once, awaited by every request. Errors here are reported against
+ * the first request rather than crashing the worker silently — a bad
+ * setup module is a caller mistake and should read as one.
+ */
+const ready = (async () => {
+    const module = (await import(data.setup));
+    const factory = module.default ?? module.setup;
+    if (typeof factory !== 'function') {
+        throw new Error(`@pond-ts/process worker: '${data.setup}' must export a setup function ` +
+            `(as \`default\` or \`setup\`) returning { registry, units?, sources?, datasets? }`);
+    }
+    const config = await factory(data.setupOptions);
+    const host = new Host({
+        registry: config.registry,
+        ...(config.units !== undefined && { units: config.units }),
+        ...(config.sources !== undefined && { sources: config.sources }),
+    });
+    for (const [id, series] of Object.entries(config.datasets ?? {})) {
+        host.add(id, series);
+    }
+    return host;
+})();
+// Surfaced through the first request instead of as an unhandled rejection.
+ready.catch(() => undefined);
+port.on('message', (message) => {
+    void (async () => {
+        try {
+            const host = await ready;
+            // `assemble: false` always. The pool answers columns; assembling a
+            // `TimeSeries` here would build something that cannot cross the
+            // boundary and that the caller can rebuild from the columns.
+            const result = await host.runAsync({
+                ...message.envelope,
+                assemble: false,
+            });
+            const { wire, transfer } = toWire(result);
+            const response = { id: message.id, ok: true, wire };
+            port.postMessage(response, transfer);
+        }
+        catch (e) {
+            const response = {
+                id: message.id,
+                ok: false,
+                error: e instanceof Error ? e.message : String(e),
+                ...(e instanceof Error && e.name !== 'Error' && { name: e.name }),
+            };
+            port.postMessage(response);
+        }
+    })();
+});
+//# sourceMappingURL=worker.js.map

package/dist/port.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Typed ports and the wiring between them.
+ *
+ * An `Outlet<T>` is a node's typed output; an `Inlet<T>` is a typed
+ * input. Because both are generic in the value type and the connect
+ * signatures require a matching `T`, wiring a `string` output into a
+ * `number` input is a compile error rather than a runtime surprise.
+ *
+ * Ports also carry the evaluation state. Each outlet holds the cached
+ * value plus a **version stamp** that increments only when a recomputed
+ * value actually differs (per the port's `equals`). Nodes record the
+ * input versions they last computed against, which is what lets a node
+ * that was marked dirty skip recomputation when nothing upstream really
+ * changed. See `node.ts` for the pull algorithm that uses this.
+ */
+import type { Node } from './node.js';
+/** A node's typed output port. */
+export declare class Outlet<T> {
+    #private;
+    readonly name: string;
+    /** The node this output belongs to. */
+    readonly node: Node<any, any>;
+    /**
+     * Evaluates this outlet and returns its value.
+     *
+     * Pull-based: the owning node recomputes only if it is dirty *and* an
+     * upstream version actually changed. A clean node returns the cached
+     * value without touching the rest of the graph.
+     */
+    get(): T;
+    /**
+     * Returns the cached value without evaluating anything, or `undefined`
+     * if this outlet has never produced one. Use it to inspect graph state
+     * (a debug view, a node inspector) without forcing computation.
+     */
+    peek(): T | undefined;
+    /**
+     * How many times this outlet's value has actually changed. Downstream
+     * nodes compare against this to decide whether a dirty mark was a real
+     * change or a false alarm. `0` means nothing has been produced yet.
+     */
+    get version(): number;
+    /** The inlets this outlet feeds. */
+    get connections(): readonly Inlet<T>[];
+    /**
+     * Wires this output into `inlet`.
+     *
+     * @throws {CycleError} if the edge would close a cycle.
+     */
+    connect(inlet: Inlet<T>): this;
+    /** Removes the edge to `inlet`, if present. */
+    disconnect(inlet: Inlet<T>): this;
+}
+/** A node's typed input port. */
+export declare class Inlet<T> {
+    #private;
+    readonly name: string;
+    /** The node this input belongs to. */
+    readonly node: Node<any, any>;
+    /**
+     * Wires `outlet` into this input, replacing any existing connection.
+     *
+     * @throws {CycleError} if the edge would close a cycle.
+     */
+    connect(outlet: Outlet<T>): this;
+    /** Removes the incoming edge, if any. Falls back to the default value. */
+    disconnect(): this;
+    /** Whether an outlet is wired into this input. */
+    get connected(): boolean;
+    /** The outlet feeding this input, or `undefined` if unconnected. */
+    get source(): Outlet<T> | undefined;
+    /**
+     * Pulls the upstream value, evaluating it if stale.
+     *
+     * @throws {UnconnectedInputError} if unconnected and no default was declared.
+     */
+    get(): T;
+}
+//# sourceMappingURL=port.d.ts.map