@glubean/sdk 0.3.2 → 0.5.0

package/dist/contract-flow-condition.js

@@ -0,0 +1,457 @@
+/**
+ * Conditional branching — predicate foundation (Phase 1).
+ *
+ * The declarative (L2) predicate layer for `flow().condition` / `switchOn` /
+ * `switchCond` (design: internal/40-discovery/proposals/contract-flow-condition.md).
+ *
+ * A predicate is built ONLY through `predicateScope(...)` (`when` / `all` / `any`
+ * / `not`) — never hand-authored — so every node is:
+ *   - **branded** (unforgeable: a module-private symbol users can't set), so a
+ *     plain object literal is not assignable where a `BranchPredicate` is expected;
+ *   - **path-extracted at construction** via the strict lens Proxy, so runtime
+ *     evaluation reads a captured path (safe traversal, never re-invokes the lens);
+ *   - **gated**: the lens must be a single member-access chain (no calls / ternary
+ *     / operators / free-variable reads) — the projection guarantee depends on it;
+ *   - **frozen** (deeply), so it can't be mutated after the purity checks ran.
+ *
+ * This file is the L2 declarative tier only. Runtime branch nodes, the builder
+ * surface, and the opaque (L1/L0) tiers land in later phases.
+ */
+import { extractSelectorPath, LensPurityError } from "./contract-core.js";
+// Unforgeable brand: a module-private symbol attached (non-enumerable) to every
+// node produced by `when`/`all`/`any`/`not`. It is a REAL runtime symbol (not a
+// type-only `declare const`), so `assertL2Predicate` can reject a hand-authored
+// declarative object — which never went through the selector source / strict
+// Proxy gate — even from JS / `as any` callers. Not exported, so unforgeable.
+const PREDICATE_BRAND = Symbol("glubean.branch-predicate");
+// --- P0 single-selector source gate -----------------------------------------
+/**
+ * Reject any lens that is not a single member-access chain off its one
+ * parameter (optional chaining allowed): `s => s.a.b`, `s => s.a?.b`.
+ *
+ * The strict lens Proxy already throws on method calls / `new` / arithmetic
+ * (via coercion), but it CANNOT see a pure ternary (`s.flag ? s.a : s.b` —
+ * `ToBoolean` on the proxy object never traps) or a free-variable / `Date.now()`
+ * read that bypasses the state entirely. This source check closes both: the
+ * projected path is then guaranteed to match what runs. (Full AST analysis is
+ * a future P1 enrichment; this string check is the P0 gate.)
+ */
+export function assertSelectorSource(fn) {
+    const src = fn.toString().trim();
+    const arrowAt = src.indexOf("=>");
+    if (arrowAt < 0) {
+        throw new LensPurityError("lens", "predicate lens must be an arrow function");
+    }
+    const paramSrc = src.slice(0, arrowAt).trim();
+    const pm = paramSrc.match(/^\(?\s*([A-Za-z_$][\w$]*)\s*\)?$/);
+    if (!pm) {
+        throw new LensPurityError("lens", `predicate lens must be a single-parameter arrow (no async, no destructuring); got "${paramSrc} =>"`);
+    }
+    const param = pm[1];
+    let body = src.slice(arrowAt + 2).trim();
+    if (body.startsWith("{")) {
+        const bm = body.match(/^\{\s*return\s+([\s\S]+?);?\s*\}$/);
+        if (!bm) {
+            throw new LensPurityError("lens", "predicate lens with a block body must be a single `return <member chain>`");
+        }
+        body = bm[1].trim();
+    }
+    // strip balanced wrapping parens
+    while (body.startsWith("(") && body.endsWith(")"))
+        body = body.slice(1, -1).trim();
+    const escaped = param.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const chain = new RegExp(`^${escaped}(?:\\??\\.[A-Za-z_$][\\w$]*)+$`);
+    if (!chain.test(body)) {
+        throw new LensPurityError("lens", `predicate lens must be a single member-access chain off "${param}" ` +
+            `(no calls, operators, ternaries, indexing, or other identifiers); got: ${body}`);
+    }
+}
+// --- operand validation ------------------------------------------------------
+function assertFiniteScalar(value, op) {
+    if (typeof value === "number" && !Number.isFinite(value)) {
+        throw new LensPurityError(`predicate.${op}`, `operand must be a finite number; NaN/Infinity are not JSON-safe and never match`);
+    }
+}
+const RELATIONAL_OPS = new Set(["gt", "gte", "lt", "lte"]);
+/**
+ * Relational ops (gt/gte/lt/lte) require a numeric operand. The type layer
+ * already enforces this, but JS / `as any` callers could pass a string / null /
+ * boolean, and runtime comparison would then rely on JS coercion (e.g.
+ * `5 > null` is `true`) — silently wrong. Reject at construction + validation.
+ */
+function assertRelationalOperand(op, value) {
+    if (RELATIONAL_OPS.has(op) && typeof value !== "number") {
+        throw new LensPurityError(`predicate.${op}`, `relational operand for "${op}" must be a number; got ${value === null ? "null" : typeof value}`);
+    }
+}
+/**
+ * Reject anything that isn't a JSON scalar (string / number / boolean / null).
+ * The type layer already enforces this for typed callers, but JS / `as any`
+ * callers can smuggle in `undefined` (dropped by JSON.stringify), `bigint`
+ * (JSON.stringify throws), symbols, objects, or functions — all of which would
+ * make the extracted projection non-JSON-safe and break scanner/Cloud.
+ */
+function assertJsonScalar(value, op) {
+    if (value === null)
+        return;
+    const t = typeof value;
+    if (t === "string" || t === "number" || t === "boolean")
+        return;
+    throw new LensPurityError(`${op}`, `case value must be a JSON scalar (string / number / boolean / null); got ${t}`);
+}
+/**
+ * Validate value-switch case values (build-time). A value-switch is an exact
+ * match-set, so values must be:
+ *   1. JSON scalars — non-scalars (undefined/bigint/symbol/object/function) are
+ *      not projection-safe (see assertJsonScalar);
+ *   2. unique — a duplicate makes the second case unreachable (first-match) and
+ *      turns the switch order-dependent, violating "order doesn't matter";
+ *   3. finite (numbers) — NaN/Infinity become `null` under JSON.stringify (not
+ *      projection-safe) and `=== NaN` never matches.
+ */
+export function assertSwitchCaseValues(values) {
+    const seen = new Set();
+    for (const v of values) {
+        assertJsonScalar(v, "switchOn");
+        assertFiniteScalar(v, "switchOn");
+        if (seen.has(v)) {
+            throw new LensPurityError("switchOn", `duplicate case value ${JSON.stringify(v)} — value-switch values must be unique ` +
+                `(a duplicate is unreachable under first-match and makes the switch order-dependent)`);
+        }
+        seen.add(v);
+    }
+}
+// --- predicate construction (the only way to make a BranchPredicate) ---------
+function brandFreeze(node) {
+    // Real runtime brand (non-enumerable so it never leaks into spreads / JSON /
+    // the extracted projection), then deep-freeze. Only this function sets it.
+    Object.defineProperty(node, PREDICATE_BRAND, {
+        value: true,
+        enumerable: false,
+        writable: false,
+        configurable: false,
+    });
+    return Object.freeze(node);
+}
+/** Runtime brand check — true only for nodes produced by `predicateScope`. */
+function isBrandedPredicate(node) {
+    return (typeof node === "object" &&
+        node !== null &&
+        node[PREDICATE_BRAND] === true);
+}
+function selectorPath(lens) {
+    assertSelectorSource(lens); // P0 source gate (ternary / free-var / calls)
+    return Object.freeze(extractSelectorPath(lens)); // strict-Proxy path + Proxy purity
+}
+/**
+ * Build a `PredicateScope<S>`. The runtime is untyped (`any`); the public typing
+ * comes from the `PredicateScope<S>` / `WhenClause<S, V>` interfaces it is cast to.
+ */
+export function predicateScope() {
+    const when = (lens) => {
+        const path = selectorPath(lens);
+        const compare = (op, value) => {
+            assertJsonScalar(value, `predicate.${op}`);
+            assertFiniteScalar(value, op);
+            assertRelationalOperand(op, value);
+            return brandFreeze({ kind: "compare", op, lens, path, value });
+        };
+        return {
+            eq: (value) => compare("eq", value),
+            ne: (value) => compare("ne", value),
+            gt: (value) => compare("gt", value),
+            gte: (value) => compare("gte", value),
+            lt: (value) => compare("lt", value),
+            lte: (value) => compare("lte", value),
+            in: (values) => {
+                values.forEach((v) => {
+                    assertJsonScalar(v, "predicate.in");
+                    assertFiniteScalar(v, "in");
+                });
+                return brandFreeze({ kind: "in", lens, path, values: Object.freeze([...values]) });
+            },
+            exists: () => brandFreeze({ kind: "presence", op: "exists", lens, path }),
+            absent: () => brandFreeze({ kind: "presence", op: "absent", lens, path }),
+            truthy: () => brandFreeze({ kind: "presence", op: "truthy", lens, path }),
+            falsy: () => brandFreeze({ kind: "presence", op: "falsy", lens, path }),
+            matches: (pattern) => {
+                const re = typeof pattern === "string" ? new RegExp(pattern) : pattern;
+                return brandFreeze({
+                    kind: "matches",
+                    lens,
+                    path,
+                    pattern: re.source,
+                    ...(re.flags ? { flags: re.flags } : {}),
+                });
+            },
+        };
+    };
+    const combine = (kind, clauses) => {
+        if (clauses.length === 0) {
+            throw new LensPurityError(`predicate.${kind}`, `${kind}() needs at least one clause`);
+        }
+        return brandFreeze({ kind, clauses: Object.freeze([...clauses]) });
+    };
+    return {
+        when: when,
+        all: (...clauses) => combine("and", clauses),
+        any: (...clauses) => combine("or", clauses),
+        not: (clause) => brandFreeze({ kind: "not", clause }),
+    };
+}
+// --- runtime evaluation ------------------------------------------------------
+/** Safe path traversal: returns `undefined` if any intermediate is null/undefined. */
+function resolvePath(state, path) {
+    let cur = state;
+    for (const seg of path) {
+        if (cur === null || cur === undefined)
+            return undefined;
+        cur = cur[seg];
+    }
+    return cur;
+}
+/** Evaluate a declarative predicate against a concrete state. Pure, no I/O. */
+export function evalPredicate(pred, state) {
+    switch (pred.kind) {
+        case "compare": {
+            const actual = resolvePath(state, pred.path);
+            switch (pred.op) {
+                case "eq":
+                    return actual === pred.value;
+                case "ne":
+                    return actual !== pred.value;
+                case "gt":
+                    return typeof actual === "number" && actual > pred.value;
+                case "gte":
+                    return typeof actual === "number" && actual >= pred.value;
+                case "lt":
+                    return typeof actual === "number" && actual < pred.value;
+                case "lte":
+                    return typeof actual === "number" && actual <= pred.value;
+            }
+            return false;
+        }
+        case "in": {
+            const actual = resolvePath(state, pred.path);
+            return pred.values.some((v) => v === actual);
+        }
+        case "presence": {
+            const actual = resolvePath(state, pred.path);
+            switch (pred.op) {
+                case "exists":
+                    return actual !== undefined;
+                case "absent":
+                    return actual === undefined;
+                case "truthy":
+                    return !!actual;
+                case "falsy":
+                    return !actual;
+            }
+            return false;
+        }
+        case "matches": {
+            const actual = resolvePath(state, pred.path);
+            return typeof actual === "string" && new RegExp(pred.pattern, pred.flags).test(actual);
+        }
+        case "and":
+            return pred.clauses.every((c) => evalPredicate(c, state));
+        case "or":
+            return pred.clauses.some((c) => evalPredicate(c, state));
+        case "not":
+            return !evalPredicate(pred.clause, state);
+    }
+}
+// --- L2 predicate tree validation (second line of defense) -------------------
+const COMPARE_OPS = new Set(["eq", "ne", "gt", "gte", "lt", "lte"]);
+const PRESENCE_OPS = new Set(["exists", "absent", "truthy", "falsy"]);
+function assertPath(path, op) {
+    if (!Array.isArray(path) || !path.every((seg) => typeof seg === "string")) {
+        throw new LensPurityError(op, `predicate path must be a string[]`);
+    }
+}
+/**
+ * Recursively validate a declarative (L2) predicate tree before it is stored
+ * by `condition` / `switchCond`. The `BranchPredicate` brand is type-only
+ * (erased at runtime), so a JS / `as any` caller could return a hand-forged
+ * object from the predicate callback — e.g. `{ kind: "opaque", ... }` (which
+ * would bypass the `conditionFn`/`conditionAsync` message requirement and emit
+ * an unlabeled opaque gate) or a node with a non-JSON `value`. This is the
+ * runtime counterpart to the (type-only) brand: it guarantees every stored L2
+ * predicate is a well-formed, JSON-safe declarative tree.
+ */
+export function assertL2Predicate(node, op = "condition") {
+    // Brand gate (primary): only nodes built by `predicateScope` carry the
+    // module-private brand, so a hand-authored object — which bypassed the
+    // selector source / strict-Proxy gate (its `path` could reference anything) —
+    // is rejected here even from JS / `as any`. The structural checks below are
+    // belt-and-suspenders for the (already-validated) branded shape.
+    if (!isBrandedPredicate(node)) {
+        throw new LensPurityError(op, `${op}() requires a declarative predicate built via the predicate scope ` +
+            `(w.when / all / any / not). The value did not come from the scope — ` +
+            `forged / hand-authored predicate objects are rejected (they bypass the ` +
+            `selector source + purity gate). For opaque logic use conditionFn / conditionAsync.`);
+    }
+    const n = node;
+    switch (n.kind) {
+        case "compare": {
+            const c = node;
+            if (typeof c.op !== "string" || !COMPARE_OPS.has(c.op)) {
+                throw new LensPurityError(op, `invalid compare op ${JSON.stringify(c.op)}`);
+            }
+            assertPath(c.path, op);
+            assertJsonScalar(c.value, op);
+            assertFiniteScalar(c.value, op);
+            assertRelationalOperand(c.op, c.value);
+            return;
+        }
+        case "in": {
+            const c = node;
+            assertPath(c.path, op);
+            if (!Array.isArray(c.values)) {
+                throw new LensPurityError(op, `in.values must be an array`);
+            }
+            c.values.forEach((v) => {
+                assertJsonScalar(v, op);
+                assertFiniteScalar(v, op);
+            });
+            return;
+        }
+        case "presence": {
+            const c = node;
+            if (typeof c.op !== "string" || !PRESENCE_OPS.has(c.op)) {
+                throw new LensPurityError(op, `invalid presence op ${JSON.stringify(c.op)}`);
+            }
+            assertPath(c.path, op);
+            return;
+        }
+        case "matches": {
+            const c = node;
+            assertPath(c.path, op);
+            if (typeof c.pattern !== "string") {
+                throw new LensPurityError(op, `matches.pattern must be a string`);
+            }
+            if (c.flags !== undefined && typeof c.flags !== "string") {
+                throw new LensPurityError(op, `matches.flags must be a string`);
+            }
+            return;
+        }
+        case "and":
+        case "or": {
+            const c = node;
+            if (!Array.isArray(c.clauses) || c.clauses.length === 0) {
+                throw new LensPurityError(op, `${n.kind}.clauses must be a non-empty array`);
+            }
+            c.clauses.forEach((cl) => assertL2Predicate(cl, op));
+            return;
+        }
+        case "not": {
+            const c = node;
+            assertL2Predicate(c.clause, op);
+            return;
+        }
+        default:
+            throw new LensPurityError(op, `${op}() requires a declarative (L2) predicate from the predicate scope; ` +
+                `got kind ${JSON.stringify(n.kind)}. For opaque / async logic use ` +
+                `conditionFn / conditionAsync (which require a \`message\`).`);
+    }
+}
+function isOpaque(p) {
+    return p.kind === "opaque";
+}
+/** Evaluate one predicate-mode case predicate (L2 declarative sync / L1 sync / L0 async). */
+async function evalCasePredicate(pred, state, ctx) {
+    if (isOpaque(pred)) {
+        const out = pred.fn(ctx, state);
+        if (pred.sync && out && typeof out.then === "function") {
+            throw new Error("conditionFn (L1) predicate must be synchronous — it returned a thenable. Use conditionAsync for async/I-O predicates.");
+        }
+        const result = await out;
+        // The API types the predicate as `boolean`, but JS / `as any` callers can
+        // return a truthy non-boolean (e.g. the string "false", an object). Fail
+        // fast instead of letting `selectBranchSteps`' `if` silently take a branch
+        // on a coerced value.
+        if (typeof result !== "boolean") {
+            throw new Error(`${pred.sync ? "conditionFn (L1)" : "conditionAsync (L0)"} predicate must return a boolean; ` +
+                `got ${result === null ? "null" : typeof result}`);
+        }
+        return result;
+    }
+    return evalPredicate(pred, state);
+}
+/**
+ * Select the steps a branch takes against a concrete state (first-match → default).
+ * Always async (L0 opaque predicates may be async). For value-mode the subject lens
+ * is evaluated exactly once: flow uses the captured `path` (safe traversal, no throw
+ * on missing intermediates), test calls the lens.
+ */
+export async function selectBranchSteps(step, state, ctx) {
+    if (step.mode === "value") {
+        const subject = step.subject.path
+            ? resolvePath(state, step.subject.path)
+            : step.subject.lens(ctx, state);
+        for (const c of step.cases) {
+            if (subject === c.value)
+                return c.steps;
+        }
+        return step.default;
+    }
+    for (const c of step.cases) {
+        if (await evalCasePredicate(c.predicate, state, ctx))
+            return c.steps;
+    }
+    return step.default;
+}
+/** Map a runtime predicate (path already captured at construction) to JSON-safe form. */
+export function extractPredicate(pred) {
+    if (isOpaque(pred)) {
+        return { kind: "opaque", strictness: pred.sync ? "L1" : "L0", mayDoAsyncIO: !pred.sync };
+    }
+    switch (pred.kind) {
+        case "compare":
+            return { kind: "compare", op: pred.op, path: [...pred.path], value: pred.value };
+        case "in":
+            return { kind: "in", path: [...pred.path], values: [...pred.values] };
+        case "presence":
+            return { kind: "presence", op: pred.op, path: [...pred.path] };
+        case "matches":
+            return {
+                kind: "matches",
+                path: [...pred.path],
+                pattern: pred.pattern,
+                ...(pred.flags ? { flags: pred.flags } : {}),
+            };
+        case "and":
+        case "or":
+            return { kind: pred.kind, clauses: pred.clauses.map(extractPredicate) };
+        case "not":
+            return { kind: "not", clause: extractPredicate(pred.clause) };
+    }
+}
+/**
+ * Normalize a runtime branch step to JSON-safe form. `recurse` normalizes a
+ * sub-step list (provided by normalizeFlow so nested branches recurse).
+ */
+export function extractBranchStep(step, recurse) {
+    if (step.mode === "value") {
+        return {
+            kind: "branch",
+            mode: "value",
+            ...(step.name ? { name: step.name } : {}),
+            subjectPath: step.subject.path ? [...step.subject.path] : [],
+            cases: step.cases.map((c) => ({ value: c.value, steps: recurse(c.steps) })),
+            default: recurse(step.default),
+        };
+    }
+    return {
+        kind: "branch",
+        mode: "predicate",
+        ...(step.name ? { name: step.name } : {}),
+        cases: step.cases.map((c) => ({
+            ...(c.message ? { message: c.message } : {}),
+            predicate: extractPredicate(c.predicate),
+            steps: recurse(c.steps),
+        })),
+        default: recurse(step.default),
+    };
+}
+//# sourceMappingURL=contract-flow-condition.js.map

package/dist/contract-flow-condition.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract-flow-condition.js","sourceRoot":"","sources":["../src/contract-flow-condition.ts"],"names":[],"mappings":"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"}

package/dist/contract-flow-poll.d.ts

@@ -0,0 +1,157 @@
+/**
+ * @module contract-flow-poll
+ *
+ * Bounded poll-until primitive for `contract.flow()` — runtime + projection.
+ *
+ * A poll repeats ONE contract case until an exit predicate over the RESPONSE
+ * holds, BOUNDED by a total wall-clock deadline and/or a finite per-attempt
+ * budget. It is the projectable subset of "loop" (a self-loop on one node), as
+ * opposed to the arbitrary loops that stay in `test()`. See the design proposal
+ * `internal/40-discovery/proposals/contract-flow-poll.md`.
+ *
+ * This module owns the poll-specific runtime types, the bounded-retry helpers
+ * (quarantined ctx, budget race), the exit-predicate evaluator (three strictness
+ * tiers, reusing the condition predicate foundation), the build-time bound
+ * validation, and the JSON-safe projection. The execution LOOP lives in
+ * `contract-core.ts` (it needs the shared committed-state cell).
+ */
+import type { ContractCaseRef, ProtocolContract, FieldMapping } from "./contract-types.js";
+import type { TestContext } from "./types.js";
+import { type BranchPredicate, type ExtractedPredicate } from "./contract-flow-condition.js";
+/**
+ * Runtime representation of a `flow().poll()` step. Carries live callbacks +
+ * the live contract ref. Never serialized — `extractPollStep` produces the
+ * JSON-safe form.
+ *
+ * The exit predicate (`until`) is over the RESPONSE (not state): L2 declarative
+ * (`BranchPredicate`, projectable) or opaque (L1 sync / L0 async, marked). The
+ * opaque form additionally receives `state` so a poll can wait for the response
+ * to reflect something already in state (e.g. `res.version >= state.lastSeen`).
+ */
+export interface RuntimePollStep {
+    kind: "poll";
+    name?: string;
+    ref: ContractCaseRef<any, any, any, any>;
+    caseKey: string;
+    /** Live contract instance (mirrors ref.contract). */
+    contract: ProtocolContract<any, any, any>;
+    bindings?: {
+        in?: (state: any) => any;
+        out?: (state: any, response: any) => any;
+        accept?: readonly unknown[];
+    };
+    /** Exit predicate — L2 declarative (over the response) or opaque (gets ctx, res, state). */
+    until: BranchPredicate<any> | {
+        kind: "opaque";
+        sync: boolean;
+        fn: (ctx: TestContext, res: any, state: any) => boolean | Promise<boolean>;
+    };
+    /** Author-supplied label (opaque tiers require it; L2 can auto-generate). */
+    message?: string;
+    /** Interval between attempts (ms). */
+    every: number;
+    /** Multiplier applied to `every` after each retry (1 = fixed). Capped at BACKOFF_CAP_MS. */
+    backoff: number;
+    /** Total wall-clock bound (ms). */
+    timeoutMs?: number;
+    /** Per-attempt budget (ms) — required when `timeoutMs` is absent. */
+    perAttemptTimeoutMs?: number;
+    /** Max attempts (>= 1). */
+    maxAttempts?: number;
+}
+/** Backoff cap — mirrors the test() step retry-backoff ceiling. */
+export declare const BACKOFF_CAP_MS = 30000;
+/** Default interval between attempts when `every` is omitted. */
+export declare const DEFAULT_EVERY_MS = 1000;
+export declare class PollExhaustedError extends Error {
+    readonly attempts: number;
+    constructor(stepLabel: string, attempts: number, detail?: string);
+}
+/**
+ * A child `TestContext` that isolates the **pass/fail-affecting** APIs of a poll
+ * attempt — `assert` / `expect` / `validate` / `fail` — so a probe's validation
+ * noise or a timed-out orphan's late failure cannot corrupt the run's pass/fail
+ * outcome. Those are buffered and either flushed (the satisfying attempt / an
+ * in-budget deliberate failure) or discarded (probe / orphan).
+ *
+ * Everything else PASSES THROUGH to the real ctx and emits per-attempt, by
+ * design — and this is deliberate, not an oversight:
+ *   - Observability (`trace` / `metric` / `log` / `action` / `event`): the
+ *     polling requests genuinely happened; their traces/metrics are wanted (you
+ *     want to see "polled 3×"). Buffering them would also be inconsistent: the
+ *     adapter's HTTP client is pre-bound to the real ctx at construction, so its
+ *     auto-traces emit to the real ctx regardless of this wrapper — there is no
+ *     way to intercept them here, so we don't pretend to.
+ *   - Accessors / side effects (`vars` / `secrets` / `session` / `http`): a
+ *     predicate that reads/writes these runs against the live ctx, exactly like
+ *     a condition predicate does (which is also evaluated against the real ctx).
+ *
+ * `skip` is pure control flow — the real `skip` only throws a SkipError (it
+ * emits nothing), so it is delegated. The poll loop catches any rejection from a
+ * raced-out attempt so a late skip/fail cannot surface as an unhandled rejection.
+ */
+export interface QuarantinedContext extends TestContext {
+    /** Replay all buffered emissions onto a real ctx (the satisfying attempt / in-budget predicate). */
+    flushTo(target: TestContext): void;
+    /** True if any buffered assertion / validation / fail recorded a failure. */
+    hasFailure(): boolean;
+}
+export declare function quarantinedCtx(real: TestContext): QuarantinedContext;
+/**
+ * Race a promise against a finite budget (ms). If the budget elapses first,
+ * reject with `onTimeout()`. A non-finite budget degrades to a plain await
+ * (build-time validation guarantees attempt budgets are finite, so this only
+ * happens defensively).
+ */
+export declare function raceBudget<T>(promise: Promise<T>, budgetMs: number, onTimeout: () => Error): Promise<T>;
+/**
+ * Evaluate a poll exit predicate. L2 declarative reads the RESPONSE (`evalPredicate`
+ * with subject = response). Opaque tiers get `(ctx, res, state)`. Non-boolean
+ * results fail fast (mirrors condition Phase 6); a thrown error / `ctx.skip()`
+ * propagates to the caller.
+ */
+export declare function evalPollExit(until: RuntimePollStep["until"], response: unknown, ctx: TestContext, state: unknown): Promise<boolean>;
+/**
+ * Validate poll bounds at construction. Two rules (both required), plus
+ * finiteness on every timing value (an `Infinity` bound would un-bound the loop):
+ *   1. total stop condition: `timeout` OR `maxAttempts`
+ *   2. finite per-attempt budget: `timeout` OR `perAttemptTimeout`
+ * (so `maxAttempts`-only — with no per-attempt budget — is illegal: a single
+ * hung request/predicate could block forever before the attempt counter advances.)
+ */
+export declare function validatePollBounds(bounds: {
+    timeout?: number;
+    maxAttempts?: number;
+    perAttemptTimeout?: number;
+    every?: number;
+    backoff?: number;
+}, stepLabel: string): void;
+export interface ExtractedPollStep {
+    kind: "poll";
+    name?: string;
+    contractId: string;
+    caseKey: string;
+    protocol: string;
+    target: string;
+    inputs?: FieldMapping[];
+    outputs?: FieldMapping[];
+    accept?: ReadonlyArray<string | number>;
+    /** Exit predicate — L2 precise (compare/in/...) or `{kind:"opaque",...}`. */
+    until: ExtractedPredicate;
+    message?: string;
+    every: number;
+    backoff: number;
+    timeoutMs?: number;
+    perAttemptTimeoutMs?: number;
+    maxAttempts?: number;
+}
+/**
+ * Normalize a runtime poll step to JSON-safe form. `dryRun` produces the
+ * input/output field mappings (the same Proxy dry-run normalizeFlow uses for a
+ * contract-call step), so the poll node carries data-flow edges like a step.
+ */
+export declare function extractPollStep(step: RuntimePollStep, dryRun: (step: RuntimePollStep) => {
+    inputs?: FieldMapping[];
+    outputs?: FieldMapping[];
+}): ExtractedPollStep;
+//# sourceMappingURL=contract-flow-poll.d.ts.map

package/dist/contract-flow-poll.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract-flow-poll.d.ts","sourceRoot":"","sources":["../src/contract-flow-poll.ts"],"names":[],"mappings":"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"}