@workerstack/testing 0.0.0-stage → 0.31.0

package/dist/api/conformance/rate-limit/backend.js

@@ -0,0 +1,90 @@
+/** The rate-limit suite's backends, each a fresh `Handle` with its own rows. */
+import { routed } from "../harness/routes.js";
+import { answer, guarded, readJson } from "../harness/serve.js";
+import { planLimitSpec, thingSpec } from "./spec.js";
+const SPEC = /^\/v1\/openapi\/spec$/;
+/** A read of `id` from `rows`: the row, or a bare 404. */
+function readRow(rows, id) {
+    const row = rows.get(id);
+    return row === undefined ? answer(404) : answer(200, row);
+}
+/** Untagged things whose first create is a 429 with `Retry-After: 0`; every later create succeeds. */
+export function untaggedThings() {
+    const document = thingSpec();
+    const rows = new Map();
+    let posts = 0;
+    const item = /^\/v1\/things\/([^/]+)$/;
+    return guarded(routed([
+        { method: "GET", path: SPEC, reply: () => answer(200, document) },
+        { method: "GET", path: /^\/v1\/things$/, reply: () => answer(200, { items: [...rows.values()] }) },
+        {
+            method: "POST",
+            path: /^\/v1\/things$/,
+            reply: () => {
+                posts += 1;
+                if (posts === 1)
+                    return answer(429, { error: "too_many_requests" }, { "retry-after": "0" });
+                const row = { id: `t_${String(posts)}`, name: "n" };
+                rows.set(row.id, row);
+                return answer(201, row);
+            },
+        },
+        { method: "DELETE", path: item, reply: (id) => (rows.delete(id), answer(204)) },
+        { method: "GET", path: item, reply: (id) => readRow(rows, id) },
+    ]));
+}
+/** The row routes of the plan-limited backend: rows live only in a table that exists. */
+function rowRoutes(tables) {
+    const rows = new Map();
+    let sequence = 0;
+    const collection = /^\/v1\/tables\/([^/]+)\/rows$/;
+    const item = /^\/v1\/tables\/[^/]+\/rows\/([^/]+)$/;
+    return [
+        { method: "GET", path: collection, reply: () => answer(200, { items: [...rows.values()] }) },
+        {
+            method: "POST",
+            path: collection,
+            reply: async (table, request) => {
+                const tableId = decodeURIComponent(table);
+                if (!tables.has(tableId))
+                    return answer(404);
+                const body = ((await readJson(request)) ?? {});
+                sequence += 1;
+                const row = { id: `r_${String(sequence)}`, name: body.name ?? "n", table_id: tableId };
+                rows.set(row.id, row);
+                return answer(201, row);
+            },
+        },
+        { method: "GET", path: item, reply: (id) => readRow(rows, decodeURIComponent(id)) },
+        { method: "DELETE", path: item, reply: () => answer(204) },
+    ];
+}
+/** One table that already exists, a table create refused as a plan limit (402), and rows. */
+export function planLimitedTables() {
+    const document = planLimitSpec();
+    const tables = new Map([["tbl_extract", { id: "tbl_extract", name: "from-extract" }]]);
+    const item = /^\/v1\/tables\/([^/]+)$/;
+    return guarded(routed([
+        { method: "GET", path: SPEC, reply: () => answer(200, document) },
+        { method: "GET", path: /^\/v1\/tables$/, reply: () => answer(200, { items: [...tables.values()] }) },
+        {
+            method: "POST",
+            path: /^\/v1\/tables$/,
+            reply: () => answer(402, { error_key: "table_plan_limit", status_key: "payment_required" }),
+        },
+        { method: "GET", path: item, reply: (id) => readRow(tables, decodeURIComponent(id)) },
+        { method: "DELETE", path: item, reply: () => answer(204) },
+        ...rowRoutes(tables),
+    ]));
+}
+/** Things whose every create is a 429 asking to come back in a day: a daily limit already spent. */
+export function dayLimitedThings() {
+    return guarded(routed([
+        {
+            method: "POST",
+            path: /^\/v1\/things$/,
+            reply: () => answer(429, { error: "too_many_requests" }, { "retry-after": "86400" }),
+        },
+    ]));
+}
+//# sourceMappingURL=backend.js.map

package/dist/api/conformance/rate-limit/spec.d.ts

@@ -0,0 +1,7 @@
+/** The two documents the rate-limit suite serves: untagged things, and tables behind a plan limit. */
+import type { OpenApiDocument } from "../../spec/types.ts";
+/** Things with no `x-rate-limit` tag: a 429 can only be met reactively. */
+export declare function thingSpec(): OpenApiDocument;
+/** Tables whose create is plan-limited (a documented 402), and the rows inside them. */
+export declare function planLimitSpec(): OpenApiDocument;
+//# sourceMappingURL=spec.d.ts.map

package/dist/api/conformance/rate-limit/spec.js

@@ -0,0 +1,71 @@
+/** The two documents the rate-limit suite serves: untagged things, and tables behind a plan limit. */
+import { bearerSecurity } from "../harness/security.js";
+const ITEM = {
+    properties: { id: { type: "string" }, name: { type: "string" } },
+    required: ["id", "name"],
+    type: "object",
+};
+const json = (schema) => ({ content: { "application/json": { schema } } });
+const PAGE = {
+    "200": {
+        ... /* @__PURE__ */json({
+            properties: { items: { items: ITEM, type: "array" } },
+            required: ["items"],
+            type: "object",
+        }),
+        description: "ok",
+    },
+};
+const NAME_BODY = {
+    ... /* @__PURE__ */json({ properties: { name: { type: "string" } }, required: ["name"], type: "object" }),
+    required: true,
+};
+const CREATED = { "201": { ... /* @__PURE__ */json(ITEM), description: "created" } };
+const READ = { "200": { ... /* @__PURE__ */json(ITEM), description: "ok" } };
+const GONE = { "204": { description: "gone" } };
+const param = (name) => ({ in: "path", name, required: true, schema: { type: "string" } });
+function operation(entity, action, { parameters, requestBody, responses }) {
+    return {
+        operationId: `${entity}.${action}`,
+        ...(parameters.length === 0 ? {} : { parameters: parameters.map(param) }),
+        ...(requestBody === undefined ? {} : { requestBody }),
+        responses,
+        "x-entity": { action, identity: "id", name: entity },
+    };
+}
+function resource(entity, { collection, item, created }) {
+    return [
+        {
+            get: operation(entity, "list", { parameters: collection, responses: PAGE }),
+            post: operation(entity, "create", { parameters: collection, requestBody: NAME_BODY, responses: created }),
+        },
+        {
+            delete: operation(entity, "delete", { parameters: item, responses: GONE }),
+            get: operation(entity, "read", { parameters: item, responses: READ }),
+        },
+    ];
+}
+function document(title, paths) {
+    return { info: { title, version: "1" }, openapi: "3.1.0", paths, ...bearerSecurity() };
+}
+/** Things with no `x-rate-limit` tag: a 429 can only be met reactively. */
+export function thingSpec() {
+    const [things, thing] = resource("thing", { collection: [], created: CREATED, item: [] });
+    return document("untagged-429", { "/v1/things": things, "/v1/things/{id}": thing });
+}
+/** Tables whose create is plan-limited (a documented 402), and the rows inside them. */
+export function planLimitSpec() {
+    const [tables, table] = resource("table", {
+        collection: [],
+        created: { ...CREATED, "402": { description: "payment_required" } },
+        item: ["table_id"],
+    });
+    const [rows, row] = resource("row", { collection: ["table_id"], created: CREATED, item: ["table_id", "row_id"] });
+    return document("plan-limit", {
+        "/v1/tables": tables,
+        "/v1/tables/{table_id}": table,
+        "/v1/tables/{table_id}/rows": rows,
+        "/v1/tables/{table_id}/rows/{row_id}": row,
+    });
+}
+//# sourceMappingURL=spec.js.map

package/dist/api/conformance/rate-limit.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Reactive 429 backoff and plan-limit adopt. Tags stay the proactive path; these cases prove
+ * the first 429 is not a seed failure, that a wait past the limit is not waited for, and that a
+ * 402 does not invent a table.
+ */
+import { type Via } from "./harness/launch.ts";
+import type { ParserResult } from "./harness/result.ts";
+export declare function runRateLimitSuite(via?: Via): Promise<ParserResult[]>;
+//# sourceMappingURL=rate-limit.d.ts.map

package/dist/api/conformance/rate-limit.js

@@ -0,0 +1,137 @@
+/**
+ * Reactive 429 backoff and plan-limit adopt. Tags stay the proactive path; these cases prove
+ * the first 429 is not a seed failure, that a wait past the limit is not waited for, and that a
+ * 402 does not invent a table.
+ */
+import { Client } from "../client/client.js";
+import { messageOf } from "../errors/message.js";
+import { parseRetryAfter, retryWaitMs, RETRY_BACKOFF_CAP_MS } from "../runtime/rate-limit/retry-after.js";
+import { run } from "./harness/counting.js";
+import { transportOpt } from "../runtime/run/network.js";
+import { isPlanLimitResponse } from "../runtime/world/plan-limit.js";
+import { Redactor } from "../security/redact.js";
+import { listening, reach } from "./harness/launch.js";
+import { dayLimitedThings, planLimitedTables, untaggedThings } from "./rate-limit/backend.js";
+/** A run of the API tester against `hosted`, on its entities `only`. */
+function runOptions(hosted, only) {
+    return {
+        baseUrl: hosted.url,
+        keepFixtures: true,
+        only,
+        principals: { alpha: {} },
+        security: { bearer: { static: "t" } },
+        seed: 1,
+        spec: `${hosted.url}/v1/openapi/spec`,
+        ...reach(hosted),
+    };
+}
+function pureCases() {
+    return [
+        {
+            detail: `delta=${String(parseRetryAfter("1"))} cap=${String(retryWaitMs(undefined, 8))}`,
+            name: "Retry-After delta-seconds and exponential cap",
+            ok: parseRetryAfter("1") === 1000 && retryWaitMs(undefined, 8) === RETRY_BACKOFF_CAP_MS,
+            why: "pure wait math must not hang a tester",
+        },
+        {
+            detail: "ok",
+            name: "402 and table_plan_limit are plan limits; 429 is not",
+            ok: isPlanLimitResponse(402, {}) &&
+                isPlanLimitResponse(400, { error_key: "table_plan_limit" }) &&
+                !isPlanLimitResponse(429, { error_key: "table_plan_limit" }),
+            why: "reuse is 402-only",
+        },
+    ];
+}
+const RETRIES = "Client.request retries a 429 with Retry-After and returns 201";
+const OVER_LIMIT = "Client.request answers a 429 that asks for longer than maxRetryAfterMs at once, without retrying";
+const ADOPTS = "row seeds after table.create 402 when a same-tenant table already exists";
+const HOSTED = [
+    {
+        backend: untaggedThings,
+        name: RETRIES,
+        probe: async (hosted, push) => {
+            const options = runOptions(hosted, ["thing"]);
+            /* No network retries, as with no network options at all: only the 429 is retried. */
+            const network = { ...transportOpt(options), retries: 0 };
+            const client = new Client({ baseUrl: hosted.url, network, redactor: new Redactor() });
+            const first = await client.request("POST", "/v1/things", { as: { anonymous: true }, body: { name: "n" } });
+            const statuses = client.transcript.map((e) => e.status).join(",");
+            push({
+                detail: `status=${first.status} seq=${statuses}`,
+                name: RETRIES,
+                ok: first.status === 201 && statuses === "429,201",
+                why: "first 429 is not the result",
+            });
+            const result = await run(options);
+            const blocked = result.findings.filter((f) => f.verdict === "BLOCKED" && f.check === "world.seed");
+            push({
+                detail: `blocked=${blocked.length} entities=${result.entitiesTested.join(",")}`,
+                name: "seed is not failed by the first 429 on an untagged create",
+                ok: blocked.length === 0 && result.entitiesTested.includes("thing"),
+                why: "no x-rate-limit required",
+            });
+        },
+        why: "first 429 is not the result",
+    },
+    {
+        backend: planLimitedTables,
+        name: ADOPTS,
+        probe: async (hosted, push) => {
+            const result = await run(runOptions(hosted, ["table", "row"]));
+            const rowBlocked = result.findings.some((f) => f.verdict === "BLOCKED" && f.entity === "row");
+            const invented = result.client.transcript.some((e) => e.method === "POST" && new URL(e.url).pathname === "/v1/tables" && e.status < 300);
+            const backend402 = result.findings.some((f) => f.verdict === "BACKEND_BUG" && f.detail.includes("402"));
+            push({
+                detail: `blocked=${rowBlocked} invented=${invented} backend402=${backend402} tested=${result.entitiesTested.join(",")}`,
+                name: ADOPTS,
+                ok: !rowBlocked && !invented && !backend402 && result.entitiesTested.includes("row"),
+                why: "do not invent tables; do not treat documented plan limit as a defect",
+            });
+        },
+        why: "do not invent tables; do not treat documented plan limit as a defect",
+    },
+    {
+        backend: dayLimitedThings,
+        name: OVER_LIMIT,
+        probe: async (hosted, push) => {
+            /* The run's own transport when it has one (in-process), else the global fetch. */
+            const transport = Object.assign({ fetchImpl: fetch }, transportOpt(runOptions(hosted, ["thing"]))).fetchImpl;
+            let requests = 0;
+            const counted = (input, init) => ((requests += 1), transport(input, init));
+            const network = { fetchImpl: counted, maxRetryAfterMs: 60_000, retries: 0 };
+            const client = new Client({ baseUrl: hosted.url, network, redactor: new Redactor() });
+            const started = performance.now();
+            const answered = await client.request("POST", "/v1/things", { as: { anonymous: true }, body: { name: "n" } });
+            const tookMs = performance.now() - started;
+            const marked = answered.retryAfterExceeded?.waitMs === 86_400_000;
+            push({
+                detail: `requests=${requests} marked=${marked}`,
+                name: OVER_LIMIT,
+                ok: requests === 1 && marked && tookMs < 1_000,
+                why: "a wait past the limit is not waited for",
+            });
+        },
+        why: "a wait past the limit is not waited for",
+    },
+];
+export async function runRateLimitSuite(via = listening) {
+    const results = pureCases();
+    const push = (result) => results.push(result);
+    for (const { backend, name, probe, why } of HOSTED) {
+        try {
+            const hosted = await via.host(backend());
+            try {
+                await probe(hosted, push);
+            }
+            finally {
+                await hosted.close();
+            }
+        }
+        catch (error) {
+            push({ detail: messageOf(error), name, ok: false, why });
+        }
+    }
+    return results;
+}
+//# sourceMappingURL=rate-limit.js.map

package/dist/api/conformance/scope.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Targeted-run recall: `--ops` must not lose a defect it was pointed at.
+ *
+ * For every defect the reference backend can exhibit, a full run names the operations its finding
+ * judges. A run targeted at exactly those operations has to report the same defect. A check whose
+ * declared `subjects` omit the operation it actually judges fails here: the targeted run either
+ * never queues it or attributes the finding elsewhere.
+ */
+import type { ParserResult } from "./harness/result.ts";
+import { type Via } from "./harness/launch.ts";
+/**
+ * `known` carries, per defect, the operations its finding judged in a full run the caller already
+ * made — the defect matrix makes exactly that run — so only the targeted run is sent here.
+ */
+export declare function runScopeSuite(via: Via, filter?: string[], known?: Readonly<Record<string, readonly string[]>>): Promise<ParserResult[]>;
+//# sourceMappingURL=scope.d.ts.map

package/dist/api/conformance/scope.js

@@ -0,0 +1,87 @@
+/**
+ * Targeted-run recall: `--ops` must not lose a defect it was pointed at.
+ *
+ * For every defect the reference backend can exhibit, a full run names the operations its finding
+ * judges. A run targeted at exactly those operations has to report the same defect. A check whose
+ * declared `subjects` omit the operation it actually judges fails here: the targeted run either
+ * never queues it or attributes the finding elsewhere.
+ */
+import { messageOf } from "../errors/message.js";
+import { run } from "./harness/counting.js";
+import { EXPECTED } from "./expected/table.js";
+import { launch, reach } from "./harness/launch.js";
+import { defectsFor } from "./matrix/defects.js";
+import { judgedOperations, primaryOf } from "./matrix/expected.js";
+import { optInFor } from "./matrix/opt-in.js";
+import { PRINCIPALS, SECURITY } from "./matrix/principals.js";
+const NOT_DEFECTS = /* @__PURE__ */ new Set(["COVERAGE_GAP", "BLOCKED"]);
+async function runOnce(defects, ops, via) {
+    /* A defect behind an opt-in shows only with it on, in the reference and in the API tester both. */
+    const optIn = optInFor(defects);
+    const server = await launch({ backend: "memory", dialect: "postgrest", via }, { defects, ...optIn.reference });
+    try {
+        const result = await run({
+            ...optIn.run,
+            baseUrl: server.url,
+            principals: PRINCIPALS,
+            security: SECURITY,
+            seed: 42,
+            spec: `${server.url}/v1/openapi/spec`,
+            ...(ops === undefined ? {} : { ops }),
+            ...reach(server),
+        });
+        return {
+            findings: result.findings.filter((f) => !NOT_DEFECTS.has(f.verdict)),
+            statuses: new Map(result.scope.operations.map((op) => [op.operationId, op.status])),
+        };
+    }
+    finally {
+        await server.close();
+    }
+}
+/**
+ * `known` carries, per defect, the operations its finding judged in a full run the caller already
+ * made — the defect matrix makes exactly that run — so only the targeted run is sent here.
+ */
+export async function runScopeSuite(via, filter, known) {
+    const results = [];
+    /* What the default backend and dialect this suite targets can exhibit: a shape-only or
+     * dialect-only defect has nowhere to happen here. */
+    const names = defectsFor("memory", "postgrest").filter((name) => filter === undefined || filter.length === 0 || filter.includes(name));
+    for (const defect of names) {
+        const check = primaryOf(EXPECTED[defect]);
+        const name = `--ops recall: ${defect}`;
+        const why = `a run targeted at the operation ${check} judges must still report it`;
+        try {
+            const reported = known?.[defect];
+            const fresh = reported === undefined
+                ? (await runOnce([defect], undefined, via)).findings.filter((f) => f.check === check)
+                : [];
+            const ops = reported ?? (fresh.length === 0 ? undefined : judgedOperations(fresh, check));
+            if (ops === undefined) {
+                results.push({ detail: "the full run did not report it either", name, ok: false, why });
+                continue;
+            }
+            if (ops.length === 0) {
+                results.push({ detail: `${check} finding carries no operation`, name, ok: false, why });
+                continue;
+            }
+            const targeted = await runOnce([defect], [...ops], via);
+            const detected = targeted.findings.some((f) => f.check === check);
+            const failed = ops.some((op) => targeted.statuses.get(op) === "failed");
+            results.push({
+                detail: `--ops ${ops.join(",")}: ${detected ? "reported" : "MISSED"}, status ${ops
+                    .map((op) => targeted.statuses.get(op) ?? "absent")
+                    .join(",")}`,
+                name,
+                ok: detected && failed,
+                why,
+            });
+        }
+        catch (error) {
+            results.push({ detail: messageOf(error), name, ok: false, why });
+        }
+    }
+    return results;
+}
+//# sourceMappingURL=scope.js.map

package/dist/api/conformance/seed-contract/fixture-walk.d.ts

@@ -0,0 +1,42 @@
+/**
+ * The fixture walk on schemas a real document trips: `z.unknown()` / `z.record` after `$ref`
+ * inlining, identity cycles, string bounds a pattern must honor, and bounds that cannot be met.
+ */
+import type { JsonSchema } from "../../spec/types.ts";
+import type { ParserResult } from "../harness/result.ts";
+/** One fixture-walk case: what it is called, why it matters, and what it found. */
+export interface WalkCase {
+    name: string;
+    why: string;
+    probe: () => {
+        ok: boolean;
+        detail: string;
+    };
+}
+/** A string bounded in length, following `pattern` when it has one. */
+interface BoundedString {
+    maxLength: number;
+    minLength: number;
+    pattern?: string;
+    type: "string";
+}
+/** A sign-up form: a required handle and name, each a bounded string. */
+interface SignUpSchema extends JsonSchema {
+    properties: {
+        handle: BoundedString;
+        name: BoundedString;
+    };
+    required: string[];
+    type: "object";
+}
+/** The handle and name a sign-up form asks for: a slug pattern with a floor, and a bounded name. */
+export declare const HANDLE_SCHEMA: SignUpSchema;
+export declare function boundedPattern(schema: JsonSchema): {
+    ok: boolean;
+    detail: string;
+};
+export declare const FIXTURE_WALK: readonly WalkCase[];
+/** Each case's verdict; a case that throws fails with the error's message, and the rest still run. */
+export declare function runFixtureWalkCases(cases?: readonly WalkCase[]): ParserResult[];
+export {};
+//# sourceMappingURL=fixture-walk.d.ts.map

package/dist/api/conformance/seed-contract/fixture-walk.js

@@ -0,0 +1,143 @@
+/**
+ * The fixture walk on schemas a real document trips: `z.unknown()` / `z.record` after `$ref`
+ * inlining, identity cycles, string bounds a pattern must honor, and bounds that cannot be met.
+ */
+import { messageOf } from "../../errors/message.js";
+import { buildCohort, FixtureOverflow, generateBody, isOverflowError, mulberry32, overflowFrom, } from "../../runtime/fixture.js";
+import { codePointCount } from "../../runtime/payloads.js";
+import { dereference } from "../../spec/load/dereference.js";
+import { documentDefs } from "../../spec/load/defs.js";
+function columnDefaults() {
+    const column = {
+        additionalProperties: {},
+        default: {},
+        properties: { name: { type: "string" } },
+        required: ["name"],
+        type: "object",
+    };
+    const schema = { properties: { columns: { items: column, type: "array" } }, required: ["columns"], type: "object" };
+    const [body] = buildCohort(schema, 1, { operationId: "table.create", variants: ["baseline"] }).map((member) => member.body);
+    return { detail: JSON.stringify(body).slice(0, 120), ok: Array.isArray(body?.["columns"]) };
+}
+function cyclicRef() {
+    const { doc } = dereference({
+        components: { schemas: { Node: { properties: { child: { $ref: "#" } }, type: "object" } } },
+        info: { title: "cycle", version: "1" },
+        openapi: "3.1.0",
+        paths: {
+            "/tables": {
+                post: {
+                    operationId: "table.create",
+                    requestBody: { content: { "application/json": { schema: { $ref: "#" } } }, required: true },
+                    responses: { "201": { description: "ok" } },
+                    "x-entity": { action: "create", identity: "id", name: "table" },
+                },
+            },
+        },
+    });
+    const schema = doc.paths?.["/tables"]?.post?.requestBody?.content?.["application/json"]?.schema;
+    /* A cohort has one member per variant, or the walk throws: getting here is the pass. */
+    const cohort = buildCohort(schema, 1, {
+        defs: documentDefs(doc),
+        operationId: "table.create",
+        variants: ["baseline"],
+    });
+    return { detail: "body returned", ok: cohort.length === 1 };
+}
+function emailFormat() {
+    const schema = { properties: { email: { format: "email", type: "string" } }, required: ["email"], type: "object" };
+    const [member] = buildCohort(schema, 1, { operationId: "user.create", variants: ["baseline"] });
+    const email = member?.body["email"];
+    return {
+        detail: String(email),
+        ok: typeof email === "string" && /^[^@]+@[^@]+\.[^@]+$/.test(email),
+    };
+}
+const HANDLE = "^[a-z0-9]([a-z0-9-]*[a-z0-9])?$";
+/** The handle and name a sign-up form asks for: a slug pattern with a floor, and a bounded name. */
+export const HANDLE_SCHEMA = {
+    properties: {
+        handle: { maxLength: 32, minLength: 3, pattern: HANDLE, type: "string" },
+        name: { maxLength: 32, minLength: 3, type: "string" },
+    },
+    required: ["handle", "name"],
+    type: "object",
+};
+/* Every cohort member's handle matches the pattern and is not `a`, and every name is in [3, 32]. */
+export function boundedPattern(schema) {
+    const members = buildCohort(schema, 1, { operationId: "user.create" });
+    const re = new RegExp(HANDLE);
+    const ok = members.every(({ body: { handle, name } }) => {
+        const n = codePointCount(String(name));
+        return (typeof handle === "string" &&
+            handle !== "a" &&
+            re.test(handle) &&
+            codePointCount(handle) >= 3 &&
+            typeof name === "string" &&
+            n >= 3 &&
+            n <= 32);
+    });
+    return { detail: ok ? `${members.length} variants` : JSON.stringify(members.map((m) => m.body)), ok };
+}
+function impossibleBounds() {
+    const bounded = { maxLength: 3, minLength: 10, type: "string" };
+    const schema = { properties: { opt: bounded, req: bounded }, required: ["req"], type: "object" };
+    const { body, missingRequired } = generateBody(schema, { index: 0, rand: mulberry32(1), variant: "baseline" });
+    return {
+        detail: `body=${JSON.stringify(body)} missing=${missingRequired.join(",")}`,
+        ok: body["opt"] === undefined && body["req"] === undefined && missingRequired.includes("/req"),
+    };
+}
+function namedOverflow() {
+    overflowFrom(new RangeError("Maximum call stack size exceeded"), "table.create");
+    const named = new FixtureOverflow("table.create", "/columns_json");
+    return {
+        detail: named.message,
+        ok: named.message.includes("table.create") && !named.message.includes("unknown") && isOverflowError(named),
+    };
+}
+export const FIXTURE_WALK = [
+    {
+        name: "default: {} on a column object seeds",
+        probe: columnDefaults,
+        why: "z.unknown() / default: {} must not recurse",
+    },
+    {
+        name: "cyclic $ref: # after deref does not throw",
+        probe: cyclicRef,
+        why: "inlined identity cycles must terminate",
+    },
+    {
+        name: "format: email matches a conservative regex",
+        probe: emailFormat,
+        why: "required email must not be Quarterly Report N",
+    },
+    {
+        name: "fixture strings honor minLength with pattern",
+        probe: () => boundedPattern(HANDLE_SCHEMA),
+        why: "handle must not be a; every cohort name is in [3, 32]",
+    },
+    {
+        name: "minLength > maxLength is a generation gap",
+        probe: impossibleBounds,
+        why: "omit optional; missingRequired on required; do not loop",
+    },
+    {
+        name: "overflow names table.create, not unknown",
+        probe: namedOverflow,
+        why: "RangeError must become a named fixture gap",
+    },
+];
+/** Each case's verdict; a case that throws fails with the error's message, and the rest still run. */
+export function runFixtureWalkCases(cases = FIXTURE_WALK) {
+    return cases.map(({ name, probe, why }) => {
+        try {
+            const { detail, ok } = probe();
+            return { detail, name, ok, why };
+        }
+        catch (error) {
+            return { detail: messageOf(error), name, ok: false, why };
+        }
+    });
+}
+//# sourceMappingURL=fixture-walk.js.map

package/dist/api/conformance/seed-contract/members.d.ts

@@ -0,0 +1,15 @@
+/**
+ * An invite-only member API: `org.inviteMember` is how a member comes to exist, so it must stay
+ * on `entity.invite` and never be seeded as `POST /things` with a generated email.
+ */
+import type { Handle } from "../../reference/http/node.ts";
+import type { OpenApiDocument } from "../../spec/types.ts";
+export declare function memberSpec(): OpenApiDocument;
+/** The member API, every invite body it was sent, and the ones a seed sent with a generated email. */
+export interface MemberBackend {
+    handle: Handle;
+    inviteBodies: unknown[];
+    seedBodies: unknown[];
+}
+export declare function memberBackend(): MemberBackend;
+//# sourceMappingURL=members.d.ts.map