@aventara/core 0.1.0-pilot.3 → 1.0.0-rc.0

package/dist/operations/structural-limits.walker.js

@@ -0,0 +1,344 @@
+import { lookupField, lookupResource } from "../contracts/contract-lookup.js";
+import { advertisedDirectives, holdsAt, } from "../contracts/field.js";
+import { NESTED_PROJECTION_SCOPE, resolveProjectionScope, } from "./projection-scope.resolver.js";
+const UNTRACKED = [];
+const RELATION_FILTER_OPERATORS = ["some", "every", "none"];
+const DIRECTIVE_PAYLOADS = new Map([
+    ["$connectOrCreate", [["create", "create"]]],
+    ["$update", [["data", "update"]]],
+    [
+        "$upsert",
+        [
+            ["create", "create"],
+            ["update", "update"],
+        ],
+    ],
+]);
+const NO_PAYLOADS = [];
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function extend(state, path, segment) {
+    return state.tracking ? [...path, segment] : UNTRACKED;
+}
+function nestingExceeded(state) {
+    state.nesting = {
+        path: ["arguments", state.rootKey],
+        code: "V1013",
+        message: `Request nesting exceeds maxNestingDepth (${state.nestingLimit}).`,
+    };
+}
+function countBooleanNode(state, path, key) {
+    if (state.booleanExceeded) {
+        return;
+    }
+    state.booleanCount += 1;
+    if (state.booleanCount > state.booleanLimit) {
+        state.booleanExceeded = true;
+        if (state.tracking) {
+            state.booleanNodes = {
+                path: [...path, key],
+                code: "V1015",
+                message: `Boolean/filter node count exceeds maxBooleanNodes (${state.booleanLimit}).`,
+            };
+        }
+    }
+}
+function walkWhere(state, resourceName, value, depth, path, counting) {
+    if (depth > state.nestingLimit) {
+        nestingExceeded(state);
+        return;
+    }
+    const resource = lookupResource(state.contract, resourceName);
+    if (!isRecord(value) || resource === undefined) {
+        return;
+    }
+    for (const key of Object.keys(value)) {
+        if (counting) {
+            countBooleanNode(state, path, key);
+        }
+        const child = value[key];
+        if (key === "AND" || key === "OR") {
+            if (Array.isArray(child)) {
+                for (let index = 0; index < child.length; index += 1) {
+                    walkWhere(state, resourceName, child[index], depth + 1, state.tracking ? [...path, key, index] : UNTRACKED, counting);
+                    if (state.nesting !== undefined) {
+                        return;
+                    }
+                }
+            }
+            continue;
+        }
+        if (key === "NOT") {
+            walkWhere(state, resourceName, child, depth + 1, extend(state, path, key), counting);
+        }
+        else {
+            const field = lookupField(resource, key);
+            if (field?.kind !== "relation") {
+                continue;
+            }
+            if (field.cardinality === "one") {
+                walkWhere(state, field.target, child, depth + 1, extend(state, path, key), counting);
+            }
+            else if (isRecord(child)) {
+                for (const operator of RELATION_FILTER_OPERATORS) {
+                    if (!(operator in child)) {
+                        continue;
+                    }
+                    walkWhere(state, field.target, child[operator], depth + 1, state.tracking ? [...path, key, operator] : UNTRACKED, counting);
+                    if (state.nesting !== undefined) {
+                        return;
+                    }
+                }
+            }
+        }
+        if (state.nesting !== undefined) {
+            return;
+        }
+    }
+}
+function walkOrderBy(state, resourceName, value, depth) {
+    const resource = lookupResource(state.contract, resourceName);
+    if (resource === undefined) {
+        return;
+    }
+    const entries = Array.isArray(value) ? value : [value];
+    for (let index = 0; index < entries.length; index += 1) {
+        const entry = entries[index];
+        if (!isRecord(entry)) {
+            continue;
+        }
+        for (const fieldName of Object.keys(entry)) {
+            const field = lookupField(resource, fieldName);
+            if (field?.kind !== "relation" || field.cardinality === "many") {
+                continue;
+            }
+            const relationDepth = depth + 1;
+            if (relationDepth > state.nestingLimit) {
+                nestingExceeded(state);
+                return;
+            }
+            walkOrderBy(state, field.target, entry[fieldName], relationDepth);
+            if (state.nesting !== undefined) {
+                return;
+            }
+        }
+    }
+}
+function soleKey(record) {
+    const keys = Object.keys(record);
+    return keys.length === 1 ? keys[0] : undefined;
+}
+function walkProjection(state, resourceName, value, depth, path, mode, scope) {
+    const resource = lookupResource(state.contract, resourceName);
+    if (!Array.isArray(value) || resource === undefined) {
+        return;
+    }
+    for (let index = 0; index < value.length; index += 1) {
+        const entry = value[index];
+        const relationName = isRecord(entry) ? soleKey(entry) : undefined;
+        const edge = relationName === undefined
+            ? undefined
+            : lookupField(resource, relationName);
+        if (relationName === undefined || edge?.kind !== "relation") {
+            continue;
+        }
+        const relationDepth = depth + 1;
+        if (relationDepth > state.nestingLimit) {
+            nestingExceeded(state);
+            return;
+        }
+        const projection = entry[relationName];
+        if (!isRecord(projection)) {
+            continue;
+        }
+        const relationPath = state.tracking
+            ? [...path, index, relationName]
+            : UNTRACKED;
+        const counted = scope !== undefined &&
+            holdsAt(mode === "select"
+                ? edge.capabilities.select
+                : edge.capabilities.include, scope);
+        if ("where" in projection) {
+            walkWhere(state, edge.target, projection.where, relationDepth, extend(state, relationPath, "where"), counted && edge.capabilities.filter?.includes("nested") === true);
+            if (state.nesting !== undefined) {
+                return;
+            }
+        }
+        if ("orderBy" in projection) {
+            walkOrderBy(state, edge.target, projection.orderBy, relationDepth);
+            if (state.nesting !== undefined) {
+                return;
+            }
+        }
+        for (const nestedMode of ["select", "include"]) {
+            if (!(nestedMode in projection)) {
+                continue;
+            }
+            walkProjection(state, edge.target, projection[nestedMode], relationDepth, extend(state, relationPath, nestedMode), nestedMode, counted ? NESTED_PROJECTION_SCOPE : undefined);
+            if (state.nesting !== undefined) {
+                return;
+            }
+        }
+    }
+}
+function walkMutationData(state, resourceName, value, depth, path, stage, counting) {
+    if (depth > state.nestingLimit) {
+        nestingExceeded(state);
+        return;
+    }
+    const resource = lookupResource(state.contract, resourceName);
+    if (!isRecord(value) || resource === undefined) {
+        return;
+    }
+    for (const fieldName of Object.keys(value)) {
+        const edge = lookupField(resource, fieldName);
+        const directives = value[fieldName];
+        if (edge?.kind !== "relation" || !isRecord(directives)) {
+            continue;
+        }
+        walkRelationDirectives(state, edge, directives, depth + 1, extend(state, path, fieldName), stage, counting);
+        if (state.nesting !== undefined) {
+            return;
+        }
+    }
+}
+function walkRelationDirectives(state, edge, directives, relationDepth, path, stage, counting) {
+    const supported = advertisedDirectives(edge.capabilities[stage]);
+    for (const directive of Object.keys(directives)) {
+        if (relationDepth > state.nestingLimit) {
+            nestingExceeded(state);
+            return;
+        }
+        const directivePath = extend(state, path, directive);
+        const directiveCounting = counting && supported?.includes(directive) === true;
+        const directiveValue = directives[directive];
+        if (Array.isArray(directiveValue)) {
+            for (let index = 0; index < directiveValue.length; index += 1) {
+                walkDirectiveEntry(state, edge.target, directive, directiveValue[index], relationDepth, extend(state, directivePath, index), directiveCounting);
+                if (state.nesting !== undefined) {
+                    return;
+                }
+            }
+        }
+        else {
+            walkDirectiveEntry(state, edge.target, directive, directiveValue, relationDepth, directivePath, directiveCounting);
+            if (state.nesting !== undefined) {
+                return;
+            }
+        }
+    }
+}
+function walkDirectiveEntry(state, target, directive, entry, relationDepth, path, counting) {
+    if (directive === "$create") {
+        walkMutationData(state, target, entry, relationDepth, path, "create", counting);
+        return;
+    }
+    if (!isRecord(entry)) {
+        return;
+    }
+    if ((directive === "$update" || directive === "$delete") &&
+        "where" in entry) {
+        walkWhere(state, target, entry.where, relationDepth, extend(state, path, "where"), counting);
+        if (state.nesting !== undefined) {
+            return;
+        }
+    }
+    for (const [key, stage] of DIRECTIVE_PAYLOADS.get(directive) ?? NO_PAYLOADS) {
+        if (!(key in entry)) {
+            continue;
+        }
+        walkMutationData(state, target, entry[key], relationDepth, extend(state, path, key), stage, counting);
+        if (state.nesting !== undefined) {
+            return;
+        }
+    }
+}
+function isUniqueOperation(request) {
+    return (request.variant === "unique" &&
+        (request.family === "find" ||
+            request.family === "update" ||
+            request.family === "delete" ||
+            request.family === "upsert"));
+}
+function walkArguments(state, request, args) {
+    const resource = request.resource;
+    const rootPath = (key) => {
+        state.rootKey = key;
+        return state.tracking ? ["arguments", key] : UNTRACKED;
+    };
+    if ("where" in args) {
+        walkWhere(state, resource, args.where, 1, rootPath("where"), !isUniqueOperation(request));
+        if (state.nesting !== undefined) {
+            return;
+        }
+    }
+    if ("orderBy" in args) {
+        rootPath("orderBy");
+        walkOrderBy(state, resource, args.orderBy, 0);
+        if (state.nesting !== undefined) {
+            return;
+        }
+    }
+    for (const mode of ["select", "include"]) {
+        if (!(mode in args)) {
+            continue;
+        }
+        walkProjection(state, resource, args[mode], 0, rootPath(mode), mode, resolveProjectionScope(lookupResource(state.contract, resource), request));
+        if (state.nesting !== undefined) {
+            return;
+        }
+    }
+    if ("data" in args) {
+        const path = rootPath("data");
+        const data = args.data;
+        if (Array.isArray(data)) {
+            for (let index = 0; index < data.length; index += 1) {
+                walkMutationData(state, resource, data[index], 0, extend(state, path, index), "create", request.family === "create");
+                if (state.nesting !== undefined) {
+                    return;
+                }
+            }
+        }
+        else {
+            walkMutationData(state, resource, data, 0, path, request.family === "update" ? "update" : "create", request.family === "create" || request.family === "update");
+            if (state.nesting !== undefined) {
+                return;
+            }
+        }
+    }
+    for (const branch of ["create", "update"]) {
+        if (!(branch in args)) {
+            continue;
+        }
+        walkMutationData(state, resource, args[branch], 0, rootPath(branch), branch, request.family === "upsert");
+        if (state.nesting !== undefined) {
+            return;
+        }
+    }
+}
+function walk(contract, request, args, tracking) {
+    const state = {
+        contract,
+        nestingLimit: contract.limits.maxNestingDepth,
+        booleanLimit: contract.limits.maxBooleanNodes,
+        tracking,
+        rootKey: "",
+        booleanCount: 0,
+        nesting: undefined,
+        booleanNodes: undefined,
+        booleanExceeded: false,
+    };
+    walkArguments(state, request, args);
+    return state;
+}
+export function findStructuralLimitIssues(contract, request, args) {
+    const untracked = walk(contract, request, args, false);
+    if (untracked.nesting !== undefined || !untracked.booleanExceeded) {
+        return { nesting: untracked.nesting, booleanNodes: undefined };
+    }
+    return {
+        nesting: undefined,
+        booleanNodes: walk(contract, request, args, true).booleanNodes,
+    };
+}

package/dist/operations/validation-code.d.ts

@@ -1,26 +1,14 @@
-/**
- * It is a runtime array for the same reason `OPERATION_CODES` is one: the union
- * below is the compiler's view of the set, and the response boundary needs the set
- * itself to test a thrower-supplied code by identity before emitting it.
- */
+/** The set of allocated Validation codes, as a runtime array. */
 export declare const VALIDATION_CODES: readonly ["V1000", "V1001", "V1002", "V1003", "V1004", "V1005", "V1006", "V1007", "V1008", "V1009", "V1010", "V1011", "V1012", "V1013", "V1014", "V1015", "V1016", "V1017", "V1018", "V1019"];
+/** A validation code (`V1000` and up), one per kind of argument problem. */
 export type ValidationCode = (typeof VALIDATION_CODES)[number];
-/**
- * This is the text the response boundary emits in place of a thrower-supplied
- * issue message, which is untrusted and may carry provider text that specification
- * 13.5 forbids in `cause`.
- *
- * It is deliberately not the only message a `V` code may ever carry. A framework
- * producer knows the offending field, limit or reference and says so; those issues
- * are built here and mapped straight to their envelope by `mapValidationOutcome`,
- * never through the sanitization boundary. This table is the floor for an issue
- * the framework did not author, not a ceiling on the ones it did.
- */
+/** The framework's message for each validation code. */
 export declare const VALIDATION_CODE_MESSAGES: Readonly<Record<ValidationCode, string>>;
+/** One validation problem: its code, message and the argument path it is at. */
 export type ValidationIssue = {
     readonly path?: readonly (string | number)[];
     readonly code: ValidationCode;
     readonly message: string;
 };
-/** Builds one Framework Validation Layer issue at its path. */
+/** Builds one validation issue at its path. */
 export declare function validationIssue(code: ValidationCode, path: readonly (string | number)[], message: string): ValidationIssue;

package/dist/operations/write-scope.resolver.d.ts

@@ -3,38 +3,13 @@ import type { Contract } from "../contracts/contract.js";
 import type { Resource } from "../contracts/resource.js";
 import type { OperationIdentity } from "./operation-identity.js";
 /**
- * Which write position one request's **top-level** `data` (or `create`/`update`)
- * argument sits in, read off the variant the Resource advertises.
- *
- * The write mirror of `resolveProjectionScope`, and a separate function for the
- * reason `resource-operations.ts` gives for `projectionScopeOf`/`writeScopeOf`
- * being two: the axes are measured and consulted independently — the flat-bulk
- * write scope covers four variants where the bulk-returning projection scope
- * covers two — and a caller that needs one position should not be handed the other
- * to discard.
- *
- * `"nested"` is the answer wherever nothing narrower is stated — an absent
- * Resource, an unadvertised variant, `true`, or a descriptor that qualifies only
- * its projection argument. Availability is **not** decided here: an unadvertised
- * operation is refused by `operation-validator.ts` before the mutation walk runs,
- * and answering `"nested"` for one keeps this function a write question rather than
- * a second, weaker copy of the availability gate.
+ * Which write position one request's top-level `data` (or `create`/`update`)
+ * argument sits in, read off the variant the Resource advertises. `"nested"`
+ * wherever nothing narrower is stated.
  */
 export declare function resolveWriteScope(resource: Resource<Contract> | undefined, request: OperationIdentity): WriteScope;
 /**
  * The position a write NESTED beneath an admitted relation directive sits in: the
  * unrestricted one, at every depth, under every top-level scope.
- *
- * It is a constant and not a parameter the recursion threads, because there is no
- * depth at which the answer differs. A relation write reached through `$create`,
- * `$connectOrCreate.create`, `$update.data` or `$upsert`'s two branches lands in
- * the unrestricted write input on both pilot engines, whatever the top-level
- * argument was. The measurement behind that is the flat bulk write inputs carrying
- * **no relation member at all**, so a nested write is only ever reachable
- * *through* a relation the top-level scope already admitted — and past that point
- * the full write surface returns.
- *
- * Naming it is the point, exactly as `NESTED_PROJECTION_SCOPE` names the same
- * decision on the read axis.
  */
 export declare const NESTED_WRITE_SCOPE: WriteScope;

package/dist/protocol/absent-route.responder.d.ts

@@ -1,16 +1,18 @@
 import type { FrameworkContracts } from "../compiler/contract.compiler.js";
 import { type OperationIdentity } from "../operations/operation-identity.js";
+import { type FrameworkDiagnosticsSink } from "../runtime/diagnostics-reporter.js";
 import type { ClientProtocolIdentity } from "../runtime/operation-request.js";
 import { type OperationFailureResponse } from "../runtime/operation-response.js";
 import type { AvProtocolRequest } from "./http-request.decoder.js";
 import { type ReadRequest } from "./http-request.reader.js";
 import { type AvProtocolResponse } from "./http-response.encoder.js";
 /**
- * "Removed" and "never existed" are not distinguished; a stale client hears
- * `A2005` first.
- *
- * It reads the compiled Contracts only — passive data — so nothing it depends on
- * can execute an operation.
+ * The absence answers: the checks a framework route makes before it reads a body, runs
+ * a pipeline or reaches an Adapter — the protocol version (`A2006`), the
+ * ClientContract hash (`A2005`), then whether the ClientContract advertises the route
+ * at all (`A2001`, `A2002`). Every envelope is the one the Framework Validation Layer
+ * answers for the same request, so a caller cannot tell which layer answered. Reads
+ * the compiled Contracts only.
  */
 /** A route's three decoded segments, still untrusted strings. */
 export type OperationRouteSegments = {
@@ -28,18 +30,18 @@ export type OperationRouteResolution = {
 };
 /**
  * An operation route `/_resources/<resource>/<family>/<variant>` under one client
- * protocol identity: version → hash → Resource → operation. A Resource key is
- * matched exactly and only as the ClientContract's own key; a family/variant pair
- * only when it is a standard operation the Resource advertises, read through
+ * protocol identity: version → hash → Resource → operation. A Resource key is matched
+ * exactly and only as the ClientContract's own key; a family/variant pair only when it
+ * is a standard operation the Resource advertises, read through
  * `isOperationVariantAvailable` alone.
  */
 export declare function resolveOperationRoute(contracts: FrameworkContracts, protocol: ClientProtocolIdentity, route: OperationRouteSegments): OperationRouteResolution;
 /**
- * The `/_transactions` route under one client protocol identity: version → hash →
- * the ClientContract's transaction capability. The route exists only when that
- * capability is `"interactive"` — tested against the value itself, as
- * `protocol.surface()` tests it — and is otherwise absent with core's own refusal
- * of a plan. `undefined` when the route is there.
+ * The `/_transactions` route under one client protocol identity: version → hash → the
+ * ClientContract's transaction capability. The route exists only when that capability
+ * is `"interactive"` — tested against the value itself, as `protocol.surface()` tests
+ * it — and is otherwise absent with core's own refusal of a plan. `undefined` when the
+ * route is there.
  */
 export declare function transactionsRouteFailure(contracts: FrameworkContracts, protocol: ClientProtocolIdentity): OperationFailureResponse | undefined;
 /**
@@ -54,12 +56,12 @@ type RouteCheck<Route> = ({
     readonly response: AvProtocolResponse;
 };
 /**
- * An operation route's checks before its body (decoder steps 2–4): the path
- * (`A2000` unless `/_resources/<r>/<f>/<v>`, each segment decodable and none
- * empty), the identity headers' presence (`A2000`), then {@link
- * resolveOperationRoute} — version, hash, Resource, operation — and the method
- * (`A2012`, `Allow: POST`). One sequence for both route styles: `decodeOperation`
- * reads the body only after it passes, `answerAbsent` never.
+ * An operation route's checks before its body (decoder steps 2–4): the path (`A2000`
+ * unless `/_resources/<r>/<f>/<v>`, each segment decodable and none empty), the
+ * identity headers' presence (`A2000`), then {@link resolveOperationRoute} — version,
+ * hash, Resource, operation — and the method (`A2012`, `Allow: POST`). One sequence
+ * for both route styles: `decodeOperation` reads the body only after it passes,
+ * `answerAbsent` never.
  */
 export declare function checkOperationRoute(contracts: FrameworkContracts, read: ReadRequest): RouteCheck<{
     readonly resource: string;
@@ -74,25 +76,9 @@ export declare function checkOperationRoute(contracts: FrameworkContracts, read:
 export declare function checkTransactionsRoute(contracts: FrameworkContracts, read: ReadRequest): RouteCheck<object>;
 /**
  * `protocol.answerAbsent(request)` — the fallback a host that mounts one route per
- * `protocol.surface()` entry mounts for every path it did not. Never a catch-all
- * into framework handling: it reads no body, runs no pipeline, calls no Adapter,
- * and takes only the compiled Contracts. In order:
- *
- * 1. a value that is not an `AvProtocolRequest` → `400 A2000`, minted id;
- * 2. a path outside the protocol's underscore namespace → `undefined`: the host
- *    answers it itself — `/favicon.ico` is not the framework's;
- * 3. `/_contract`: any method but `GET` → `405 A2012` with `Allow: GET`; no
- *    identity header is read;
- * 4. `/_transactions`, or else an operation route: exactly what the catch-all
- *    host's decoder answers before its body — path syntax and identity presence
- *    (`A2000`), version (`A2006`), hash (`A2005`), Resource (`A2001`), operation
- *    or the `"none"` capability (`A2002`), method (`A2012`, `Allow: POST`) — each
- *    core's own envelope;
- * 5. a route that EXISTS, reached with its own method — the host mounted only part
- *    of the surface — → `500 A3000`: a host wiring bug made visible, never a
- *    silent 404.
- *
- * Every framework answer echoes `Aventara-Request-Id`.
+ * `protocol.surface()` entry mounts for every path it did not. Never a catch-all into
+ * framework handling: it reads no body, runs no pipeline, calls no Adapter, and takes
+ * only the compiled Contracts. In order:
  */
-export declare function answerAbsentRequest(contracts: FrameworkContracts, received: AvProtocolRequest): AvProtocolResponse | undefined;
+export declare function answerAbsentRequest(contracts: FrameworkContracts, received: AvProtocolRequest, sink?: FrameworkDiagnosticsSink): AvProtocolResponse | undefined;
 export {};

package/dist/protocol/absent-route.responder.js

@@ -3,6 +3,7 @@ import { isOperationVariantAvailable, } from "../contracts/resource-operations.j
 import { parseOperationIdentity, } from "../operations/operation-identity.js";
 import { operationUnavailableIssue } from "../operations/operation-validator.js";
 import { resourceUnavailableIssue } from "../operations/operation-validator-core.js";
+import { createReporter, } from "../runtime/diagnostics-reporter.js";
 import { INTERNAL_FAILURE_MESSAGE, operationFailure, } from "../runtime/operation-response.js";
 import { protocolIdentityFailure } from "../runtime/operation-runtime.js";
 import { mapValidationOutcome } from "../runtime/outcome-mapper.js";
@@ -11,6 +12,7 @@ import { CONTRACT_ROUTE, GET_ONLY, isProtocolPath, operationRouteSegments, POST_
 import { encodeOperationResponse, } from "./http-response.encoder.js";
 import { identityHeadersMissing, transportFailure, } from "./protocol-failure.js";
 import { missingIdentityHeaders } from "./protocol-headers.js";
+import { UnmountedRouteError } from "./unmounted-route.error.js";
 export function resolveOperationRoute(contracts, protocol, route) {
     const identityFailure = protocolIdentityFailure(contracts, protocol);
     if (identityFailure !== undefined) {
@@ -29,7 +31,9 @@ export function resolveOperationRoute(contracts, protocol, route) {
         !isOperationVariantAvailable(lookupOwn(lookupOwn(advertised, route.family), route.variant))) {
         return {
             ok: false,
-            failure: mapValidationOutcome([operationUnavailableIssue(route)]),
+            failure: mapValidationOutcome([
+                operationUnavailableIssue(contracts.client, route),
+            ]),
         };
     }
     return { ok: true, operation };
@@ -82,7 +86,7 @@ function identityFailureOf(read) {
 function refusedWith(response) {
     return { ok: false, response };
 }
-export function answerAbsentRequest(contracts, received) {
+export function answerAbsentRequest(contracts, received, sink) {
     const read = readRequest(received);
     if (!read.ok) {
         return read.response;
@@ -96,10 +100,32 @@ export function answerAbsentRequest(contracts, received) {
             ? unmounted(read.requestId)
             : transportFailure("A2012", read.requestId, GET_ONLY);
     }
-    const route = path === TRANSACTIONS_ROUTE
-        ? checkTransactionsRoute(contracts, read)
-        : checkOperationRoute(contracts, read);
-    return route.ok ? unmounted(read.requestId) : route.response;
+    if (path === TRANSACTIONS_ROUTE) {
+        const route = checkTransactionsRoute(contracts, read);
+        if (!route.ok) {
+            return route.response;
+        }
+        createReporter(sink, {
+            kind: "transaction",
+            origin: "client",
+            requestId: read.requestId,
+        })(new UnmountedRouteError("transactions", `POST ${TRANSACTIONS_ROUTE}`), "A3000");
+        return unmounted(read.requestId);
+    }
+    const route = checkOperationRoute(contracts, read);
+    if (!route.ok) {
+        return route.response;
+    }
+    const { family, variant } = route.operation;
+    createReporter(sink, {
+        kind: "operation",
+        origin: "client",
+        resource: route.resource,
+        family,
+        variant,
+        requestId: read.requestId,
+    })(new UnmountedRouteError(`${route.resource}.${family}.${variant}`, `POST ${path}`), "A3000");
+    return unmounted(read.requestId);
 }
 function unmounted(requestId) {
     return encodeOperationResponse(operationFailure("A3000", { message: INTERNAL_FAILURE_MESSAGE }), requestId);

package/dist/protocol/av-protocol.d.ts

@@ -1,12 +1,6 @@
 /**
- * The members of `AvProtocol`, as this module's own named exports. The entry
- * (`./index.ts`) publishes this module whole as the namespace `AvProtocol`: the
- * language freezes a module namespace, and a bundler drops the members a consumer
- * does not read.
- *
- * Re-exports only — no logic lives here. Every member is pinned, by name and by
- * type, in `./index.test-d.ts`, whose exact `keyof` set fails when a member is
- * added or removed without a row.
+ * The HTTP protocol: pure functions and data a host uses to serve a Framework.
+ * Start with `AvProtocol.bind(framework)`.
  */
 export { normalizeEntrypoint } from "../config/entrypoint.normalizer.js";
 export { scalarFormats } from "../contracts/wire-scalar-format.js";

package/dist/protocol/contract-document.responder.d.ts

@@ -2,9 +2,9 @@ import type { ClientContract } from "../contracts/contract.js";
 import type { AvProtocolRequest } from "./http-request.decoder.js";
 import type { AvProtocolResponse } from "./http-response.encoder.js";
 /**
- * The served ClientContract, written once per binding: its JCS-canonical bytes and
- * its entity tag, the quoted contract hash. The bytes include `protocol.hash`,
- * although the hash's own input excludes it.
+ * The served ClientContract, written once per binding: its JCS-canonical bytes and its
+ * entity tag, the quoted contract hash. The bytes include `protocol.hash`, although
+ * the hash's own input excludes it.
  */
 export type ContractDocument = {
     readonly body: string;
@@ -13,20 +13,7 @@ export type ContractDocument = {
 /** The bound ClientContract as the document `_contract` serves. */
 export declare function contractDocumentOf(client: ClientContract): ContractDocument;
 /**
- * `protocol.encodeContract(request)`: the `GET <entrypoint>/_contract` responder.
- * In order:
- *
- * 1. a value that is not an `AvProtocolRequest` → `400 A2000` under a minted id
- *    (as the decoders answer it);
- * 3. a path other than `/_contract` → `400 A2000` (path syntax this route cannot
- *    read, as a decoder answers one);
- * 4. a method other than `GET` → `405 A2012` with `Allow: GET`;
- * 5. `If-None-Match` matching the document's entity tag — RFC 9110 §13.1.2's weak
- *    comparison, over a comma-separated list, or `*` — → `304 Not Modified`, no
- *    body, still carrying `ETag` and `Cache-Control`; otherwise `200` with the
- *    canonical bytes, `ETag`, `Cache-Control: no-cache` and `Content-Type:
- *    application/json`.
- *
- * No identity header is required or read, and the body is never read.
+ * `protocol.encodeContract(request)`: the `GET <entrypoint>/_contract` responder. In
+ * order:
  */
 export declare function encodeContractRequest(document: ContractDocument, received: AvProtocolRequest): AvProtocolResponse;