@aventara/core 1.0.0-rc.0 → 1.0.0-rc.2

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

@@ -28,6 +28,109 @@ function nestingExceeded(state) {
         message: `Request nesting exceeds maxNestingDepth (${state.nestingLimit}).`,
     };
 }
+function jsonDepthExceeded(state, fieldPath) {
+    state.nestingAtField = true;
+    state.nesting = {
+        path: state.tracking ? fieldPath : ["arguments", state.rootKey],
+        code: "V1021",
+        message: `Json value depth exceeds maxJsonDepth (${state.jsonDepthLimit}).`,
+    };
+}
+function isJsonField(field) {
+    return "scalar" in field.type && field.type.scalar === "json";
+}
+function jsonValueExceeds(state, value) {
+    const deepest = new Map();
+    const ancestors = new Set();
+    const stack = [{ leave: false, value, level: 0 }];
+    while (stack.length > 0) {
+        const task = stack.pop();
+        if (task.leave) {
+            ancestors.delete(task.container);
+            continue;
+        }
+        const current = task.value;
+        if (typeof current !== "object" ||
+            current === null ||
+            ancestors.has(current)) {
+            continue;
+        }
+        const inner = task.level + 1;
+        if (inner > state.jsonDepthLimit) {
+            return true;
+        }
+        const seen = deepest.get(current);
+        if (seen !== undefined && seen >= inner) {
+            continue;
+        }
+        deepest.set(current, inner);
+        ancestors.add(current);
+        stack.push({ leave: true, container: current });
+        const entries = Array.isArray(current)
+            ? current
+            : Object.values(current);
+        for (const entry of entries) {
+            stack.push({ leave: false, value: entry, level: inner });
+        }
+    }
+    return false;
+}
+function walkJsonWrite(state, field, value, path) {
+    const operands = isRecord(value) && Object.keys(value).some((key) => key.startsWith("$"))
+        ? Object.entries(value)
+            .filter(([key]) => key !== "$unset" && key !== "$ref")
+            .map(([, operand]) => operand)
+        : [value];
+    for (const operand of operands) {
+        const values = field.list && Array.isArray(operand) ? operand : [operand];
+        for (const entry of values) {
+            if (jsonValueExceeds(state, entry)) {
+                jsonDepthExceeded(state, path);
+                return;
+            }
+        }
+    }
+}
+const JSON_LIST_OPERATORS = new Set(["in", "notIn", "hasEvery", "hasSome"]);
+const JSON_VALUELESS_OPERATORS = new Set(["mode", "isEmpty", "path"]);
+function walkJsonFilter(state, filter, depth, path) {
+    let level = depth;
+    let current = filter;
+    while (isRecord(current)) {
+        let next;
+        for (const operator of Object.keys(current)) {
+            const operand = current[operator];
+            if (operator === "not" && isRecord(operand)) {
+                next = operand;
+                continue;
+            }
+            if (JSON_VALUELESS_OPERATORS.has(operator)) {
+                continue;
+            }
+            const values = JSON_LIST_OPERATORS.has(operator) && Array.isArray(operand)
+                ? operand
+                : [operand];
+            for (const entry of values) {
+                if (jsonValueExceeds(state, entry)) {
+                    jsonDepthExceeded(state, path);
+                    return;
+                }
+            }
+        }
+        if (next === undefined) {
+            return;
+        }
+        level += 1;
+        if (level > state.nestingLimit) {
+            nestingExceeded(state);
+            return;
+        }
+        current = next;
+    }
+    if (jsonValueExceeds(state, current)) {
+        jsonDepthExceeded(state, path);
+    }
+}
 function countBooleanNode(state, path, key) {
     if (state.booleanExceeded) {
         return;
@@ -74,7 +177,18 @@ function walkWhere(state, resourceName, value, depth, path, counting) {
         }
         else {
             const field = lookupField(resource, key);
+            if (field?.kind === "scalar") {
+                if (isJsonField(field)) {
+                    walkJsonFilter(state, child, depth, extend(state, path, key));
+                }
+                else {
+                    walkScalarNot(state, child, depth);
+                }
+            }
             if (field?.kind !== "relation") {
+                if (state.nesting !== undefined) {
+                    return;
+                }
                 continue;
             }
             if (field.cardinality === "one") {
@@ -97,6 +211,22 @@ function walkWhere(state, resourceName, value, depth, path, counting) {
         }
     }
 }
+function walkScalarNot(state, filter, depth) {
+    let level = depth;
+    let current = filter;
+    while (isRecord(current) && Object.hasOwn(current, "not")) {
+        const operand = current.not;
+        if (!isRecord(operand)) {
+            return;
+        }
+        level += 1;
+        if (level > state.nestingLimit) {
+            nestingExceeded(state);
+            return;
+        }
+        current = operand;
+    }
+}
 function walkOrderBy(state, resourceName, value, depth) {
     const resource = lookupResource(state.contract, resourceName);
     if (resource === undefined) {
@@ -194,6 +324,13 @@ function walkMutationData(state, resourceName, value, depth, path, stage, counti
     for (const fieldName of Object.keys(value)) {
         const edge = lookupField(resource, fieldName);
         const directives = value[fieldName];
+        if (edge?.kind === "scalar" && isJsonField(edge)) {
+            walkJsonWrite(state, edge, directives, extend(state, path, fieldName));
+            if (state.nesting !== undefined) {
+                return;
+            }
+            continue;
+        }
         if (edge?.kind !== "relation" || !isRecord(directives)) {
             continue;
         }
@@ -321,11 +458,13 @@ function walk(contract, request, args, tracking) {
     const state = {
         contract,
         nestingLimit: contract.limits.maxNestingDepth,
+        jsonDepthLimit: contract.limits.maxJsonDepth,
         booleanLimit: contract.limits.maxBooleanNodes,
         tracking,
         rootKey: "",
         booleanCount: 0,
         nesting: undefined,
+        nestingAtField: false,
         booleanNodes: undefined,
         booleanExceeded: false,
     };
@@ -334,6 +473,12 @@ function walk(contract, request, args, tracking) {
 }
 export function findStructuralLimitIssues(contract, request, args) {
     const untracked = walk(contract, request, args, false);
+    if (untracked.nestingAtField) {
+        return {
+            nesting: walk(contract, request, args, true).nesting,
+            booleanNodes: undefined,
+        };
+    }
     if (untracked.nesting !== undefined || !untracked.booleanExceeded) {
         return { nesting: untracked.nesting, booleanNodes: undefined };
     }

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

@@ -1,14 +1,19 @@
+import type { AvFieldCheck } from "../contracts/field-check.js";
 /** 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"];
+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", "V1020", "V1021"];
 /** A validation code (`V1000` and up), one per kind of argument problem. */
-export type ValidationCode = (typeof VALIDATION_CODES)[number];
+export type AvValidationCode = (typeof VALIDATION_CODES)[number];
 /** The framework's message for each validation code. */
-export declare const VALIDATION_CODE_MESSAGES: Readonly<Record<ValidationCode, string>>;
+export declare const VALIDATION_CODE_MESSAGES: Readonly<Record<AvValidationCode, string>>;
 /** One validation problem: its code, message and the argument path it is at. */
-export type ValidationIssue = {
+export type AvValidationIssue = {
     readonly path?: readonly (string | number)[];
-    readonly code: ValidationCode;
+    readonly code: AvValidationCode;
     readonly message: string;
+    /** The failed field validator's check name (`max_length`, `string_format`, …). */
+    readonly check?: AvFieldCheck["check"];
+    /** That check's parameters, as the Contract stores them (`{ maximum: 80 }`). */
+    readonly params?: Readonly<Record<string, unknown>>;
 };
 /** Builds one validation issue at its path. */
-export declare function validationIssue(code: ValidationCode, path: readonly (string | number)[], message: string): ValidationIssue;
+export declare function validationIssue(code: AvValidationCode, path: readonly (string | number)[], message: string): AvValidationIssue;

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

@@ -0,0 +1,6 @@
+import type { ErrorCodeGuidance } from "../runtime/error-guidance.js";
+import type { AvValidationCode } from "./validation-code.js";
+/** Cause and fix of every validation code. */
+export declare const VALIDATION_CODE_GUIDANCE: {
+    readonly [C in AvValidationCode]: ErrorCodeGuidance;
+};

package/dist/operations/validation-code.guidance.js

@@ -0,0 +1,90 @@
+export const VALIDATION_CODE_GUIDANCE = {
+    V1000: {
+        cause: "A required value is absent: a create leaves out a required field that has no database default and no compute.create (the path names the field), a required relation and its reference field are both missing, a typed Json field lacks a required key, or a $ref has no fingerprint.",
+        fix: "Send the value at the issue's path. When the server must fill it, give the field a compute.create stage or a database default; a pipe cannot fill it.",
+    },
+    V1001: {
+        cause: "A value of the wrong type: a string where a number is expected, a negative limit, a non-integer id, null given to an operator with no null meaning (gt, contains, in), two directives in one scalar action object (`{ $increment: 1, $decrement: 2 }`), or a server-side value that is not plain data.",
+        fix: "Send the type the contract states at that path (the generated client's types say it).",
+    },
+    V1002: {
+        cause: "A value that is not a member of the enum, or outside a typed Json field's AvZ.enum or AvZ.literal.",
+        fix: "Send one of the enum's members.",
+    },
+    V1003: {
+        cause: 'A malformed datetime, decimal, base64 or UUID string, or a failed pattern or format validator (`check: "string_format"`).',
+        fix: "Send the canonical encoding (ISO-8601 UTC datetime, decimal string, base64 bytes) and satisfy the validator that check and params name.",
+    },
+    V1004: {
+        cause: "A number, length or size outside its range: a failed bound, length or size validator, a BigInt outside signed 64 bits, an AvZ.int() outside the safe integer range, or a transaction with no operations.",
+        fix: "Send a value inside the range; check and params name the validator that failed.",
+    },
+    V1005: {
+        cause: "A field that does not exist or is hidden in the caller's layer, an unknown Resource (under A2001), or a key a typed Json field's shape does not declare.",
+        fix: "Use a field the caller's contract exposes, expose it through exemptions, or make the call from server code.",
+    },
+    V1006: {
+        cause: "An operator, directive or nested write the field does not offer (at any depth, inside not too; a to-many $update's data takes only what a bulk write takes), a mode it does not offer, or an operation that is not available (under A2002).",
+        fix: "Use what the contract lists for that field or Resource, or expose it through exemptions.",
+    },
+    V1007: {
+        cause: "The where of a unique operation is not exactly one complete identifier.",
+        fix: "Pass exactly one identifier: the id, or every field of one @unique or @@unique.",
+    },
+    V1008: {
+        cause: "Both select and include, a write-only field selected, or a relation that is not selectable there.",
+        fix: "Use select or include, not both, and select only readable fields.",
+    },
+    V1009: {
+        cause: "A cursor without an explicit orderBy, or cursor keys that do not match the ordered fields.",
+        fix: "Give an orderBy and a cursor holding exactly its ordered fields.",
+    },
+    V1010: {
+        cause: "A $ref path the earlier step does not return, a $ref to a step that is not in the transaction, or to a step with no single row (a many or count step).",
+        fix: "Select the referenced field in the earlier step, and reference a single-row step.",
+    },
+    V1011: {
+        cause: "The referenced value's type does not fit its target, a nullable source where only a non-null value is accepted included.",
+        fix: "Reference a field of the target's type, non-null where the target needs it.",
+    },
+    V1012: {
+        cause: "A nested write that does not fit the relation (a list where one record is expected), a reference field set together with its own relation, one record mixing reference fields and relation writes where the adapter cannot run both, or a record written through a relation that writes that relation (or a field holding its reference) back, where the adapter admits no such write.",
+        fix: "Write either the relation or its reference field, in the relation's cardinality.",
+    },
+    V1013: {
+        cause: "Nested projections, filters or writes deeper than maxNestingDepth.",
+        fix: "Nest less, or raise limits.maxNestingDepth.",
+    },
+    V1014: {
+        cause: "A limit above maxListLimit, or more steps than maxTransactionOperations.",
+        fix: "Paginate or split the plan, or raise the limit.",
+    },
+    V1015: {
+        cause: "A where tree with more nodes than maxBooleanNodes.",
+        fix: "Simplify the filter (in instead of many OR clauses), or raise limits.maxBooleanNodes.",
+    },
+    V1016: {
+        cause: "A $ref to the referencing step itself or a later one, or to an index no step has.",
+        fix: "Reference an earlier step only.",
+    },
+    V1017: {
+        cause: "A hand-written plan whose fingerprint does not match its step.",
+        fix: "Let the generated client, framework.appTx or framework.clientTx build the plan.",
+    },
+    V1018: {
+        cause: "The referenced step returned no value at that path, such as a first step that matched no row.",
+        fix: "Make sure the earlier step returns a row, or use a unique step, which fails with A2003.",
+    },
+    V1019: {
+        cause: "A later step uses a row that an earlier step's delete removed through a database cascade.",
+        fix: "Reorder or drop the dependent step.",
+    },
+    V1020: {
+        cause: "One framework.transaction([...]) list mixes appTx and clientTx steps.",
+        fix: "Build every step of a plan from one origin.",
+    },
+    V1021: {
+        cause: "A Json field's value nests deeper than maxJsonDepth.",
+        fix: "Flatten the value, or raise limits.maxJsonDepth.",
+    },
+};

package/dist/operations/validation-code.js

@@ -19,6 +19,8 @@ export const VALIDATION_CODES = [
     "V1017",
     "V1018",
     "V1019",
+    "V1020",
+    "V1021",
 ];
 export const VALIDATION_CODE_MESSAGES = {
     V1000: "Required value missing.",
@@ -41,6 +43,8 @@ export const VALIDATION_CODE_MESSAGES = {
     V1017: "Transaction fingerprint mismatch.",
     V1018: "Transaction reference resolved to no value.",
     V1019: "Transaction step depends on a row removed by an earlier step's cascade",
+    V1020: "Transaction mixes application and client steps.",
+    V1021: "Json value depth limit exceeded.",
 };
 export function validationIssue(code, path, message) {
     return { code, path, message };

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

@@ -1,15 +1,19 @@
-import type { WriteScope } from "../contracts/capability.js";
-import type { Contract } from "../contracts/contract.js";
-import type { Resource } from "../contracts/resource.js";
-import type { OperationIdentity } from "./operation-identity.js";
+import type { AvWriteScope } from "../contracts/capability.js";
+import type { AvContract } from "../contracts/contract.js";
+import type { AvResource } from "../contracts/resource.js";
+import type { AvOperationIdentity } 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. `"nested"`
  * wherever nothing narrower is stated.
  */
-export declare function resolveWriteScope(resource: Resource<Contract> | undefined, request: OperationIdentity): WriteScope;
+export declare function resolveWriteScope(resource: AvResource<AvContract> | undefined, request: AvOperationIdentity): AvWriteScope;
 /**
  * The position a write NESTED beneath an admitted relation directive sits in: the
  * unrestricted one, at every depth, under every top-level scope.
  */
-export declare const NESTED_WRITE_SCOPE: WriteScope;
+export declare const NESTED_WRITE_SCOPE: AvWriteScope;
+/** The position a to-many `$update`'s `data` sits in: the flat-bulk write position. */
+export declare const TO_MANY_UPDATE_WRITE_SCOPE: AvWriteScope;
+/** The position of a relation's other end inside a record written through it. */
+export declare const LOOPBACK_WRITE_SCOPE: AvWriteScope;

package/dist/operations/write-scope.resolver.js

@@ -5,3 +5,5 @@ export function resolveWriteScope(resource, request) {
     return writeScopeOf(lookupOwn(advertised, request.variant));
 }
 export const NESTED_WRITE_SCOPE = "nested";
+export const TO_MANY_UPDATE_WRITE_SCOPE = "bulkWrite";
+export const LOOPBACK_WRITE_SCOPE = "loopback";

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

@@ -1,8 +1,9 @@
-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 { AvContracts } from "../compiler/contract.compiler.js";
+import type { RemoteRequestOrigin } from "../config/config-layer.js";
+import { type AvOperationIdentity } from "../operations/operation-identity.js";
+import { type AvDiagnosticsSink } from "../runtime/diagnostics-reporter.js";
 import type { ClientProtocolIdentity } from "../runtime/operation-request.js";
-import { type OperationFailureResponse } from "../runtime/operation-response.js";
+import { type AvOperationFailureResponse } 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";
@@ -23,10 +24,10 @@ export type OperationRouteSegments = {
 /** What a route check resolves to: the operation it names, or the answer that refuses it. */
 export type OperationRouteResolution = {
     readonly ok: true;
-    readonly operation: OperationIdentity;
+    readonly operation: AvOperationIdentity;
 } | {
     readonly ok: false;
-    readonly failure: OperationFailureResponse;
+    readonly failure: AvOperationFailureResponse;
 };
 /**
  * An operation route `/_resources/<resource>/<family>/<variant>` under one client
@@ -35,7 +36,7 @@ export type OperationRouteResolution = {
  * is a standard operation the Resource advertises, read through
  * `isOperationVariantAvailable` alone.
  */
-export declare function resolveOperationRoute(contracts: FrameworkContracts, protocol: ClientProtocolIdentity, route: OperationRouteSegments): OperationRouteResolution;
+export declare function resolveOperationRoute(contracts: AvContracts, protocol: ClientProtocolIdentity, route: OperationRouteSegments, origin?: RemoteRequestOrigin): OperationRouteResolution;
 /**
  * The `/_transactions` route under one client protocol identity: version → hash → the
  * ClientContract's transaction capability. The route exists only when that capability
@@ -43,7 +44,7 @@ export declare function resolveOperationRoute(contracts: FrameworkContracts, pro
  * 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;
+export declare function transactionsRouteFailure(contracts: AvContracts, protocol: ClientProtocolIdentity, origin?: RemoteRequestOrigin): AvOperationFailureResponse | undefined;
 /**
  * What a route's checks before its body resolve to: the route a request
  * reaches, or the framework response that answers it instead.
@@ -63,9 +64,9 @@ type RouteCheck<Route> = ({
  * for both route styles: `decodeOperation` reads the body only after it passes,
  * `answerAbsent` never.
  */
-export declare function checkOperationRoute(contracts: FrameworkContracts, read: ReadRequest): RouteCheck<{
+export declare function checkOperationRoute(contracts: AvContracts, read: ReadRequest, origin?: RemoteRequestOrigin): RouteCheck<{
     readonly resource: string;
-    readonly operation: OperationIdentity;
+    readonly operation: AvOperationIdentity;
 }>;
 /**
  * `/_transactions`' checks before its body: the path (`A2000` unless exactly
@@ -73,12 +74,12 @@ export declare function checkOperationRoute(contracts: FrameworkContracts, read:
  * {@link transactionsRouteFailure} — version, hash, `"interactive"` — and the
  * method (`A2012`, `Allow: POST`).
  */
-export declare function checkTransactionsRoute(contracts: FrameworkContracts, read: ReadRequest): RouteCheck<object>;
+export declare function checkTransactionsRoute(contracts: AvContracts, read: ReadRequest, origin?: RemoteRequestOrigin): 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:
  */
-export declare function answerAbsentRequest(contracts: FrameworkContracts, received: AvProtocolRequest, sink?: FrameworkDiagnosticsSink): AvProtocolResponse | undefined;
+export declare function answerAbsentRequest(contracts: AvContracts, received: AvProtocolRequest, sink?: AvDiagnosticsSink, origin?: RemoteRequestOrigin): AvProtocolResponse | undefined;
 export {};

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

@@ -12,13 +12,13 @@ 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);
+import { AvUnmountedRouteError } from "./unmounted-route.error.js";
+export function resolveOperationRoute(contracts, protocol, route, origin = "client") {
+    const identityFailure = protocolIdentityFailure(contracts, protocol, origin);
     if (identityFailure !== undefined) {
         return { ok: false, failure: identityFailure };
     }
-    const resource = lookupResource(contracts.client, route.resource);
+    const resource = lookupResource(contracts[origin], route.resource);
     if (resource === undefined) {
         return {
             ok: false,
@@ -32,19 +32,19 @@ export function resolveOperationRoute(contracts, protocol, route) {
         return {
             ok: false,
             failure: mapValidationOutcome([
-                operationUnavailableIssue(contracts.client, route),
+                operationUnavailableIssue(contracts[origin], route),
             ]),
         };
     }
     return { ok: true, operation };
 }
-export function transactionsRouteFailure(contracts, protocol) {
-    return (protocolIdentityFailure(contracts, protocol) ??
-        (contracts.client.transactions === "interactive"
+export function transactionsRouteFailure(contracts, protocol, origin = "client") {
+    return (protocolIdentityFailure(contracts, protocol, origin) ??
+        (contracts[origin].transactions === "interactive"
             ? undefined
             : transactionsUnavailableFailure()));
 }
-export function checkOperationRoute(contracts, read) {
+export function checkOperationRoute(contracts, read, origin = "client") {
     const segments = operationRouteSegments(read.request.path);
     if (segments === undefined) {
         return refusedWith(transportFailure("A2000", read.requestId));
@@ -52,7 +52,7 @@ export function checkOperationRoute(contracts, read) {
     if (read.protocol === undefined) {
         return refusedWith(identityFailureOf(read));
     }
-    const route = resolveOperationRoute(contracts, read.protocol, segments);
+    const route = resolveOperationRoute(contracts, read.protocol, segments, origin);
     if (!route.ok) {
         return refusedWith(encodeOperationResponse(route.failure, read.requestId));
     }
@@ -65,14 +65,14 @@ export function checkOperationRoute(contracts, read) {
         }
         : refusedWith(transportFailure("A2012", read.requestId, POST_ONLY));
 }
-export function checkTransactionsRoute(contracts, read) {
+export function checkTransactionsRoute(contracts, read, origin = "client") {
     if (read.request.path !== TRANSACTIONS_ROUTE) {
         return refusedWith(transportFailure("A2000", read.requestId));
     }
     if (read.protocol === undefined) {
         return refusedWith(identityFailureOf(read));
     }
-    const absent = transactionsRouteFailure(contracts, read.protocol);
+    const absent = transactionsRouteFailure(contracts, read.protocol, origin);
     if (absent !== undefined) {
         return refusedWith(encodeOperationResponse(absent, read.requestId));
     }
@@ -86,7 +86,7 @@ function identityFailureOf(read) {
 function refusedWith(response) {
     return { ok: false, response };
 }
-export function answerAbsentRequest(contracts, received, sink) {
+export function answerAbsentRequest(contracts, received, sink, origin = "client") {
     const read = readRequest(received);
     if (!read.ok) {
         return read.response;
@@ -101,30 +101,30 @@ export function answerAbsentRequest(contracts, received, sink) {
             : transportFailure("A2012", read.requestId, GET_ONLY);
     }
     if (path === TRANSACTIONS_ROUTE) {
-        const route = checkTransactionsRoute(contracts, read);
+        const route = checkTransactionsRoute(contracts, read, origin);
         if (!route.ok) {
             return route.response;
         }
         createReporter(sink, {
             kind: "transaction",
-            origin: "client",
+            origin,
             requestId: read.requestId,
-        })(new UnmountedRouteError("transactions", `POST ${TRANSACTIONS_ROUTE}`), "A3000");
+        })(new AvUnmountedRouteError("transactions", `POST ${TRANSACTIONS_ROUTE}`), "A3000");
         return unmounted(read.requestId);
     }
-    const route = checkOperationRoute(contracts, read);
+    const route = checkOperationRoute(contracts, read, origin);
     if (!route.ok) {
         return route.response;
     }
     const { family, variant } = route.operation;
     createReporter(sink, {
         kind: "operation",
-        origin: "client",
+        origin,
         resource: route.resource,
         family,
         variant,
         requestId: read.requestId,
-    })(new UnmountedRouteError(`${route.resource}.${family}.${variant}`, `POST ${path}`), "A3000");
+    })(new AvUnmountedRouteError(`${route.resource}.${family}.${variant}`, `POST ${path}`), "A3000");
     return unmounted(read.requestId);
 }
 function unmounted(requestId) {

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

@@ -1,4 +1,4 @@
-import type { ClientContract } from "../contracts/contract.js";
+import type { AvContractClient } from "../contracts/contract.js";
 import type { AvProtocolRequest } from "./http-request.decoder.js";
 import type { AvProtocolResponse } from "./http-response.encoder.js";
 /**
@@ -11,9 +11,9 @@ export type ContractDocument = {
     readonly etag: string;
 };
 /** The bound ClientContract as the document `_contract` serves. */
-export declare function contractDocumentOf(client: ClientContract): ContractDocument;
+export declare function contractDocumentOf(client: AvContractClient): ContractDocument;
 /**
- * `protocol.encodeContract(request)`: the `GET <entrypoint>/_contract` responder. In
+ * `protocol.encodeContract(request)`: the `GET <api>/_contract` responder. In
  * order:
  */
 export declare function encodeContractRequest(document: ContractDocument, received: AvProtocolRequest): AvProtocolResponse;

package/dist/protocol/contract-document.responder.js

@@ -1,10 +1,10 @@
-import { canonicalizeContract } from "../contracts/contract-canonicalizer.js";
+import { canonicalContractTextOf } from "../contracts/contract-canonicalizer.js";
 import { CONTRACT_ROUTE, GET_ONLY, readRequest, } from "./http-request.reader.js";
 import { transportFailure } from "./protocol-failure.js";
 import { headers, headerValue } from "./protocol-headers.js";
 export function contractDocumentOf(client) {
     return Object.freeze({
-        body: canonicalizeContract(client),
+        body: canonicalContractTextOf(client),
         etag: `"${client.protocol.hash}"`,
     });
 }