@workerstack/testing 0.0.0-stage → 0.31.0

package/dist/api/runtime/feature-gate.js

@@ -0,0 +1,47 @@
+/**
+ * When a 403 is the document, not a defect.
+ *
+ * `x-feature-gate` names a plan key. A free principal hitting that route and receiving
+ * `vars.type === "feature_gate"` is the product working as published. Treating that the same as
+ * a broken create is the class of mistake that turns a correct backend into `world.seed` BLOCKED.
+ */
+/** Forbidden status unless a later abstraction names another one — the documented default. */
+export const FEATURE_GATE_STATUS = 403;
+export function isDocumentedFeatureGateDenial(op, status, body) {
+    if (op.featureGate === null)
+        return false;
+    if (status !== FEATURE_GATE_STATUS)
+        return false;
+    if (body === null || typeof body !== "object")
+        return false;
+    const vars = body["vars"];
+    if (vars === null || typeof vars !== "object")
+        return false;
+    const rec = vars;
+    if (rec["type"] !== "feature_gate")
+        return false;
+    /* A string that disagrees with the tag is backend/tag drift — keep today's failure. Absent
+     * `vars.feature` is enough together with `type`; do not invent a mismatch. */
+    if (typeof rec["feature"] === "string" && rec["feature"] !== op.featureGate)
+        return false;
+    return true;
+}
+export function describeFeatureGate(op, body) {
+    const key = op.featureGate ?? "unknown";
+    const vars = featureGateVars(body);
+    if (vars === null)
+        return `x-feature-gate: ${key}`;
+    const extras = ["current_plan", "required_plan", "feature"]
+        .filter((name) => typeof vars[name] === "string")
+        .map((name) => `${name}: ${vars[name]}`);
+    return extras.length === 0 ? `x-feature-gate: ${key}` : `x-feature-gate: ${key} (${extras.join(", ")})`;
+}
+export function featureGateVars(body) {
+    if (body === null || typeof body !== "object")
+        return null;
+    const vars = body["vars"];
+    if (vars === null || typeof vars !== "object")
+        return null;
+    return vars;
+}
+//# sourceMappingURL=feature-gate.js.map

package/dist/api/runtime/fence.d.ts

@@ -0,0 +1,29 @@
+/**
+ * A hook that sees every request before it leaves the process and may refuse it.
+ *
+ * A refused request never reaches the backend, so nothing about it can be a verdict on the
+ * backend: it surfaces as `FencedError` on the path the caller already treats as "could not
+ * finish" — a check unresolved, a cohort blocked, a teardown leftover — never as a response a
+ * check could read a status from. Every refusal is kept, so the report can list them all.
+ */
+import type { FenceDecision, FenceRequest } from "../config/types/hooks.ts";
+export interface FencedRequest {
+    method: string;
+    url: string;
+    operationId?: string;
+    phase: string;
+    reason: string;
+}
+export declare class FencedError extends Error {
+    readonly request: FencedRequest;
+    name: string;
+    constructor(request: FencedRequest);
+}
+export declare class Fence {
+    private readonly hook;
+    readonly fenced: FencedRequest[];
+    constructor(hook: (request: FenceRequest) => FenceDecision | Promise<FenceDecision>);
+    /** Resolves when the request may go; throws `FencedError`, after recording it, when it may not. */
+    check(request: FenceRequest): Promise<void>;
+}
+//# sourceMappingURL=fence.d.ts.map

package/dist/api/runtime/fence.js

@@ -0,0 +1,39 @@
+/**
+ * A hook that sees every request before it leaves the process and may refuse it.
+ *
+ * A refused request never reaches the backend, so nothing about it can be a verdict on the
+ * backend: it surfaces as `FencedError` on the path the caller already treats as "could not
+ * finish" — a check unresolved, a cohort blocked, a teardown leftover — never as a response a
+ * check could read a status from. Every refusal is kept, so the report can list them all.
+ */
+export class FencedError extends Error {
+    request;
+    name = "FencedError";
+    constructor(request) {
+        super(`fenced: ${request.reason} (${request.method} ${request.url})`);
+        this.request = request;
+    }
+}
+export class Fence {
+    hook;
+    fenced = [];
+    constructor(hook) {
+        this.hook = hook;
+    }
+    /** Resolves when the request may go; throws `FencedError`, after recording it, when it may not. */
+    async check(request) {
+        const decision = await this.hook(request);
+        if (decision.allow)
+            return;
+        const refused = {
+            method: request.method,
+            phase: request.phase,
+            reason: decision.reason,
+            url: request.url,
+            ...(request.operationId === undefined ? {} : { operationId: request.operationId }),
+        };
+        this.fenced.push(refused);
+        throw new FencedError(refused);
+    }
+}
+//# sourceMappingURL=fence.js.map

package/dist/api/runtime/fill-path.d.ts

@@ -0,0 +1,8 @@
+import type { ParamStyle } from "../spec/graph/parameters.ts";
+/**
+ * A path template with each `{name}` replaced by its value, written in the style the operation
+ * declares for it (simple unless it says label or matrix) and percent-encoded per RFC 3986. A
+ * missing value is a seed failure.
+ */
+export declare function fillPath(template: string, values: Record<string, string>, styles?: Readonly<Record<string, ParamStyle>>): string;
+//# sourceMappingURL=fill-path.d.ts.map

package/dist/api/runtime/fill-path.js

@@ -0,0 +1,16 @@
+import { serializeParam } from "../client/param-style.js";
+import { SeedError } from "./seed-error.js";
+/**
+ * A path template with each `{name}` replaced by its value, written in the style the operation
+ * declares for it (simple unless it says label or matrix) and percent-encoded per RFC 3986. A
+ * missing value is a seed failure.
+ */
+export function fillPath(template, values, styles = {}) {
+    return template.replace(/\{([^}]+)\}/g, (_, name) => {
+        const value = values[name];
+        if (value === undefined)
+            throw new SeedError(name, `no value for path parameter {${name}}`);
+        return serializeParam({ ...styles[name], in: "path", name }, value);
+    });
+}
+//# sourceMappingURL=fill-path.js.map

package/dist/api/runtime/finding-key.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The identity of a finding across runs.
+ *
+ * Two runs that hit the same defect word its detail the same way except for what is particular to
+ * the run: the ids the backend issued, the nonce the API tester salted its values with, timestamps, the port
+ * the backend listened on. Those are replaced with placeholders, and the summary is left out — it
+ * is prose that may be reworded — so a baseline matches the defect and a diff calls it persisting.
+ */
+import type { Finding } from "./finding.ts";
+export declare function normalizeDetail(detail: string): string;
+export declare function findingKey(finding: Pick<Finding, "check" | "entity" | "detail" | "operations" | "origin">): string;
+//# sourceMappingURL=finding-key.d.ts.map

package/dist/api/runtime/finding-key.js

@@ -0,0 +1,33 @@
+/**
+ * The identity of a finding across runs.
+ *
+ * Two runs that hit the same defect word its detail the same way except for what is particular to
+ * the run: the ids the backend issued, the nonce the API tester salted its values with, timestamps, the port
+ * the backend listened on. Those are replaced with placeholders, and the summary is left out — it
+ * is prose that may be reworded — so a baseline matches the defect and a diff calls it persisting.
+ */
+const RUN_SPECIFIC = [
+    [/\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/gi, "<uuid>"],
+    [/\b\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:?\d{2})?/g, "<time>"],
+    /* A run folder's stamp, `20261015T210304Z`. */
+    [/\b\d{8}T\d{6}Z?\b/g, "<stamp>"],
+    [/\bhttps?:\/\/[^/\s"'`)]+/g, "<origin>"],
+    [/\b[0-9A-HJKMNP-TV-Z]{26}\b/g, "<ulid>"],
+    /* `tbl_8f3k2`: a prefix and a suffix holding a digit. `created_at` and `proj_alpha` stay. */
+    [/\b[a-z][a-z0-9]{0,15}_(?=[A-Za-z0-9]*\d)[A-Za-z0-9]{3,}\b/g, "<id>"],
+    /* A nonce or hash: hex with both a digit and a letter, eight or more long. */
+    [/\b(?=[0-9a-f]*\d)(?=[0-9a-f]*[a-f])[0-9a-f]{8,}\b/g, "<hex>"],
+    /* Epoch times and other counters too long to be a quantity a reader compares. */
+    [/\b\d{10,}\b/g, "<n>"],
+];
+export function normalizeDetail(detail) {
+    let text = detail;
+    for (const [pattern, placeholder] of RUN_SPECIFIC)
+        text = text.replace(pattern, placeholder);
+    return text;
+}
+export function findingKey(finding) {
+    const operations = [...(finding.operations ?? [])].sort().join(",");
+    return [finding.origin ?? "", finding.check, finding.entity, operations, normalizeDetail(finding.detail)].join("|");
+}
+//# sourceMappingURL=finding-key.js.map

package/dist/api/runtime/finding.d.ts

@@ -0,0 +1,142 @@
+/**
+ * Findings carry their verdict, not a severity guess made at report time. The verdict is derived
+ * from what the evidence shows, which is what lets the report collapse cascades and lets the
+ * conformance suite assert "exactly this defect was detected".
+ */
+import type { Exchange } from "./exchange.ts";
+export type Verdict = "BACKEND_BUG" | "SPEC_BUG" | "SECURITY" | "AMBIGUITY" | "COVERAGE_GAP" | "BLOCKED";
+export interface Finding {
+    /** Stable identifier for the check that produced this — the conformance suite asserts on it. */
+    check: string;
+    verdict: Verdict;
+    entity: string;
+    summary: string;
+    detail: string;
+    evidence: Exchange[];
+    /** Set when the finding came from a non-primary `origins[]` host. */
+    origin?: string;
+    /** Fixture filename when `uploads.each` drove the invocation. */
+    fixture?: string;
+    /** Operations this finding judges. Absent on run-level findings (teardown, network, pacing). */
+    operations?: string[];
+    /** A baseline entry names it: still reported, no longer a reason the run fails. */
+    known?: {
+        reason: string;
+    };
+}
+/**
+ * Whether a finding is a root cause — what fails a run. Coverage gaps and blocks are what the API tester
+ * could not look at, not what it found. The console, the reports, the matrix and the exit code
+ * all ask this one question.
+ */
+export declare function isRootCause(finding: {
+    verdict: Verdict | string;
+}): boolean;
+/** A root cause no baseline entry names — what the verdict and every defect count count. */
+export declare function isFailingRootCause(finding: {
+    verdict: Verdict | string;
+    known?: unknown;
+}): boolean;
+/**
+ * How one run of a check ended. `run` returns one on every path, so a check cannot fall silent:
+ * it either asserted the property, reported a finding, could not reach a verdict, or stood down
+ * because what it tests is not there — and the last two say why.
+ */
+export type Outcome = {
+    kind: "asserted";
+    note?: string;
+} | {
+    kind: "finding";
+    verdict: Verdict;
+    note?: string;
+} | {
+    kind: "unresolved";
+    reason: string;
+} | {
+    kind: "stood-down";
+    reason: string;
+};
+/** The property was tested and passed — or, if the check reported along the way, did not. */
+export declare const ASSERTED: Outcome;
+/**
+ * The property passed, and how the backend behaved is worth saying — a policy the document leaves
+ * open, such as whether unknown query parameters are rejected or ignored.
+ */
+export declare function asserted(note: string): Outcome;
+/** The check does not apply here after all: what it tests is absent, for `reason`. */
+export declare function standDown(reason: string): Outcome;
+/**
+ * A check that ran, could not reach a verdict, and stopped.
+ *
+ * Distinct from a skip (the entity never had what the check needs) and from a pass (the property
+ * was tested and passed). Before this existed a check that bailed halfway — no matching field, an
+ * empty listing, a probe that errored — simply returned, and the report was identical to one
+ * where the property was verified. On a backend with several faults that is most of the suite
+ * going quiet at once, which is the precise moment a reader most needs to know it happened.
+ */
+export interface Inconclusive {
+    check: string;
+    entity: string;
+    /** Why no verdict was reachable, in the reader's terms. */
+    reason: string;
+    operations?: string[];
+}
+/** What a check states about a defect: the line a reader scans, the detail behind it, what proves it. */
+export interface Claim {
+    summary: string;
+    detail: string;
+    evidence: Exchange[];
+    /** Fixture filename when `uploads.each` drove the invocation. */
+    fixture?: string | undefined;
+}
+/** A gap proves nothing by exchange: it is what the API tester could not look at. */
+export type GapClaim = Omit<Claim, "evidence">;
+/** A check that could not run because `cause` failed first. */
+export interface BlockedClaim {
+    summary: string;
+    cause: string;
+    evidence?: Exchange[] | undefined;
+}
+/** What a view of the findings stamps on and enforces for what it records. */
+interface CollectorView {
+    /** The operations every finding it records is attributed to. */
+    operations?: readonly string[] | undefined;
+    /** The one check it accepts findings from. */
+    owner?: string | undefined;
+}
+export declare class FindingCollector {
+    #private;
+    readonly findings: Finding[];
+    readonly inconclusive: Inconclusive[];
+    constructor(findings?: Finding[], inconclusive?: Inconclusive[], view?: CollectorView);
+    /**
+     * A view that accepts findings only under `check`. Each check runs against one, so a check
+     * cannot report under another's id: a finding filed under the wrong id is proven by the wrong
+     * defect, and suppresses the wrong dependents.
+     */
+    ownedBy(check: string): FindingCollector;
+    /**
+     * A view over the same findings that attributes everything it records to `operations`.
+     *
+     * Each check runs against its own view, so a finding lands on the operations the check judges
+     * without threading an id through every call site. Read-only checks run concurrently, so a
+     * shared "current check" would attribute one check's finding to another.
+     */
+    attributed(operations: readonly string[]): FindingCollector;
+    /**
+     * Records that a check ran without reaching a verdict. Returns `undefined` so a check can
+     * `return ctx.findings.unresolved(...)` at the point it gives up, which keeps the reason
+     * beside the condition that caused it rather than in a comment.
+     */
+    unresolved(check: string, entity: string, reason: string): Outcome;
+    /** Records a finding. Every finding passes here, so here its text is made fit to share. */
+    report(finding: Finding): Outcome;
+    backend(check: string, entity: string, claim: Claim): Outcome;
+    security(check: string, entity: string, claim: Claim): Outcome;
+    spec(check: string, entity: string, claim: Claim): Outcome;
+    gap(check: string, entity: string, claim: GapClaim): Outcome;
+    blocked(check: string, entity: string, claim: BlockedClaim): Outcome;
+    byVerdict(verdict: Verdict): Finding[];
+}
+export {};
+//# sourceMappingURL=finding.d.ts.map

package/dist/api/runtime/finding.js

@@ -0,0 +1,151 @@
+/**
+ * Findings carry their verdict, not a severity guess made at report time. The verdict is derived
+ * from what the evidence shows, which is what lets the report collapse cascades and lets the
+ * conformance suite assert "exactly this defect was detected".
+ */
+/**
+ * Whether a finding is a root cause — what fails a run. Coverage gaps and blocks are what the API tester
+ * could not look at, not what it found. The console, the reports, the matrix and the exit code
+ * all ask this one question.
+ */
+export function isRootCause(finding) {
+    return finding.verdict !== "COVERAGE_GAP" && finding.verdict !== "BLOCKED";
+}
+/** A root cause no baseline entry names — what the verdict and every defect count count. */
+export function isFailingRootCause(finding) {
+    return isRootCause(finding) && finding.known === undefined;
+}
+/** The property was tested and passed — or, if the check reported along the way, did not. */
+export const ASSERTED = /* @__PURE__ */ Object.freeze({ kind: "asserted" });
+/**
+ * The property passed, and how the backend behaved is worth saying — a policy the document leaves
+ * open, such as whether unknown query parameters are rejected or ignored.
+ */
+export function asserted(note) {
+    return { kind: "asserted", note };
+}
+/** The check does not apply here after all: what it tests is absent, for `reason`. */
+export function standDown(reason) {
+    return { kind: "stood-down", reason };
+}
+/* A stack frame line as V8 prints it: a newline, indentation, then "at ...". */
+const STACK_FRAME = /\n[ \t]*at [^\n]*/g;
+/*
+ * An absolute path that names a user's directory: under /home/<user>, /Users/<user> or /root, or
+ * any path on a Windows drive, optionally as a file:// URL. A Unix path elsewhere is left alone,
+ * since an API route such as /rows/{id} reads the same and a report must keep it.
+ */
+const USER_PATH = /(?<![\w./\\-])(?:file:\/\/)?(?:\/(?:home|Users)\/[^\s/'"`()<>]+|\/root(?![^\s/'"`()<>])|[A-Za-z]:(?=[\\/]))[^\s'"`()<>]*/g;
+/* Everything up to the last path separator that something follows. */
+const DIRECTORIES = /^.*[\\/](?=[^\\/])/;
+/**
+ * `path` as a whole path, never inside a longer one: under cwd "/x/testing", "/x/testing2" and "/x/testing.bak"
+ * stay, while "/x/testing/a.ts" and a sentence ending "/x/testing." match.
+ */
+function wholePath(path) {
+    return new RegExp(String.raw `(?<![\w.-])${path.replaceAll(/[.*+?^${}()|[\]\\]/g, String.raw `\$&`)}(?![\w-]|\.\w)`, "g");
+}
+/**
+ * Text a report may carry. A report is shared beyond the machine that ran it, so no finding names
+ * where the API tester or its user lives:
+ * - every stack frame line ("\n    at ...") is dropped;
+ * - a path under the working directory is written relative to it, the directory itself as ".";
+ * - any other path in a user's directory (see `USER_PATH`) is cut to its last segment, so
+ *   "/home/ann/x/spec.yaml:3" reads "spec.yaml:3".
+ */
+function reportable(text) {
+    return text
+        .replaceAll(STACK_FRAME, "")
+        .replaceAll(wholePath(process.cwd()), ".")
+        .replaceAll(USER_PATH, (path) => path.replace(DIRECTORIES, ""));
+}
+export class FindingCollector {
+    findings;
+    inconclusive;
+    #operations;
+    #owner;
+    constructor(findings = [], inconclusive = [], view = {}) {
+        this.findings = findings;
+        this.inconclusive = inconclusive;
+        this.#operations = view.operations;
+        this.#owner = view.owner;
+    }
+    /**
+     * A view that accepts findings only under `check`. Each check runs against one, so a check
+     * cannot report under another's id: a finding filed under the wrong id is proven by the wrong
+     * defect, and suppresses the wrong dependents.
+     */
+    ownedBy(check) {
+        return new FindingCollector(this.findings, this.inconclusive, { operations: this.#operations, owner: check });
+    }
+    #own(check) {
+        if (this.#owner !== undefined && check !== this.#owner) {
+            throw new Error(`check "${this.#owner}" tried to report under "${check}"`);
+        }
+    }
+    /**
+     * A view over the same findings that attributes everything it records to `operations`.
+     *
+     * Each check runs against its own view, so a finding lands on the operations the check judges
+     * without threading an id through every call site. Read-only checks run concurrently, so a
+     * shared "current check" would attribute one check's finding to another.
+     */
+    attributed(operations) {
+        return new FindingCollector(this.findings, this.inconclusive, { operations, owner: this.#owner });
+    }
+    #stamp() {
+        return this.#operations === undefined ? {} : { operations: [...this.#operations] };
+    }
+    /**
+     * Records that a check ran without reaching a verdict. Returns `undefined` so a check can
+     * `return ctx.findings.unresolved(...)` at the point it gives up, which keeps the reason
+     * beside the condition that caused it rather than in a comment.
+     */
+    unresolved(check, entity, reason) {
+        this.#own(check);
+        const said = reportable(reason);
+        this.inconclusive.push({ check, entity, reason: said, ...this.#stamp() });
+        return { kind: "unresolved", reason: said };
+    }
+    /** Records a finding. Every finding passes here, so here its text is made fit to share. */
+    report(finding) {
+        this.#own(finding.check);
+        const recorded = {
+            ...finding,
+            detail: reportable(finding.detail),
+            summary: reportable(finding.summary),
+            ...(finding.operations === undefined ? this.#stamp() : {}),
+        };
+        this.findings.push(recorded);
+        if (recorded.verdict === "COVERAGE_GAP")
+            return standDown(recorded.summary);
+        if (recorded.verdict === "BLOCKED")
+            return { kind: "unresolved", reason: recorded.summary };
+        return { kind: "finding", verdict: recorded.verdict };
+    }
+    #claim(check, entity, claim) {
+        const { detail, evidence, fixture, summary, verdict } = claim;
+        const finding = { check, detail, entity, evidence, summary, verdict };
+        return this.report(fixture === undefined || fixture === "" ? finding : { ...finding, fixture });
+    }
+    backend(check, entity, claim) {
+        return this.#claim(check, entity, { ...claim, verdict: "BACKEND_BUG" });
+    }
+    security(check, entity, claim) {
+        return this.#claim(check, entity, { ...claim, verdict: "SECURITY" });
+    }
+    spec(check, entity, claim) {
+        return this.#claim(check, entity, { ...claim, verdict: "SPEC_BUG" });
+    }
+    gap(check, entity, claim) {
+        return this.#claim(check, entity, { ...claim, evidence: [], verdict: "COVERAGE_GAP" });
+    }
+    blocked(check, entity, claim) {
+        const { cause, evidence = [], summary } = claim;
+        return this.report({ check, detail: `blocked by ${cause}`, entity, evidence, summary, verdict: "BLOCKED" });
+    }
+    byVerdict(verdict) {
+        return this.findings.filter((f) => f.verdict === verdict);
+    }
+}
+//# sourceMappingURL=finding.js.map

package/dist/api/runtime/fixture.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Schema-driven fixture generation: the discriminating cohort.
+ *
+ * Valid-random data cannot test a query engine: `ilike` needs a substring, `order` needs a total
+ * order, escaping needs metacharacters. The API tester seeds a *cohort* — one record per variant, each shaped
+ * so some query assertion has signal — and derives everything from a seed so a failing run is
+ * exactly reproducible.
+ *
+ * The values themselves come from `generate.ts`, the one place the API tester invents data, from the request
+ * schema as `spec/schema.ts` normalizes it. Every body is checked against that schema before it
+ * leaves; one that cannot be made valid is a gap naming the operation and the field, never a
+ * request the document forbids.
+ */
+import { type Variant } from "./generate/types.ts";
+import type { JsonSchema } from "../spec/types.ts";
+export type { Variant } from "./generate/types.ts";
+export { isVacuous } from "./generate/algebra.ts";
+export declare const COHORT: readonly Variant[];
+/** Deterministic PRNG — same seed, same cohort, every run. */
+export declare function mulberry32(seed: number): () => number;
+export interface CohortMember {
+    variant: Variant;
+    body: Record<string, unknown>;
+}
+/**
+ * Thrown when no valid body can be built for an operation. The pointer names the field; the
+ * reason says why — and the fix is `hooks.resolveInput`, which can supply what the schema cannot.
+ */
+export declare class FixtureOverflow extends Error {
+    readonly operationId: string;
+    readonly pointer: string;
+    readonly reason?: string | undefined;
+    constructor(operationId: string, pointer: string, reason?: string | undefined);
+}
+export declare function overflowFrom(error: unknown, operationId: string, pointer?: string): FixtureOverflow;
+export declare function isOverflowError(error: unknown): boolean;
+export interface CohortOptions {
+    /** The operation an overflow names; default "unknown". */
+    operationId?: string;
+    /** Recursive schemas the document refers to as `testing-defs#/$defs/<name>`. */
+    defs?: Record<string, JsonSchema>;
+    /** Per-run token for values that must not collide with an earlier run's. */
+    nonce?: string;
+    /** Top-level fields whose values must be distinct across runs too — the x-unique columns. */
+    distinct?: ReadonlySet<string>;
+}
+/**
+ * The request schema as any writer may fill it: readOnly properties gone, and an optional property
+ * marked x-privileged left out, since only the highest rank may set it (`ordinary`). Every body the API tester
+ * makes or cuts from a record is read through this.
+ */
+export declare function ordinaryRequestSchema(schema: JsonSchema): JsonSchema;
+export declare function ordinaryRequestSchema(schema: JsonSchema | boolean): JsonSchema | boolean;
+/** A cohort to build: the variants to make, default the whole `COHORT`, and how to make them. */
+export interface CohortBuild extends CohortOptions {
+    variants?: readonly Variant[];
+}
+/** One body per variant, each valid for the schema — or a `FixtureOverflow` naming what is not. */
+export declare function buildCohort(bodySchema: JsonSchema | boolean, seed: number, options?: CohortBuild): CohortMember[];
+/** Which body to draw: its variant, the random source, and its position in a cohort. */
+export interface BodyDraw {
+    variant: Variant;
+    rand: () => number;
+    index: number;
+}
+/**
+ * One body, with the required fields that could not be made rather than an exception — for
+ * callers that report each gap themselves. Optional fields that cannot be made are left out.
+ */
+export declare function generateBody(bodySchema: JsonSchema | boolean, draw: BodyDraw): {
+    body: Record<string, unknown>;
+    missingRequired: string[];
+};
+/**
+ * Makes unique-set tuples differ across cohort members, by drawing new values from each
+ * column's schema. When the document cannot express two distinct values — a two-value enum and
+ * seven members — the extra members are dropped and the caller records a gap.
+ */
+/** What a member's unique columns are redrawn from: the body schema, and how cohort values are made. */
+export interface Redrawing extends CohortOptions {
+    schema: JsonSchema | boolean;
+}
+export declare function ensureDistinctUniqueValues(members: CohortMember[], sets: string[][], { schema, ...options }: Redrawing): {
+    members: CohortMember[];
+    gap: string | null;
+};
+//# sourceMappingURL=fixture.d.ts.map