@aventara/testing 0.0.0-stage → 0.1.0-pilot.0

package/dist/protocol/protocol-fixtures.js

@@ -0,0 +1,998 @@
+import { CORPUS_AUTHOR, CORPUS_CLIENT_CONTRACT_DOCUMENT, CORPUS_CLIENT_CONTRACT_HASH, CORPUS_NOBODY, CORPUS_NONE_CLIENT_CONTRACT_HASH, CORPUS_TRIGGER, } from "./corpus-contract.fixture.js";
+/**
+ * The Phase 10 protocol fixture corpus: passive data, read by the coverage
+ * gate (`protocol-coverage.spec.ts`) and, from later slices on, driven
+ * through each host driver. Each slice adds the rows it settles and removes
+ * what they cover from the gate's awaiting ledger.
+ */
+/**
+ * A well-formed generated-client request. A family-11 row's answer does not
+ * depend on it: the answer is what arrived instead of a framework envelope.
+ */
+const OPERATION_REQUEST = {
+    method: "POST",
+    path: "/_resources/authors/find/many",
+    headers: {
+        "Content-Type": "application/json",
+        "Aventara-Protocol-Version": "1",
+        "Aventara-Contract-Hash": `sha256:${"0".repeat(64)}`,
+    },
+    body: { kind: "raw", content: "{}" },
+};
+/**
+ * Family 11 — transport errors (§13.5; R5). Each row is a response that is NOT
+ * a framework envelope — produced by a proxy, a broken host or the network,
+ * never by the framework — so a client raises `TransportError`, never a
+ * `FrameworkError`. `AvProtocol.isOperationResponse` refuses every row's body
+ * (`envelope-guard.spec.ts`), and the generated client's emitted check is held
+ * to agree with it row by row (`packages/client`, the envelope pin).
+ *
+ * Every label begins `transport-error:`. These rows describe what a client
+ * receives, not what a host must answer, so a host driver does not drive them:
+ * it selects its rows by `client.outcome`, skipping every row whose outcome is
+ * `"transport-error"` (the director, 2026-10-05) — never by label or by
+ * `server.code === null`. `adapterCalls` is `0` because the framework produced
+ * none of these answers.
+ */
+const transportError = (label, status, bodyBytes) => ({
+    label: `transport-error: ${label}`,
+    request: OPERATION_REQUEST,
+    server: {
+        status,
+        code: null,
+        adapterCalls: 0,
+        ...(bodyBytes === undefined ? {} : { bodyBytes }),
+    },
+    client: { outcome: "transport-error" },
+});
+const envelopeText = (code, data, cause) => JSON.stringify({ data, code, cause });
+const TRANSPORT_ERRORS = [
+    transportError("502 with an HTML page", 502, "<html><body><h1>502 Bad Gateway</h1></body></html>"),
+    transportError("200 with JSON of another shape", 200, '{"ok":true}'),
+    transportError("connection failure — no response arrived", 0),
+    transportError("a truncated body", 200, '{"data":null,"code":"A10'),
+    transportError("an empty body", 204, ""),
+    transportError("a JSON array", 200, "[]"),
+    transportError("JSON null", 200, "null"),
+    transportError("a JSON string", 200, '"A1000"'),
+    transportError("a code this protocol does not allocate", 400, envelopeText("A9999", null, { message: "x" })),
+    transportError("a code that is not a string", 200, '{"data":null,"code":1000,"cause":null}'),
+    transportError("no data member", 200, '{"code":"A1000","cause":null}'),
+    transportError("no cause member", 200, '{"data":1,"code":"A1000"}'),
+    transportError("a success code with a cause", 200, envelopeText("A1000", 1, { message: "x" })),
+    transportError("A1001 with data", 200, envelopeText("A1001", { id: 1 }, null)),
+    transportError("an error code with a null cause", 404, envelopeText("A2003", null, null)),
+    transportError("an error code with data", 404, envelopeText("A2003", { id: 1 }, { message: "x" })),
+    transportError("a cause whose message is not a string", 422, envelopeText("A2004", null, { message: 5 })),
+    transportError("a cause that is a string", 422, envelopeText("A2004", null, "Invalid.")),
+    transportError("issues that are not an array", 422, envelopeText("A2004", null, { message: "x", issues: {} })),
+    transportError("an issue whose code is not a validation code", 422, envelopeText("A2004", null, {
+        message: "x",
+        issues: [{ code: "V9999", message: "y" }],
+    })),
+    transportError("an issue whose message is not a string", 422, envelopeText("A2004", null, { message: "x", issues: [{ code: "V1000" }] })),
+    transportError("an issue whose path is not an array", 422, envelopeText("A2004", null, {
+        message: "x",
+        issues: [{ path: "a.b", code: "V1000", message: "y" }],
+    })),
+    transportError("an issue whose path holds an object", 422, envelopeText("A2004", null, {
+        message: "x",
+        issues: [{ path: [{}], code: "V1000", message: "y" }],
+    })),
+    transportError("an issue whose path holds a fraction", 422, envelopeText("A2004", null, {
+        message: "x",
+        issues: [{ path: [0.5], code: "V1000", message: "y" }],
+    })),
+    transportError("an operation index that is a string", 409, envelopeText("A2008", null, { message: "x", operation: "1" })),
+    transportError("a negative operation index", 409, envelopeText("A2008", null, { message: "x", operation: -1 })),
+    transportError("a fractional operation index", 409, envelopeText("A2008", null, { message: "x", operation: 0.5 })),
+];
+/**
+ * A generated client's request to the corpus Framework for one operation of
+ * `authors` (`corpus-contract.fixture.ts`): its identity headers name the
+ * corpus ClientContract, and it sends its own `Aventara-Request-Id`, so the
+ * echo every framework answer carries (Q13) is a fixed fact of the row.
+ */
+const corpusRequest = (operation, body, requestId, overrides = {}) => ({
+    method: "POST",
+    path: `/_resources/authors/${operation}`,
+    headers: {
+        "Content-Type": "application/json",
+        "Aventara-Protocol-Version": "1",
+        "Aventara-Contract-Hash": CORPUS_CLIENT_CONTRACT_HASH,
+        "Aventara-Request-Id": requestId,
+    },
+    body: { kind: "raw", content: JSON.stringify(body) },
+    ...overrides,
+});
+/** The framework's own headers on an answer to a request that sent `requestId`. */
+const answeredHeaders = (requestId) => ({
+    "Content-Type": "application/json",
+    "Aventara-Request-Id": requestId,
+});
+/**
+ * Family 2 — success statuses (§13.2; plan S8). Every standard operation
+ * through a found route: its success code at its status — `201` exactly for
+ * `A1002` and `A1003`, `200` otherwise, `upsert.unique`'s `A1008` included —
+ * with `cause: null`, the result in wire form, one Adapter call, and no
+ * `Location` (P2: the framework's two headers are all it writes). The label
+ * begins with the operation's name, which is how the coverage gate reads a
+ * success row.
+ */
+const success = (operation, body, status, code, data, label = "") => {
+    const requestId = `corpus-${operation.replace(".", "-")}${label === "" ? "" : "-miss"}`;
+    return {
+        label: `${operation}${label === "" ? "" : ` ${label}`}`,
+        request: corpusRequest(operation.replace(".", "/"), body, requestId),
+        server: {
+            status,
+            code,
+            adapterCalls: 1,
+            responseHeaders: answeredHeaders(requestId),
+            bodyBytes: JSON.stringify({ data, code, cause: null }),
+        },
+        client: { outcome: "resolve" },
+    };
+};
+const WHERE = { where: { id: CORPUS_AUTHOR.id } };
+const DATA = { name: CORPUS_AUTHOR.name };
+const SUCCESS_STATUSES = [
+    success("find.first", WHERE, 200, "A1000", CORPUS_AUTHOR),
+    success("find.first", { where: { id: CORPUS_NOBODY } }, 200, "A1001", null, "matching nothing → 200 A1001 with null data"),
+    success("find.unique", WHERE, 200, "A1000", CORPUS_AUTHOR),
+    success("find.many", {}, 200, "A1000", [CORPUS_AUTHOR]),
+    success("find.count", {}, 200, "A1000", 2),
+    success("create.one", { data: DATA }, 201, "A1002", CORPUS_AUTHOR),
+    success("create.many", { data: [DATA] }, 201, "A1003", [CORPUS_AUTHOR]),
+    success("create.count", { data: [DATA, DATA] }, 201, "A1003", 2),
+    success("update.first", { ...WHERE, data: DATA }, 200, "A1004", CORPUS_AUTHOR),
+    success("update.unique", { ...WHERE, data: DATA }, 200, "A1004", CORPUS_AUTHOR),
+    success("update.many", { ...WHERE, data: DATA }, 200, "A1005", [
+        CORPUS_AUTHOR,
+    ]),
+    success("update.count", { ...WHERE, data: DATA }, 200, "A1005", 2),
+    success("delete.first", WHERE, 200, "A1006", CORPUS_AUTHOR),
+    success("delete.unique", WHERE, 200, "A1006", CORPUS_AUTHOR),
+    success("delete.many", WHERE, 200, "A1007", [CORPUS_AUTHOR]),
+    success("delete.count", WHERE, 200, "A1007", 2),
+    success("upsert.unique", { ...WHERE, create: DATA, update: DATA }, 200, "A1008", CORPUS_AUTHOR),
+];
+/**
+ * F-828 (plan S12) — a computed field added under `client.fields` is read
+ * through the HTTP surface like one added at root: `books.label`, VIRTUAL,
+ * computed from `id` (`corpus-contract.fixture.ts`). It is in the default read,
+ * and an explicit `select` of it answers it alone; the Adapter is asked only for
+ * stored columns (core's `computed-read-runtime.scope-added-field.spec.ts`).
+ */
+const scopeAdded = (label, body, requestId, data) => ({
+    label: `scope-added: ${label}`,
+    request: corpusRequest("find/many", body, requestId, {
+        path: "/_resources/books/find/many",
+    }),
+    server: {
+        status: 200,
+        code: "A1000",
+        adapterCalls: 1,
+        responseHeaders: answeredHeaders(requestId),
+        bodyBytes: JSON.stringify({ data, code: "A1000", cause: null }),
+    },
+    client: { outcome: "resolve" },
+});
+const SCOPE_ADDED = [
+    scopeAdded("a computed field added under client.fields is in the default read (F-828)", {}, "corpus-scope-added-default", 
+    // The Contract orders the record's fields, not the Adapter.
+    [{ authorId: CORPUS_AUTHOR.id, id: "b1", label: "book:b1" }]),
+    scopeAdded("an explicit select of it answers it alone (F-828)", { select: ["label"] }, "corpus-scope-added-select", [{ label: "book:b1" }]),
+];
+/**
+ * A request the protocol answers itself, before any Adapter call: the
+ * framework's own envelope, exactly, at its code's status.
+ */
+const refused = (label, request, status, code, message, headers = {}) => ({
+    label,
+    request,
+    server: {
+        status,
+        code,
+        causeKeys: ["message"],
+        adapterCalls: 0,
+        responseHeaders: {
+            ...answeredHeaders(String(request.headers["Aventara-Request-Id"])),
+            ...headers,
+        },
+        bodyBytes: JSON.stringify({ data: null, code, cause: { message } }),
+    },
+    client: { outcome: "framework-error", code },
+});
+const MALFORMED = "The request is malformed and cannot be interpreted.";
+/** `{"pad":"x…"}`, one byte over the default 1 MiB `maxRequestBytes` (§20.1). */
+const OVERSIZED = `{"pad":"${"x".repeat(1024 * 1024 + 1 - 10)}"}`;
+const rawBody = (requestId, content) => corpusRequest("find/many", {}, requestId, {
+    body: { kind: "raw", content },
+});
+/**
+ * Family 7 — body and media (§12.3, §12.6, Q11; plan S7, driven from S8). On
+ * the raw arm: `{}` is valid (`find.many` above), and every other shape — a
+ * list, a scalar, `null`, no body, text that is not JSON — is `A2000`; a
+ * content type other than `application/json` is `A2011`; a decoded body over
+ * the limit is `A2010`. On the parsed arm only the shape is the decoder's.
+ * Routing metadata in the body is an argument like any other, refused by
+ * core's own validation (N16), so it reaches the Framework but no Adapter.
+ */
+const BODY_AND_MEDIA = [
+    refused("body: a JSON list → 400 A2000", rawBody("corpus-body-list", "[]"), 400, "A2000", MALFORMED),
+    refused("body: a JSON number → 400 A2000", rawBody("corpus-body-number", "3"), 400, "A2000", MALFORMED),
+    refused("body: JSON null → 400 A2000", rawBody("corpus-body-null", "null"), 400, "A2000", MALFORMED),
+    refused("body: none (zero bytes) → 400 A2000", rawBody("corpus-body-none", ""), 400, "A2000", MALFORMED),
+    refused("body: text that is not JSON → 400 A2000", rawBody("corpus-body-text", "{"), 400, "A2000", MALFORMED),
+    refused("body: parsed by the host, null → 400 A2000", corpusRequest("find/many", {}, "corpus-body-parsed-null", {
+        body: { kind: "parsed", value: null },
+    }), 400, "A2000", MALFORMED),
+    refused("media: text/plain → 415 A2011", corpusRequest("find/many", {}, "corpus-media-text", {
+        headers: {
+            "Content-Type": "text/plain",
+            "Aventara-Protocol-Version": "1",
+            "Aventara-Contract-Hash": CORPUS_CLIENT_CONTRACT_HASH,
+            "Aventara-Request-Id": "corpus-media-text",
+        },
+    }), 415, "A2011", "The request content type is not supported; send application/json."),
+    refused("body: one byte over maxRequestBytes → 413 A2010", rawBody("corpus-body-oversized", OVERSIZED), 413, "A2010", "The request body exceeds the maximum request size."),
+    {
+        label: "body: routing metadata is an argument, refused by core → 422 A2004",
+        request: corpusRequest("find/many", { resource: "authors", family: "find", variant: "many" }, "corpus-body-routing"),
+        server: {
+            status: 422,
+            code: "A2004",
+            causeKeys: ["issues", "message"],
+            issues: [
+                { code: "V1001", path: ["arguments", "resource"] },
+                { code: "V1001", path: ["arguments", "family"] },
+                { code: "V1001", path: ["arguments", "variant"] },
+            ],
+            adapterCalls: 0,
+            responseHeaders: answeredHeaders("corpus-body-routing"),
+        },
+        client: { outcome: "framework-error", code: "A2004" },
+    },
+];
+/**
+ * Family 8 — method (§12.1). A framework route accepts `POST` only; anything
+ * else is `405 A2012` carrying `Allow: POST` (RFC 9110 §15.5.6; the
+ * director, 2026-10-05).
+ */
+const METHOD = [
+    refused("method: GET on a resource route → 405 A2012 with Allow: POST", corpusRequest("find/many", {}, "corpus-method-get", { method: "GET" }), 405, "A2012", "The HTTP method is not allowed on this framework route.", { Allow: "POST" }),
+];
+/** A generator's `GET /_contract`, with `headers` beside its own request id. */
+const contractRequest = (requestId, headers = {}, method = "GET") => ({
+    method,
+    path: "/_contract",
+    headers: { "Aventara-Request-Id": requestId, ...headers },
+    body: { kind: "raw", content: "" },
+});
+/** The corpus document's entity tag: the quoted contract hash (§12.5). */
+const CORPUS_ETAG = `"${CORPUS_CLIENT_CONTRACT_HASH}"`;
+/** `200` with the document: its exact bytes, `ETag`, `Cache-Control: no-cache`. */
+const contractServed = (label, requestId, headers = {}) => ({
+    label: `contract: ${label}`,
+    request: contractRequest(requestId, headers),
+    server: {
+        status: 200,
+        code: null,
+        adapterCalls: 0,
+        responseHeaders: {
+            ...answeredHeaders(requestId),
+            ETag: CORPUS_ETAG,
+            "Cache-Control": "no-cache",
+        },
+        bodyBytes: CORPUS_CLIENT_CONTRACT_DOCUMENT,
+    },
+    client: { outcome: "resolve" },
+});
+/** `304 Not Modified`: no body, `ETag` and `Cache-Control` kept (RFC 9110 §15.4.5). */
+const contractNotModified = (label, requestId, ifNoneMatch) => ({
+    label: `contract: ${label}`,
+    request: contractRequest(requestId, { "If-None-Match": ifNoneMatch }),
+    server: {
+        status: 304,
+        code: null,
+        adapterCalls: 0,
+        responseHeaders: {
+            "Aventara-Request-Id": requestId,
+            ETag: CORPUS_ETAG,
+            "Cache-Control": "no-cache",
+        },
+        bodyBytes: "",
+    },
+    client: { outcome: "resolve" },
+});
+/**
+ * Family 1 — contract discovery (§12.5, Q8; plan S11). `GET /_contract`
+ * serves the ClientContract's JCS bytes with `ETag` the quoted hash and
+ * `Cache-Control: no-cache`, needs no identity header, and answers `304` with
+ * no body when `If-None-Match` matches — weakly, in a list, or `*`. Any other
+ * method is `405 A2012` with `Allow: GET`. A generator resolves both `200`
+ * and `304` ("up to date", Phase 12).
+ */
+const CONTRACT_DISCOVERY = [
+    contractServed("GET → 200 with the JCS bytes, ETag and no-cache", "corpus-contract"),
+    contractServed("no identity header is required, nor judged when sent", "corpus-contract-identity", {
+        "Aventara-Protocol-Version": "2",
+        "Aventara-Contract-Hash": `sha256:${"0".repeat(64)}`,
+    }),
+    contractNotModified("If-None-Match the quoted hash → 304", "corpus-contract-304", CORPUS_ETAG),
+    contractNotModified("If-None-Match weak W/ → 304", "corpus-contract-304-weak", `W/${CORPUS_ETAG}`),
+    contractNotModified("If-None-Match a list holding it → 304", "corpus-contract-304-list", `"sha256:old", ${CORPUS_ETAG}`),
+    contractNotModified("If-None-Match * → 304", "corpus-contract-304-star", "*"),
+    contractServed("If-None-Match another hash → 200", "corpus-contract-stale", {
+        "If-None-Match": '"sha256:old"',
+    }),
+    refused("method: POST on /_contract → 405 A2012 with Allow: GET", contractRequest("corpus-contract-post", {}, "POST"), 405, "A2012", "The HTTP method is not allowed on this framework route.", { Allow: "GET" }),
+];
+/**
+ * One node of a generated client's plan (§14, M25): the operation, its
+ * arguments verbatim, and the fingerprint the client computed over them —
+ * a literal, as the client sends it; `corpus-contract.spec.ts` recomputes
+ * every one with core's `computeOperationFingerprint`.
+ */
+const planNode = (resource, operation, args, fingerprint) => {
+    const [family, variant] = operation.split(".");
+    return { resource, family, variant, args, fingerprint };
+};
+const AUTHORS_FIND_MANY = planNode("authors", "find.many", {}, "fp1:1aLMnUbKspahv3fbsV7pKg");
+/** `POST /_transactions` with a plan of `nodes`, under the corpus identity. */
+const planRequest = (requestId, nodes, overrides = {}) => ({
+    ...corpusRequest("", { operations: nodes }, requestId),
+    path: "/_transactions",
+    ...overrides,
+});
+/** A row refused by core's validation layer: its issues and cause keys, no Adapter call. */
+const invalid = (label, request, status, code, issues, operation) => ({
+    label,
+    request,
+    server: {
+        status,
+        code,
+        causeKeys: operation === undefined
+            ? ["issues", "message"]
+            : ["issues", "message", "operation"],
+        issues,
+        adapterCalls: 0,
+        responseHeaders: answeredHeaders(String(request.headers["Aventara-Request-Id"])),
+    },
+    client: { outcome: "framework-error", code },
+});
+/**
+ * Family 9 — transactions (§14; plan S9), through `/_transactions` under
+ * ClientContract rules only (R1). A committed plan is `200 A1009` with each
+ * step's data in plan order, a create included (P3); a rolled-back plan
+ * answers its failing step's own code at that code's status, cause keys
+ * `message` and `operation` (Q4, M15); a step that depends on rows an earlier
+ * step's cascade removed is refused before anything runs (`V1019` → `422`);
+ * and a plan node cannot carry an origin (N11).
+ *
+ * The R1 rows come in pairs, labelled `R1: <what> — single route` and
+ * `R1: <what> — /_transactions`: the same refusal through both routes, the
+ * plan's differing only by `cause.operation` (asserted pair by pair in
+ * `corpus-contract.spec.ts`).
+ */
+const TRANSACTIONS = [
+    {
+        label: "transaction — committed, a create included → 200 A1009 in plan order",
+        request: planRequest("corpus-tx-committed", [
+            planNode("authors", "create.one", { data: { name: CORPUS_AUTHOR.name } }, "fp1:ivp4epVXIrdpENiusGWg3w"),
+            AUTHORS_FIND_MANY,
+        ]),
+        server: {
+            status: 200,
+            code: "A1009",
+            adapterCalls: 2,
+            responseHeaders: answeredHeaders("corpus-tx-committed"),
+            bodyBytes: JSON.stringify({
+                data: [CORPUS_AUTHOR, [CORPUS_AUTHOR]],
+                code: "A1009",
+                cause: null,
+            }),
+        },
+        client: { outcome: "resolve" },
+    },
+    {
+        label: "transaction — rolled back at step 1, a find.unique miss → 404 A2003 (its own status)",
+        request: planRequest("corpus-tx-rolled-back", [
+            AUTHORS_FIND_MANY,
+            planNode("authors", "find.unique", { where: { id: CORPUS_NOBODY } }, "fp1:WY0DNK9cOeveQr7rjKOdzA"),
+        ]),
+        server: {
+            status: 404,
+            code: "A2003",
+            causeKeys: ["message", "operation"],
+            adapterCalls: 2,
+            responseHeaders: answeredHeaders("corpus-tx-rolled-back"),
+            bodyBytes: JSON.stringify({
+                data: null,
+                code: "A2003",
+                cause: {
+                    message: "No record matched the unique selector.",
+                    operation: 1,
+                },
+            }),
+        },
+        client: { outcome: "framework-error", code: "A2003" },
+    },
+    invalid("transaction — a step that reads what an earlier delete cascaded into → 422 A2004 / V1019", planRequest("corpus-tx-cascade", [
+        planNode("authors", "delete.unique", { where: { id: CORPUS_AUTHOR.id } }, "fp1:ImWDaYNUDpIsjiuBSGBesg"),
+        planNode("books", "find.many", {}, "fp1:0vpQhJUZvleqWv_xMBvQug"),
+    ]), 422, "A2004", [{ code: "V1019", path: ["operations", 1, "resource"] }], 1),
+    ...["scope", "origin"].map((key) => invalid(`transaction — a plan node carrying "${key}" cannot smuggle an origin → 422 A2004 / V1001`, planRequest(`corpus-tx-smuggle-${key}`, [
+        { ...AUTHORS_FIND_MANY, [key]: "application" },
+    ]), 422, "A2004", [{ code: "V1001", path: [key] }], 0)),
+    invalid("R1: a client-hidden field — single route", corpusRequest("find/many", { select: ["id", "secret"] }, "corpus-r1-field"), 422, "A2004", [{ code: "V1005", path: ["arguments", "select", 1] }]),
+    invalid("R1: a client-hidden field — /_transactions", planRequest("corpus-r1-field-tx", [
+        AUTHORS_FIND_MANY,
+        planNode("authors", "find.many", { select: ["id", "secret"] }, "fp1:1t8vSfPuohv1N5MIX8ccNw"),
+    ]), 422, "A2004", [{ code: "V1005", path: ["arguments", "select", 1] }], 1),
+    invalid("R1: a client-restricted variant — single route", {
+        ...corpusRequest("", {}, "corpus-r1-variant"),
+        path: "/_resources/secrets/find/many",
+    }, 404, "A2002", [{ code: "V1006", path: ["operation"] }]),
+    invalid("R1: a client-restricted variant — /_transactions", planRequest("corpus-r1-variant-tx", [
+        AUTHORS_FIND_MANY,
+        planNode("secrets", "find.many", {}, "fp1:KegI5OcquDHi8z39VH11EQ"),
+    ]), 404, "A2002", [{ code: "V1006", path: ["operation"] }], 1),
+    invalid("R1: a client-hidden Resource — single route", {
+        ...corpusRequest("", {}, "corpus-r1-resource"),
+        path: "/_resources/hiddenRes/find/many",
+    }, 404, "A2001", [{ code: "V1005", path: ["resource"] }]),
+    invalid("R1: a client-hidden Resource — /_transactions", planRequest("corpus-r1-resource-tx", [
+        AUTHORS_FIND_MANY,
+        planNode("hiddenRes", "find.many", {}, "fp1:UY6pLVLKM2LaIMnfQa0zGw"),
+    ]), 404, "A2001", [{ code: "V1005", path: ["resource"] }], 1),
+    refused("method: GET on /_transactions → 405 A2012 with Allow: POST", planRequest("corpus-tx-get", [AUTHORS_FIND_MANY], { method: "GET" }), 405, "A2012", "The HTTP method is not allowed on this framework route.", { Allow: "POST" }),
+];
+/** A hash no corpus ClientContract has: a stale generated client's. */
+const STALE_HASH = `sha256:${"0".repeat(64)}`;
+/** The FVL's validation-failure text, which every A2001/A2002 envelope carries. */
+const VALIDATION_FAILED = "Operation arguments failed framework validation.";
+/**
+ * An absence answer (Q2's O3): core's own envelope for the same request,
+ * byte for byte (`corpus-contract.spec.ts` recomputes each operation row's
+ * through `framework.execute`), with zero Adapter calls.
+ */
+const absent = (label, request, status, code, cause) => ({
+    label: `absent: ${label}`,
+    request,
+    server: {
+        status,
+        code,
+        causeKeys: Object.keys(cause).sort(),
+        ...(Array.isArray(cause.issues)
+            ? {
+                issues: cause.issues.map(({ code: issue, path }) => ({ code: issue, path })),
+            }
+            : {}),
+        adapterCalls: 0,
+        responseHeaders: answeredHeaders(String(request.headers["Aventara-Request-Id"])),
+        bodyBytes: JSON.stringify({ data: null, code, cause }),
+    },
+    client: { outcome: "framework-error", code },
+});
+/** A corpus request to `path`, its identity headers overridden by `headers`. */
+const absentRequest = (path, requestId, headers = {}, method = "POST") => {
+    const base = corpusRequest("", {}, requestId);
+    return { ...base, method, path, headers: { ...base.headers, ...headers } };
+};
+const unavailableOperation = (resource, operation) => ({
+    message: VALIDATION_FAILED,
+    issues: [
+        {
+            path: ["operation"],
+            code: "V1006",
+            message: `Operation "${operation}" is not available on Resource "${resource}".`,
+        },
+    ],
+});
+const unavailableResource = (resource) => ({
+    message: VALIDATION_FAILED,
+    issues: [
+        {
+            code: "V1005",
+            path: ["resource"],
+            message: `Resource "${resource}" is not available in the active Contract.`,
+        },
+    ],
+});
+/**
+ * Family 6 — the absence responder (Q2's O3, Q3; plan S10). What a request
+ * for a route the ClientContract does not advertise answers, identically
+ * whether the host mounts one route per `protocol.surface()` entry with
+ * `protocol.answerAbsent` as its fallback or a catch-all whose decoder answers
+ * absence (Q12) — both styles drive these rows. Identity first, so a stale
+ * client hears `A2005` (F-716's server half), then the Resource, then the
+ * operation; zero Adapter calls. `_transactions` under `"none"` is asked of
+ * the corpus's second ClientContract, named by its hash.
+ */
+const ABSENCE = [
+    absent("an unadvertised operation, current hash → 404 A2002", absentRequest("/_resources/books/delete/many", "corpus-absent-op"), 404, "A2002", unavailableOperation("books", "delete.many")),
+    absent("an unadvertised operation, stale hash → 409 A2005 (regenerate)", absentRequest("/_resources/books/delete/many", "corpus-absent-stale", {
+        "Aventara-Contract-Hash": STALE_HASH,
+    }), 409, "A2005", {
+        message: "Generated client contract does not match the server. Regenerate the client.",
+    }),
+    absent("a stale hash before the method → 409 A2005", absentRequest("/_resources/authors/find/many", "corpus-absent-stale-get", { "Aventara-Contract-Hash": STALE_HASH }, "GET"), 409, "A2005", {
+        message: "Generated client contract does not match the server. Regenerate the client.",
+    }),
+    absent("another protocol version → 400 A2006", absentRequest("/_resources/books/delete/many", "corpus-absent-version", {
+        "Aventara-Protocol-Version": "2",
+    }), 400, "A2006", { message: "Aventara protocol version does not match the server." }),
+    absent("an unknown Resource → 404 A2001", absentRequest("/_resources/nope/find/many", "corpus-absent-resource"), 404, "A2001", unavailableResource("nope")),
+    absent("a Resource with operations: {} → 404 A2002 (M6)", absentRequest("/_resources/secrets/find/many", "corpus-absent-empty"), 404, "A2002", unavailableOperation("secrets", "find.many")),
+    absent("a client-hidden Resource → 404 A2001 (M7)", absentRequest("/_resources/hiddenRes/find/many", "corpus-absent-hidden"), 404, "A2001", unavailableResource("hiddenRes")),
+    absent('/_transactions under transactions "none" → 404 A2002 at ["operations"] (M17)', {
+        ...planRequest("corpus-absent-tx-none", [AUTHORS_FIND_MANY]),
+        headers: {
+            ...planRequest("corpus-absent-tx-none", [AUTHORS_FIND_MANY]).headers,
+            "Aventara-Contract-Hash": CORPUS_NONE_CLIENT_CONTRACT_HASH,
+        },
+    }, 404, "A2002", {
+        message: "Transaction plans are not available on the active Contract.",
+        issues: [
+            {
+                code: "V1006",
+                path: ["operations"],
+                message: "Transaction plans are not available on the active Contract.",
+            },
+        ],
+    }),
+];
+/**
+ * A row whose whole answer is stated: its status, its envelope byte for byte
+ * (each object's keys in the order core writes them, as measured), its cause
+ * keys and issues read off that envelope, and its Adapter calls. A success
+ * code resolves; any other code is a framework error.
+ */
+const answered = (label, request, status, adapterCalls, envelope, responseHeaders = answeredHeaders(String(request.headers["Aventara-Request-Id"]))) => {
+    const { cause } = envelope;
+    const issues = Array.isArray(cause?.issues)
+        ? cause.issues.map(({ code, path }) => path === undefined ? { code } : { code, path })
+        : undefined;
+    return {
+        label,
+        request,
+        server: {
+            status,
+            code: envelope.code,
+            ...(cause === null ? {} : { causeKeys: Object.keys(cause).sort() }),
+            ...(issues === undefined ? {} : { issues }),
+            adapterCalls,
+            responseHeaders,
+            bodyBytes: JSON.stringify({
+                data: envelope.data,
+                code: envelope.code,
+                cause,
+            }),
+        },
+        client: envelope.code.startsWith("A1")
+            ? { outcome: "resolve" }
+            : { outcome: "framework-error", code: envelope.code },
+    };
+};
+/** A corpus request to any Resource's operation route. */
+const routeRequest = (resource, operation, body, requestId, overrides = {}) => corpusRequest("", body, requestId, {
+    path: `/_resources/${resource}/${operation.replace(".", "/")}`,
+    ...overrides,
+});
+const NO_MATCH = "No record matched the unique selector.";
+/**
+ * Family 3 — absence semantics (§13.4): what a request that matches nothing
+ * answers, operation by operation. `find.first`'s `A1001` is family 2's.
+ */
+const ABSENCE_SEMANTICS = [
+    answered("absence: find.unique matching nothing → 404 A2003", routeRequest("authors", "find.unique", { where: { id: CORPUS_NOBODY } }, "corpus-none-find-unique"), 404, 1, { data: null, code: "A2003", cause: { message: NO_MATCH } }),
+    answered("absence: find.many matching nothing → 200 A1000 with []", routeRequest("authors", "find.many", { where: { id: CORPUS_NOBODY } }, "corpus-none-find-many"), 200, 1, { data: [], code: "A1000", cause: null }),
+    answered("absence: find.count matching nothing → 200 A1000 with 0", routeRequest("authors", "find.count", { where: { id: CORPUS_NOBODY } }, "corpus-none-find-count"), 200, 1, { data: 0, code: "A1000", cause: null }),
+    answered("absence: update.first matching nothing → 200 A1001 with null", routeRequest("authors", "update.first", { where: { id: CORPUS_NOBODY }, data: DATA }, "corpus-none-update-first"), 200, 1, { data: null, code: "A1001", cause: null }),
+    answered("absence: delete.first matching nothing → 200 A1001 with null", routeRequest("authors", "delete.first", { where: { id: CORPUS_NOBODY } }, "corpus-none-delete-first"), 200, 1, { data: null, code: "A1001", cause: null }),
+    answered("absence: update.unique with no target → 404 A2003", routeRequest("authors", "update.unique", { where: { id: CORPUS_NOBODY }, data: DATA }, "corpus-none-update-unique"), 404, 1, { data: null, code: "A2003", cause: { message: NO_MATCH } }),
+    answered("absence: delete.unique with no target → 404 A2003", routeRequest("authors", "delete.unique", { where: { id: CORPUS_NOBODY } }, "corpus-none-delete-unique"), 404, 1, { data: null, code: "A2003", cause: { message: NO_MATCH } }),
+];
+/** `{ id: { equals: "a1" } }` wrapped in `depth` single-member `AND`s. */
+const nested = (depth) => depth === 0
+    ? { id: { equals: CORPUS_AUTHOR.id } }
+    : { AND: [nested(depth - 1)] };
+/** 51 filter nodes under one `OR`: one over the default `maxBooleanNodes` (50). */
+const TOO_MANY_NODES = {
+    OR: Array.from({ length: 51 }, () => ({ id: { equals: CORPUS_AUTHOR.id } })),
+};
+/** A plan reference to `path` of step `operation`, whose fingerprint is `fingerprint`. */
+const ref = (operation, fingerprint, path) => ({
+    $ref: { operation, fingerprint, path: [path] },
+});
+/** Step 0 of every reference row: create an author, selecting its id. */
+const CREATE_ID = planNode("authors", "create.one", { data: { name: CORPUS_AUTHOR.name }, select: ["id"] }, "fp1:aMKNYrUwcifOeY8ZYk4pow");
+const CREATE_ID_PRINT = CREATE_ID.fingerprint;
+/** A `find.first` that matches nothing: a source with no value to refer to. */
+const FIRST_NOBODY = planNode("authors", "find.first", { where: { id: CORPUS_NOBODY } }, "fp1:qNR9mD7_iVygNtmuuXjymw");
+const ARGUMENTS_FAILED = "Operation arguments failed framework validation.";
+/**
+ * Family 4 — argument validation (§13.3; ADR 0008), core's own answers through
+ * the HTTP surface: an unknown field (`V1005`), an unadvertised operator
+ * (`V1006`), an invalid projection (`V1008`) → `A2004`; the three limits
+ * (`V1013` nesting, `V1014` a plan's operation count, `V1015` filter nodes) →
+ * `A2009`; a plan reference's index, fingerprint, path, type and value
+ * (`V1016`, `V1017`, `V1010`, `V1011`, `V1018`) → `A2007`. Rollup precedence
+ * (ADR 0008 decision 2), behaviourally: two `A2004` issues roll up together,
+ * and a limit refuses alone, before a field defect is read.
+ */
+const ARGUMENT_VALIDATION = [
+    answered("argument: an unknown field in where → 422 A2004 / V1005", corpusRequest("find/many", { where: { nope: { equals: "x" } } }, "corpus-arg-field"), 422, 0, {
+        data: null,
+        code: "A2004",
+        cause: {
+            message: ARGUMENTS_FAILED,
+            issues: [
+                {
+                    code: "V1005",
+                    path: ["arguments", "where", "nope"],
+                    message: 'Field "nope" is not available on Resource "authors".',
+                },
+            ],
+        },
+    }),
+    answered("argument: a filter operator the field does not advertise → 422 A2004 / V1006", corpusRequest("find/many", { where: { name: { contains: "A" } } }, "corpus-arg-operator"), 422, 0, {
+        data: null,
+        code: "A2004",
+        cause: {
+            message: ARGUMENTS_FAILED,
+            issues: [
+                {
+                    code: "V1006",
+                    path: ["arguments", "where", "name", "contains"],
+                    message: 'Filter operator "contains" is not available on field "name".',
+                },
+            ],
+        },
+    }),
+    answered("argument: select and include together → 422 A2004 / V1008", corpusRequest("find/many", { select: ["id"], include: [] }, "corpus-arg-projection"), 422, 0, {
+        data: null,
+        code: "A2004",
+        cause: {
+            message: ARGUMENTS_FAILED,
+            issues: [
+                {
+                    code: "V1008",
+                    path: ["arguments"],
+                    message: "select and include are mutually exclusive.",
+                },
+            ],
+        },
+    }),
+    answered("argument: two defects of one family roll up together → 422 A2004 / V1001 + V1005", corpusRequest("find/many", { take: 251, where: { nope: { equals: 1 } } }, "corpus-arg-rollup"), 422, 0, {
+        data: null,
+        code: "A2004",
+        cause: {
+            message: ARGUMENTS_FAILED,
+            issues: [
+                {
+                    code: "V1001",
+                    path: ["arguments", "take"],
+                    message: 'Argument "take" is not valid for find.many.',
+                },
+                {
+                    code: "V1005",
+                    path: ["arguments", "where", "nope"],
+                    message: 'Field "nope" is not available on Resource "authors".',
+                },
+            ],
+        },
+    }),
+    answered("argument: nesting over maxNestingDepth → 422 A2009 / V1013", corpusRequest("find/many", { where: nested(13) }, "corpus-arg-nesting"), 422, 0, {
+        data: null,
+        code: "A2009",
+        cause: {
+            message: ARGUMENTS_FAILED,
+            issues: [
+                {
+                    path: ["arguments", "where"],
+                    code: "V1013",
+                    message: "Request nesting exceeds maxNestingDepth (12).",
+                },
+            ],
+        },
+    }),
+    answered("argument: filter nodes over maxBooleanNodes → 422 A2009 / V1015", corpusRequest("find/many", { where: TOO_MANY_NODES }, "corpus-arg-nodes"), 422, 0, {
+        data: null,
+        code: "A2009",
+        cause: {
+            message: ARGUMENTS_FAILED,
+            issues: [
+                {
+                    path: ["arguments", "where"],
+                    code: "V1015",
+                    message: "Boolean/filter node count exceeds maxBooleanNodes (50).",
+                },
+            ],
+        },
+    }),
+    answered("argument: a limit refuses alone, before a field defect is read → 422 A2009 / V1015", corpusRequest("find/many", { where: TOO_MANY_NODES, select: ["nope"] }, "corpus-arg-precedence"), 422, 0, {
+        data: null,
+        code: "A2009",
+        cause: {
+            message: ARGUMENTS_FAILED,
+            issues: [
+                {
+                    path: ["arguments", "where"],
+                    code: "V1015",
+                    message: "Boolean/filter node count exceeds maxBooleanNodes (50).",
+                },
+            ],
+        },
+    }),
+    answered("argument: a plan over maxTransactionOperations → 422 A2009 / V1014", planRequest("corpus-arg-plan-size", Array.from({ length: 21 }, () => AUTHORS_FIND_MANY)), 422, 0, {
+        data: null,
+        code: "A2009",
+        cause: {
+            message: "Transaction operation count exceeds the active Contract limit.",
+            issues: [
+                {
+                    code: "V1014",
+                    path: ["operations"],
+                    message: "Transaction operation count exceeds maxTransactionOperations (20).",
+                },
+            ],
+        },
+    }),
+    ...[
+        [
+            "an operation index no earlier step has → 422 A2007 / V1016",
+            "corpus-arg-ref-index",
+            planNode("authors", "create.one", { data: { name: ref(5, CREATE_ID_PRINT, "id") } }, "fp1:NOPvPjrK18ki-rp5JekbCg"),
+            "V1016",
+            "name",
+            "operation",
+            "Transaction reference operation index is invalid.",
+            0,
+        ],
+        [
+            "a fingerprint that is not its source's → 422 A2007 / V1017",
+            "corpus-arg-ref-fingerprint",
+            planNode("authors", "create.one", { data: { name: ref(0, "fp1:AAAAAAAAAAAAAAAAAAAAAA", "id") } }, "fp1:LMKG9r39fh8Q4FsS2EbmSQ"),
+            "V1017",
+            "name",
+            "fingerprint",
+            "Transaction reference fingerprint does not match its source operation.",
+            0,
+        ],
+        [
+            "a path its source does not select → 422 A2007 / V1010",
+            "corpus-arg-ref-path",
+            planNode("authors", "create.one", { data: { name: ref(0, CREATE_ID_PRINT, "name") } }, "fp1:z-msTPG2tGrnDfhbp7OMNw"),
+            "V1010",
+            "name",
+            "path",
+            "Transaction reference path is not present in the source projection.",
+            0,
+        ],
+        [
+            "a source type its destination cannot take → 422 A2007 / V1011",
+            "corpus-arg-ref-type",
+            planNode("samples", "create.one", {
+                data: {
+                    count: "1",
+                    at: "2026-10-05T00:00:00.000Z",
+                    amount: "1",
+                    blob: ref(0, CREATE_ID_PRINT, "id"),
+                },
+            }, "fp1:kFeNIIPUkzjgT905qlgNUg"),
+            "V1011",
+            "blob",
+            "path",
+            "Transaction reference source type is not assignable to its destination.",
+            0,
+        ],
+    ].map(([what, requestId, step, code, field, member, message, calls]) => answered(`argument: a plan reference to ${what}`, planRequest(requestId, [CREATE_ID, step]), 422, calls, {
+        data: null,
+        code: "A2007",
+        cause: {
+            message: ARGUMENTS_FAILED,
+            issues: [
+                {
+                    code,
+                    path: ["operations", 1, "args", "data", field, "$ref", member],
+                    message,
+                },
+            ],
+            operation: 1,
+        },
+    })),
+    answered("argument: a plan reference that resolves to no value → 422 A2007 / V1018, after its source ran", planRequest("corpus-arg-ref-value", [
+        FIRST_NOBODY,
+        planNode("authors", "create.one", { data: { name: ref(0, "fp1:qNR9mD7_iVygNtmuuXjymw", "id") } }, "fp1:4EFGvMTB6fmhpeV65U9J9Q"),
+    ]), 422, 1, {
+        data: null,
+        code: "A2007",
+        cause: {
+            message: ARGUMENTS_FAILED,
+            issues: [
+                {
+                    code: "V1018",
+                    path: ["operations", 1, "args", "data", "name", "$ref", "path"],
+                    message: "Transaction reference resolved to no value.",
+                },
+            ],
+            operation: 1,
+        },
+    }),
+];
+/** The corpus identity headers, with `overrides` applied and `omit` left out. */
+const identityHeaders = (requestId, overrides = {}, omit) => Object.fromEntries(Object.entries({
+    "Content-Type": "application/json",
+    "Aventara-Protocol-Version": "1",
+    "Aventara-Contract-Hash": CORPUS_CLIENT_CONTRACT_HASH,
+    "Aventara-Request-Id": requestId,
+    ...overrides,
+}).filter(([name]) => name !== omit));
+const STALE_CLIENT = "Generated client contract does not match the server. Regenerate the client.";
+/**
+ * Family 5 — identity (§12.4; S7 follow-ups): a request missing either
+ * identity header is malformed (`A2000`), another protocol version is
+ * `A2006`, a stale or malformed hash is `A2005` with Appendix B.3's text (Q3),
+ * all on a route that exists; header names are matched without regard to case.
+ */
+const IDENTITY = [
+    refused("identity: no Aventara-Protocol-Version → 400 A2000", corpusRequest("find/many", {}, "corpus-id-no-version", {
+        headers: identityHeaders("corpus-id-no-version", {}, "Aventara-Protocol-Version"),
+    }), 400, "A2000", MALFORMED),
+    refused("identity: no Aventara-Contract-Hash → 400 A2000", corpusRequest("find/many", {}, "corpus-id-no-hash", {
+        headers: identityHeaders("corpus-id-no-hash", {}, "Aventara-Contract-Hash"),
+    }), 400, "A2000", MALFORMED),
+    refused("identity: another protocol version → 400 A2006", corpusRequest("find/many", {}, "corpus-id-version", {
+        headers: identityHeaders("corpus-id-version", {
+            "Aventara-Protocol-Version": "2",
+        }),
+    }), 400, "A2006", "Aventara protocol version does not match the server."),
+    refused("identity: a stale contract hash on a route that exists → 409 A2005", corpusRequest("find/many", {}, "corpus-id-stale", {
+        headers: identityHeaders("corpus-id-stale", {
+            "Aventara-Contract-Hash": `sha256:${"0".repeat(64)}`,
+        }),
+    }), 409, "A2005", STALE_CLIENT),
+    refused("identity: a malformed contract hash → 409 A2005", corpusRequest("find/many", {}, "corpus-id-malformed", {
+        headers: identityHeaders("corpus-id-malformed", {
+            "Aventara-Contract-Hash": "sha256:xyz",
+        }),
+    }), 409, "A2005", STALE_CLIENT),
+    answered("identity: header names in lower case → 200 A1000", corpusRequest("find/many", {}, "corpus-id-case", {
+        headers: Object.fromEntries(Object.entries(identityHeaders("corpus-id-case")).map(([name, value]) => [name.toLowerCase(), value])),
+    }), 200, 1, { data: [CORPUS_AUTHOR], code: "A1000", cause: null }, answeredHeaders("corpus-id-case")),
+];
+/** `authors.find.unique` naming the trigger `id` — what the guard or Adapter fails on. */
+const triggered = (id, requestId) => corpusRequest("find/unique", { where: { id } }, requestId);
+/**
+ * Family 10 — internal and authorization (§13.2; Q5, Q6), from the corpus's
+ * guard and Adapter failing on purpose (labelled by trigger,
+ * `CORPUS_TRIGGER`): `A3000`–`A3003` → 500 with `{ message }` only — no
+ * sub-code reaches the wire (Q5); `A4000` → 401, `A4001`/`A4002` → 403, with
+ * no reason member (Q6). Every one is a framework error, never a transport
+ * error: each body is an envelope.
+ */
+const INTERNAL = [
+    answered("internal: a guard that throws → 500 A3000", triggered(CORPUS_TRIGGER.guardThrows, "corpus-internal-a3000"), 500, 0, {
+        data: null,
+        code: "A3000",
+        cause: { message: "Internal framework error." },
+    }),
+    answered("internal: an Adapter that throws → 500 A3001", triggered(CORPUS_TRIGGER.adapterThrows, "corpus-internal-a3001"), 500, 1, {
+        data: null,
+        code: "A3001",
+        cause: { message: "Adapter execution failed." },
+    }),
+    answered("internal: a plan whose commit fails after the work → 500 A3002", planRequest("corpus-internal-a3002", [
+        planNode("authors", "update.unique", { where: { id: CORPUS_TRIGGER.commitFails }, data: DATA }, "fp1:8gs-RmzsqGlD_FFmk6dlQA"),
+    ]), 500, 1, { data: null, code: "A3002", cause: { message: "Transaction failed." } }),
+    answered("internal: a result the wire cannot spell → 500 A3003", routeRequest("samples", "find.unique", { where: { id: CORPUS_TRIGGER.unencodable } }, "corpus-internal-a3003"), 500, 1, {
+        data: null,
+        code: "A3003",
+        cause: { message: "Result serialization failed." },
+    }),
+    answered("internal: a guard that requires authentication → 401 A4000", triggered(CORPUS_TRIGGER.unauthenticated, "corpus-internal-a4000"), 401, 0, {
+        data: null,
+        code: "A4000",
+        cause: { message: "Authentication is required." },
+    }),
+    answered("internal: a guard that denies → 403 A4001", triggered(CORPUS_TRIGGER.guardDenies, "corpus-internal-a4001"), 403, 0, {
+        data: null,
+        code: "A4001",
+        cause: { message: "Operation denied by a framework guard." },
+    }),
+    answered("internal: a policy denial, no reason member → 403 A4002", triggered(CORPUS_TRIGGER.policyDenies, "corpus-internal-a4002"), 403, 0, {
+        data: null,
+        code: "A4002",
+        cause: { message: "Denied by the corpus policy." },
+    }),
+];
+/**
+ * Family 12 — conflict codes (§13.2): the corpus Adapter raising `A2008`,
+ * `A2013` and `A2014` from an `update.unique` → 409, `cause.issues` absent.
+ */
+const CONFLICT = [
+    [CORPUS_TRIGGER.conflict, "A2008"],
+    [CORPUS_TRIGGER.concurrentModification, "A2013"],
+    [CORPUS_TRIGGER.staleSelection, "A2014"],
+].map(([trigger, code]) => answered(`conflict: the Adapter answers ${code} → 409, no issues`, corpusRequest("update/unique", { where: { id: trigger }, data: DATA }, `corpus-conflict-${code}`), 409, 1, {
+    data: null,
+    code,
+    cause: { message: `The corpus Adapter answered ${code}.` },
+}));
+/** The one `samples` record in wire form (P1): what both encoders must write. */
+const SAMPLE_WIRE = {
+    id: "s1",
+    count: "9007199254740993",
+    at: "2026-10-05T12:34:56.789Z",
+    amount: "12.50",
+    blob: "/wAQ",
+};
+/** A `samples` create whose `blob` is `blob`. */
+const sampleCreate = (blob, requestId) => routeRequest("samples", "create.one", {
+    data: {
+        count: "1",
+        at: "2026-10-05T00:00:00.000Z",
+        amount: "1.5",
+        blob,
+    },
+}, requestId);
+/**
+ * Family 13 — wire scalars (P1, C1): a result carrying a `bigint`, a `Date`, a
+ * `Decimal` and a `Uint8Array` is written as their exact wire strings; a
+ * request `bytes` value whose padding carries non-zero bits is refused at the
+ * field, and its canonical spelling accepted. (The unencodable result is
+ * family 10's `A3003`.)
+ */
+const WIRE_SCALARS = [
+    answered("wire: a result's bigint, datetime, decimal and bytes in wire form → 200 A1000", routeRequest("samples", "find.unique", { where: { id: "s1" } }, "corpus-wire-result"), 200, 1, { data: SAMPLE_WIRE, code: "A1000", cause: null }),
+    answered('wire: bytes "AB==" (non-zero pad bits) → 422 A2004 / V1003, no Adapter call', sampleCreate("AB==", "corpus-wire-pad-bits"), 422, 0, {
+        data: null,
+        code: "A2004",
+        cause: {
+            message: ARGUMENTS_FAILED,
+            issues: [
+                {
+                    code: "V1003",
+                    path: ["arguments", "data", "blob"],
+                    message: "Value must use RFC 4648 base64 encoding.",
+                },
+            ],
+        },
+    }),
+    answered('wire: bytes "AA==" (canonical) → 201 A1002', sampleCreate("AA==", "corpus-wire-canonical"), 201, 1, { data: SAMPLE_WIRE, code: "A1002", cause: null }),
+];
+/**
+ * Family 14 — correlation (Q13): `Aventara-Request-Id` is adopted when it is
+ * 1–128 visible ASCII characters and echoed (every row above sends one and
+ * states its echo, refusals included); otherwise it is ignored — a fresh id
+ * is minted, whose value no row can state — and the request is never refused
+ * over it.
+ */
+const CORRELATION = [
+    answered("correlation: a 128-character id is adopted and echoed", corpusRequest("find/many", {}, "x".repeat(128)), 200, 1, { data: [CORPUS_AUTHOR], code: "A1000", cause: null }),
+    ...[
+        ["a 129-character id", "x".repeat(129)],
+        ["an empty id", ""],
+        ["an id with a space", "a b"],
+    ].map(([what, id]) => answered(`correlation: ${what} is not adopted, and never refused → 200 A1000`, corpusRequest("find/many", {}, id), 200, 1, { data: [CORPUS_AUTHOR], code: "A1000", cause: null }, { "Content-Type": "application/json" })),
+];
+export const AvProtocolFixtures = [
+    ...CONTRACT_DISCOVERY,
+    ...SUCCESS_STATUSES,
+    ...ABSENCE_SEMANTICS,
+    ...SCOPE_ADDED,
+    ...ARGUMENT_VALIDATION,
+    ...IDENTITY,
+    ...BODY_AND_MEDIA,
+    ...METHOD,
+    ...ABSENCE,
+    ...TRANSACTIONS,
+    ...INTERNAL,
+    ...CONFLICT,
+    ...WIRE_SCALARS,
+    ...CORRELATION,
+    ...TRANSPORT_ERRORS,
+];