@prestack/thread 0.0.1

package/dist/operations/memory.js

@@ -0,0 +1,365 @@
+import { randomUUID } from 'node:crypto';
+import { backoffMs, isExhausted } from "./queue-policy.js";
+function projectRow(row, fields, key) {
+    const keep = new Set([key, 'version', ...fields]);
+    const projected = {};
+    for (const [name, value] of Object.entries(row)) {
+        if (keep.has(name))
+            projected[name] = value;
+    }
+    return projected;
+}
+export class UnknownColumnError extends Error {
+    constructor(entity, key) {
+        super(`${entity} does not declare "${key}", so writing it would be silently discarded. ` +
+            'Declare the field or relation on the entity, or stop writing the key.');
+        this.name = 'UnknownColumnError';
+    }
+}
+export class VersionConflictError extends Error {
+    constructor(entity, id, expectedVersion) {
+        super(`${entity} ${id} was not at version ${expectedVersion} — someone else changed it first. ` +
+            're-read the row and retry with its current ETag.');
+        this.name = 'VersionConflictError';
+    }
+}
+export class MemoryStore {
+    data = new Map();
+    declared;
+    keys;
+    constructor(declared, keys) {
+        this.declared = declared ?? new Map();
+        this.keys = keys ?? new Map();
+    }
+    keyOf(entity) {
+        const held = this.keys.get(entity);
+        if (held === undefined) {
+            throw new Error(`nothing told this store which value identifies a ${entity}, so it cannot find one row rather than all of ` +
+                'them. An entity states that with a `unique` invariant over one of its values, and whatever builds this ' +
+                'store passes those along with the columns each entity declares.');
+        }
+        return held;
+    }
+    static SYSTEM = new Set(['version']);
+    assertDeclared(entity, row) {
+        const allowed = this.declared.get(entity);
+        if (allowed === undefined)
+            return;
+        for (const key of Object.keys(row)) {
+            if (allowed.has(key) || MemoryStore.SYSTEM.has(key))
+                continue;
+            throw new UnknownColumnError(entity, key);
+        }
+    }
+    depth = 0;
+    async transaction(_actor, fn) {
+        if (this.depth > 0)
+            return fn();
+        const snapshot = new Map();
+        for (const [key, rows] of this.data)
+            snapshot.set(key, rows.map((r) => ({ ...r })));
+        this.depth += 1;
+        try {
+            return await fn();
+        }
+        catch (err) {
+            this.data = snapshot;
+            throw err;
+        }
+        finally {
+            this.depth -= 1;
+        }
+    }
+    async insert(_actor, entity, row) {
+        this.assertDeclared(entity, row);
+        const rows = this.data.get(entity) ?? [];
+        const rec = { ...row, version: 1 };
+        rows.push(rec);
+        this.data.set(entity, rows);
+        return { ...rec };
+    }
+    async get(_actor, entity, key, fields) {
+        const named = this.keyOf(entity);
+        const row = this.data.get(entity)?.find((r) => r[named] === key) ?? null;
+        return row === null ? null : projectRow(row, fields, named);
+    }
+    async list(_actor, entity, opts) {
+        const all = this.data.get(entity) ?? [];
+        const where = Object.entries(opts?.where ?? {});
+        for (const [field] of where)
+            this.assertDeclared(entity, { [field]: null });
+        const matched = where.length === 0 ? all : all.filter((row) => where.every(([f, v]) => (row[f] ?? null) === v));
+        return opts?.limit ? matched.slice(0, opts.limit).map((r) => ({ ...r })) : matched.map((r) => ({ ...r }));
+    }
+    async update(_actor, entity, key, patch, expectedVersion) {
+        this.assertDeclared(entity, patch);
+        const named = this.keyOf(entity);
+        const rows = this.data.get(entity) ?? [];
+        const i = rows.findIndex((r) => r[named] === key);
+        const cur = rows[i];
+        if (i < 0 || !cur)
+            throw new Error(`record ${String(key)} not found`);
+        const currentVersion = typeof cur['version'] === 'number' ? cur['version'] : 1;
+        if (expectedVersion !== undefined && expectedVersion !== currentVersion) {
+            throw new VersionConflictError(entity, String(key), expectedVersion);
+        }
+        const next = { ...cur, ...patch, [named]: key, version: currentVersion + 1 };
+        rows[i] = next;
+        return { ...next };
+    }
+    async remove(_actor, entity, key) {
+        const named = this.keyOf(entity);
+        this.data.set(entity, (this.data.get(entity) ?? []).filter((r) => r[named] !== key));
+    }
+}
+export class MemoryQueue {
+    jobs = new Map();
+    dead = [];
+    seq = 0;
+    async enqueue(actor, kind, payload, opts) {
+        if (opts?.dedupeKey) {
+            for (const [id, job] of this.jobs) {
+                if (job.dedupeKey === opts.dedupeKey)
+                    return id;
+            }
+        }
+        const id = `job_${++this.seq}`;
+        this.jobs.set(id, {
+            id,
+            kind,
+            payload,
+            attempts: 0,
+            runAt: opts?.runAt ?? 0,
+            claimed: false,
+            dedupeKey: opts?.dedupeKey,
+            actor,
+        });
+        return id;
+    }
+    async poll(kinds, limit, now) {
+        const due = [];
+        for (const job of this.jobs.values()) {
+            if (due.length >= limit)
+                break;
+            if (job.claimed || !kinds.includes(job.kind) || job.runAt > now)
+                continue;
+            job.claimed = true;
+            due.push({ ...job });
+        }
+        return due;
+    }
+    async ack(id) {
+        this.jobs.delete(id);
+    }
+    async fail(id, error, now) {
+        const job = this.jobs.get(id);
+        if (!job)
+            return;
+        job.attempts += 1;
+        job.claimed = false;
+        if (isExhausted(job.attempts)) {
+            this.dead.push({ ...job });
+            this.jobs.delete(id);
+            return;
+        }
+        job.runAt = now + backoffMs(job.attempts);
+        void error;
+    }
+    async deadLetter(id, error) {
+        const job = this.jobs.get(id);
+        if (!job)
+            return;
+        this.dead.push({ ...job });
+        this.jobs.delete(id);
+        void error;
+    }
+    async deadLetters() {
+        return this.dead.map((j) => ({ ...j }));
+    }
+}
+export class MemoryIdempotency {
+    records;
+    onCheck;
+    constructor(opts) {
+        this.records = opts.records ?? new Map();
+        this.onCheck = opts.onCheck;
+    }
+    keyFor(key, action) {
+        return `${key}:${action}`;
+    }
+    async check(key, action) {
+        this.onCheck?.();
+        if (!key)
+            return null;
+        const k = this.keyFor(key, action);
+        return this.records.has(k) ? (this.records.get(k) ?? null) : null;
+    }
+    async store(key, action, output) {
+        if (!key)
+            return;
+        const k = this.keyFor(key, action);
+        if (!this.records.has(k))
+            this.records.set(k, output);
+    }
+}
+export function memoryVault(seed = {}) {
+    return {
+        async resolve(refs) {
+            const found = {};
+            for (const ref of refs) {
+                const value = seed[ref];
+                if (value === undefined)
+                    throw new Error(`vault has no value for "${ref}"`);
+                found[ref] = value;
+            }
+            return found;
+        },
+    };
+}
+export const arrived = () => Date.now();
+export const fresh = () => randomUUID();
+export function inMemorySeams(opts) {
+    const sink = {
+        logs: [], events: [], audits: [], errors: [], costs: [], indexed: [], spans: [],
+        outbox: [], gateOrder: [], quota: { reserved: [], committed: [], released: 0 },
+        files: [], queries: [],
+    };
+    const store = new MemoryStore(opts?.entities, opts?.keys);
+    const queue = new MemoryQueue();
+    const searchIdx = new Map();
+    const telemetry = {
+        start(action) {
+            let status = 'ok';
+            return {
+                ok() { status = 'ok'; },
+                error() { status = 'error'; },
+                end() { sink.spans.push({ action, status }); },
+            };
+        },
+    };
+    const log = { write(level, action, _actor, data) { sink.logs.push({ level, action, data }); } };
+    const audit = { async append(_actor, record) { sink.audits.push(record); } };
+    const errors = { async record(_actor, record) { sink.errors.push(record); } };
+    const cost = { meter(action) { sink.costs.push(action); } };
+    const events = { async publish(e) { sink.events.push(e); } };
+    const rateLimiter = {
+        async check() {
+            sink.gateOrder.push('rate');
+            return opts?.allowRate ?? true;
+        },
+        async checkPolicy() {
+            sink.gateOrder.push('rate');
+            return opts?.allowRate ?? true;
+        },
+    };
+    const featureGate = opts?.features === undefined
+        ? undefined
+        : {
+            async check(_actor, feature) {
+                sink.gateOrder.push('feature');
+                return (opts.features ?? []).includes(feature);
+            },
+        };
+    const used = new Map();
+    const quotas = opts?.quota === undefined
+        ? undefined
+        : {
+            async reserve(_actor, meter, estimate) {
+                sink.gateOrder.push('quota');
+                sink.quota.reserved.push(estimate);
+                const allowance = opts.quota?.[meter] ?? Number.POSITIVE_INFINITY;
+                const before = used.get(meter) ?? 0;
+                if (before + estimate > allowance) {
+                    return {
+                        ok: false,
+                        behavior: opts.onExceed ?? 'block',
+                        retryAfterSeconds: 60,
+                        async commit() { },
+                        async release() { },
+                    };
+                }
+                used.set(meter, before + estimate);
+                let settled = false;
+                return {
+                    ok: true,
+                    behavior: null,
+                    retryAfterSeconds: 0,
+                    async commit(actual) {
+                        if (settled)
+                            return;
+                        settled = true;
+                        sink.quota.committed.push(actual);
+                        used.set(meter, (used.get(meter) ?? 0) - estimate + actual);
+                    },
+                    async release() {
+                        if (settled)
+                            return;
+                        settled = true;
+                        sink.quota.released += 1;
+                        used.set(meter, (used.get(meter) ?? 0) - estimate);
+                    },
+                };
+            },
+        };
+    const outbox = {
+        async emit(_actor, event) {
+            sink.outbox.push(event);
+        },
+    };
+    const idempotency = new MemoryIdempotency({
+        onCheck: () => sink.gateOrder.push('idempotency'),
+    });
+    const search = {
+        async index(_actor, entity, row) {
+            sink.indexed.push({ entity, row });
+            searchIdx.set(entity, [...(searchIdx.get(entity) ?? []), row]);
+        },
+        async query(_actor, entity, q) {
+            const needle = q.toLowerCase();
+            return (searchIdx.get(entity) ?? []).filter((r) => JSON.stringify(r).toLowerCase().includes(needle));
+        },
+    };
+    const vault = opts?.secrets === undefined ? undefined : memoryVault(opts.secrets);
+    const stored = new Map();
+    const files = {
+        async put(_actor, key, body, contentType) {
+            stored.set(key, { body, contentType });
+            sink.files.push({ action: 'put', key, bytes: body.byteLength });
+            return { size: body.byteLength };
+        },
+        async get(_actor, key) {
+            const found = stored.get(key);
+            sink.files.push({ action: 'get', key, bytes: found === undefined ? null : found.body.byteLength });
+            return found === undefined ? null : { body: found.body, contentType: found.contentType };
+        },
+        async signedUrl(_actor, key, expiresInSeconds) {
+            sink.files.push({ action: 'signed', key, bytes: null });
+            return `https://files.invalid/unsigned-in-memory/${encodeURIComponent(key)}?expires_in=${String(expiresInSeconds)}`;
+        },
+        async remove(_actor, key) {
+            stored.delete(key);
+            sink.files.push({ action: 'remove', key, bytes: null });
+        },
+    };
+    const answers = opts?.views;
+    const views = answers === undefined
+        ? undefined
+        : {
+            async query(_actor, sql, params) {
+                const found = (answers[sql] ?? []);
+                sink.queries.push({ sql, params, rows: found.length });
+                return found;
+            },
+        };
+    return {
+        seams: {
+            store, telemetry, log, audit, errors, search, cost, idempotency, events, rateLimiter, queue,
+            outbox, files, clock: { now: arrived }, random: { next: Math.random, uuid: fresh },
+            ...(featureGate ? { featureGate } : {}),
+            ...(quotas ? { quotas } : {}),
+            ...(vault ? { vault } : {}),
+            ...(views ? { views } : {}),
+        },
+        sink, store, queue,
+    };
+}

package/dist/operations/metering.d.ts

@@ -0,0 +1,55 @@
+import { PlatformError } from './errors/catalog.ts';
+import type { PropertyValue, Search, Seams, Store, Views } from './seams.ts';
+export interface ActionBudget {
+    readonly roundTrips: number;
+}
+export interface WriteAmplification {
+    readonly entity: string;
+    readonly id: string;
+    readonly columns: readonly string[];
+    readonly bytes: number;
+}
+export interface DatabaseUsage {
+    readonly roundTrips: number;
+    readonly rowsRead: number;
+    readonly rowsWritten: number;
+    readonly bytesRead: number;
+    readonly bytesWritten: number;
+    readonly amplified: readonly WriteAmplification[];
+}
+export declare class RoundTripBudgetExceededError extends PlatformError {
+    readonly budget: number;
+    readonly refusedStatement: string;
+    constructor(budget: number, statement: string);
+}
+export declare const BUDGET_EXCEEDED_BECAUSE = "round_trip_budget_exceeded";
+export declare const DB_USAGE_PROPERTY = "db";
+export declare const DB_USAGE_ATTRIBUTES: {
+    readonly roundTrips: "thread.db.round_trips";
+    readonly rowsRead: "thread.db.rows_read";
+    readonly rowsWritten: "thread.db.rows_written";
+    readonly bytesRead: "thread.db.bytes_read";
+    readonly bytesWritten: "thread.db.bytes_written";
+    readonly budgetRoundTrips: "thread.db.budget_round_trips";
+};
+export declare const DB_AMPLIFICATION_PROPERTY = "db_amplification";
+export declare const DB_AMPLIFICATION_ATTRIBUTES: {
+    readonly entities: "thread.db.amplified_entities";
+    readonly columns: "thread.db.amplified_columns";
+    readonly bytes: "thread.db.amplified_bytes";
+    readonly writes: "thread.db.amplified_writes";
+};
+export declare function databaseUsageValues(usage: DatabaseUsage, budget?: ActionBudget): Readonly<Record<string, PropertyValue>>;
+export declare function writeAmplificationValues(usage: DatabaseUsage): Readonly<Record<string, PropertyValue>> | undefined;
+export declare function payloadBytes(value: unknown, depth?: number): number;
+export interface MeterableSeams {
+    readonly store?: Store;
+    readonly search?: Search;
+    readonly views?: Views;
+}
+export interface Metered<S> {
+    readonly seams: S;
+    usage(): DatabaseUsage;
+}
+export type MeteredSeams = Metered<Seams>;
+export declare function meterDatabase<S extends MeterableSeams>(seams: S, budget?: ActionBudget): Metered<S>;

package/dist/operations/metering.js

@@ -0,0 +1,247 @@
+import { PlatformError } from "./errors/catalog.js";
+import { DbRoundTripBudgetExceeded } from "./errors/errors.js";
+import { isTransactional } from "./seams.js";
+export class RoundTripBudgetExceededError extends PlatformError {
+    budget;
+    refusedStatement;
+    constructor(budget, statement) {
+        const detail = `this operation declared a budget of ${budget} database round trip(s) and asked for ` +
+            `"${statement}" as number ${budget + 1}`;
+        super(DbRoundTripBudgetExceeded.def, { detail, because: BUDGET_EXCEEDED_BECAUSE });
+        this.name = 'RoundTripBudgetExceededError';
+        this.message = detail;
+        this.budget = budget;
+        this.refusedStatement = statement;
+    }
+}
+export const BUDGET_EXCEEDED_BECAUSE = 'round_trip_budget_exceeded';
+export const DB_USAGE_PROPERTY = 'db';
+export const DB_USAGE_ATTRIBUTES = {
+    roundTrips: 'thread.db.round_trips',
+    rowsRead: 'thread.db.rows_read',
+    rowsWritten: 'thread.db.rows_written',
+    bytesRead: 'thread.db.bytes_read',
+    bytesWritten: 'thread.db.bytes_written',
+    budgetRoundTrips: 'thread.db.budget_round_trips',
+};
+export const DB_AMPLIFICATION_PROPERTY = 'db_amplification';
+export const DB_AMPLIFICATION_ATTRIBUTES = {
+    entities: 'thread.db.amplified_entities',
+    columns: 'thread.db.amplified_columns',
+    bytes: 'thread.db.amplified_bytes',
+    writes: 'thread.db.amplified_writes',
+};
+export function databaseUsageValues(usage, budget) {
+    return {
+        [DB_USAGE_ATTRIBUTES.roundTrips]: usage.roundTrips,
+        [DB_USAGE_ATTRIBUTES.rowsRead]: usage.rowsRead,
+        [DB_USAGE_ATTRIBUTES.rowsWritten]: usage.rowsWritten,
+        [DB_USAGE_ATTRIBUTES.bytesRead]: usage.bytesRead,
+        [DB_USAGE_ATTRIBUTES.bytesWritten]: usage.bytesWritten,
+        ...(budget === undefined ? {} : { [DB_USAGE_ATTRIBUTES.budgetRoundTrips]: budget.roundTrips }),
+    };
+}
+export function writeAmplificationValues(usage) {
+    if (usage.amplified.length === 0)
+        return undefined;
+    const entities = [...new Set(usage.amplified.map((write) => write.entity))];
+    const columns = [...new Set(usage.amplified.flatMap((write) => write.columns))];
+    return {
+        [DB_AMPLIFICATION_ATTRIBUTES.entities]: entities.join(','),
+        [DB_AMPLIFICATION_ATTRIBUTES.columns]: columns.join(','),
+        [DB_AMPLIFICATION_ATTRIBUTES.bytes]: usage.amplified.reduce((total, write) => total + write.bytes, 0),
+        [DB_AMPLIFICATION_ATTRIBUTES.writes]: usage.amplified.length,
+    };
+}
+const MAX_WALK_DEPTH = 24;
+function utf8Length(text) {
+    let bytes = 0;
+    for (let index = 0; index < text.length; index += 1) {
+        const code = text.charCodeAt(index);
+        if (code < 0x80)
+            bytes += 1;
+        else if (code < 0x800)
+            bytes += 2;
+        else if (code >= 0xd800 && code <= 0xdbff && index + 1 < text.length) {
+            bytes += 4;
+            index += 1;
+        }
+        else
+            bytes += 3;
+    }
+    return bytes;
+}
+export function payloadBytes(value, depth = 0) {
+    if (value === null || value === undefined)
+        return 0;
+    if (depth > MAX_WALK_DEPTH)
+        return 0;
+    switch (typeof value) {
+        case 'string':
+            return utf8Length(value);
+        case 'number':
+        case 'boolean':
+        case 'bigint':
+            return 8;
+        case 'object':
+            break;
+        default:
+            return 0;
+    }
+    if (value instanceof Date)
+        return 8;
+    if (value instanceof Uint8Array)
+        return value.byteLength;
+    if (Array.isArray(value)) {
+        let total = 0;
+        for (const item of value)
+            total += payloadBytes(item, depth + 1);
+        return total;
+    }
+    let total = 0;
+    for (const [key, nested] of Object.entries(value)) {
+        total += utf8Length(key) + payloadBytes(nested, depth + 1);
+    }
+    return total;
+}
+function sameStoredValue(left, right, depth = 0) {
+    if (left === right)
+        return true;
+    if (depth > MAX_WALK_DEPTH)
+        return false;
+    if (left instanceof Date || right instanceof Date) {
+        return left instanceof Date && right instanceof Date && left.getTime() === right.getTime();
+    }
+    if (typeof left !== 'object' || typeof right !== 'object' || left === null || right === null)
+        return false;
+    if (Array.isArray(left) !== Array.isArray(right))
+        return false;
+    if (Array.isArray(left) && Array.isArray(right)) {
+        return left.length === right.length && left.every((item, index) => sameStoredValue(item, right[index], depth + 1));
+    }
+    const a = left;
+    const b = right;
+    const keys = Object.keys(a);
+    if (keys.length !== Object.keys(b).length)
+        return false;
+    return keys.every((key) => key in b && sameStoredValue(a[key], b[key], depth + 1));
+}
+export function meterDatabase(seams, budget) {
+    let roundTrips = 0;
+    let rowsRead = 0;
+    let rowsWritten = 0;
+    let bytesRead = 0;
+    let bytesWritten = 0;
+    const amplified = [];
+    const seen = new Map();
+    const remember = (entity, row) => {
+        seen.set(`${entity}:${row.id}`, row);
+    };
+    const spend = (statement) => {
+        if (budget !== undefined && roundTrips >= budget.roundTrips) {
+            throw new RoundTripBudgetExceededError(budget.roundTrips, statement);
+        }
+        roundTrips += 1;
+    };
+    const readRows = (rows) => {
+        rowsRead += rows.length;
+        for (const row of rows)
+            bytesRead += payloadBytes(row);
+    };
+    const base = seams.store;
+    const store = base === undefined ? undefined : {
+        async insert(actor, entity, row) {
+            spend(`insert ${entity}`);
+            bytesWritten += payloadBytes(row);
+            rowsWritten += 1;
+            const written = await base.insert(actor, entity, row);
+            remember(entity, written);
+            return written;
+        },
+        async get(actor, entity, id, fields) {
+            spend(`get ${entity}`);
+            const row = await base.get(actor, entity, id, fields);
+            if (row !== null) {
+                rowsRead += 1;
+                bytesRead += payloadBytes(row);
+                remember(entity, row);
+            }
+            return row;
+        },
+        async list(actor, entity, opts) {
+            spend(`list ${entity}`);
+            const rows = await base.list(actor, entity, opts);
+            readRows(rows);
+            for (const row of rows)
+                remember(entity, row);
+            return rows;
+        },
+        async update(actor, entity, id, patch, expectedVersion) {
+            spend(`update ${entity}`);
+            recordAmplification(entity, id, patch);
+            bytesWritten += payloadBytes(patch);
+            rowsWritten += 1;
+            const row = await base.update(actor, entity, id, patch, expectedVersion);
+            remember(entity, row);
+            return row;
+        },
+        async remove(actor, entity, id) {
+            spend(`remove ${entity}`);
+            rowsWritten += 1;
+            await base.remove(actor, entity, id);
+            seen.delete(`${entity}:${id}`);
+        },
+    };
+    if (base !== undefined && store !== undefined && isTransactional(base)) {
+        store.transaction = (actor, fn) => base.transaction(actor, fn);
+    }
+    function recordAmplification(entity, id, patch) {
+        const stored = seen.get(`${entity}:${id}`);
+        if (stored === undefined)
+            return;
+        const columns = [];
+        let bytes = 0;
+        for (const [column, value] of Object.entries(patch)) {
+            if (!(column in stored))
+                continue;
+            if (!sameStoredValue(value, stored[column]))
+                continue;
+            columns.push(column);
+            bytes += payloadBytes(value);
+        }
+        if (columns.length === 0)
+            return;
+        amplified.push({ entity, id: String(id), columns, bytes });
+    }
+    const views = seams.views === undefined
+        ? undefined
+        : {
+            async query(actor, sql, params) {
+                spend('view');
+                const rows = await seams.views.query(actor, sql, params);
+                readRows(rows);
+                return rows;
+            },
+        };
+    const baseSearch = seams.search;
+    const search = baseSearch === undefined
+        ? undefined
+        : {
+            index: (actor, entity, row) => baseSearch.index(actor, entity, row),
+            async query(actor, entity, q) {
+                spend(`search ${entity}`);
+                const rows = await baseSearch.query(actor, entity, q);
+                readRows(rows);
+                return rows;
+            },
+        };
+    const metered = {
+        ...(store === undefined ? {} : { store }),
+        ...(search === undefined ? {} : { search }),
+        ...(views === undefined ? {} : { views }),
+    };
+    return {
+        seams: { ...seams, ...metered },
+        usage: () => ({ roundTrips, rowsRead, rowsWritten, bytesRead, bytesWritten, amplified }),
+    };
+}

package/dist/operations/nodes.d.ts

@@ -0,0 +1,35 @@
+import type { Threaded } from '../core/thread.ts';
+import type { Operation } from './operations.ts';
+import type { Handed, Reads, Supplied } from './seams.ts';
+export interface Node extends Threaded {
+    readonly version: number;
+}
+export type Held<I = unknown> = Parameters<Operation<I>['run']>[1];
+export declare const STOPPED: unique symbol;
+export declare function stopped(thrown: unknown): {
+    readonly value: unknown;
+} | undefined;
+export declare const nd_read: <I, R extends string = Supplied>(block: (hands: Reads<Handed<R>>, held: Held<I>) => Promise<unknown>) => {
+    type: "nd_read";
+};
+export declare const nd_action: <I, R extends string = Supplied>(block: (hands: Handed<R>, held: Held<I>) => Promise<unknown>) => {
+    type: "nd_action";
+};
+export declare const nd_branch: <I, R extends string = Supplied>(choose: (hands: Reads<Handed<R>>, held: Held<I>) => Promise<string>, ways: Readonly<Record<string, (hands: Handed<R>, held: Held<I>) => Promise<unknown>>>) => {
+    type: "nd_branch";
+};
+export declare const nd_each: <I, R extends string = Supplied>(over: (held: Held<I>) => readonly unknown[], block: (item: unknown, hands: Handed<R>, held: Held<I>) => Promise<unknown>) => {
+    type: "nd_each";
+};
+export declare const nd_parallel: <I, R extends string = Supplied>(blocks: readonly ((hands: Handed<R>, held: Held<I>) => Promise<unknown>)[]) => {
+    type: "nd_parallel";
+};
+export declare const nd_repeat: <I, R extends string = Supplied>(ceiling: number, block: (pass: number, carried: unknown, hands: Handed<R>, held: Held<I>) => Promise<{
+    readonly done: boolean;
+    readonly value: unknown;
+}>) => {
+    type: "nd_repeat";
+};
+export declare const nd_stop: <I, R extends string = Supplied>(block: (hands: Reads<Handed<R>>, held: Held<I>) => Promise<unknown>) => {
+    type: "nd_stop";
+};