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

package/dist/operations/operation-validator.d.ts

@@ -1,19 +1,34 @@
 import type { Contract } from "../contracts/contract.js";
-import type { OperationIdentity } from "./operation-identity.js";
+import { type OperationIdentity } from "./operation-identity.js";
 import { type OperationValidationOptions, type OperationValidationResult } from "./operation-validator-core.js";
 import type { ValidationIssue } from "./validation-code.js";
 export type { OperationValidationOptions, OperationValidationResult, SemanticOperationArguments, } from "./operation-validator-core.js";
+/** The key of a request's operation identity that makes it unavailable. */
+export declare function unavailableOperationKey(contract: Contract, request: {
+    readonly resource: string;
+    readonly family: string;
+}): "family" | "variant";
 /**
  * The Framework Validation Layer's issue for a `(resource, family, variant)` the
- * active Contract does not advertise on a Resource it has (`V1006` at `["operation"]`,
- * rolling up to `A2002`). The one spelling — the protocol's absence answers build
- * theirs with it, so a caller cannot tell which layer answered.
+ * active Contract does not advertise on a Resource it has: `V1006`, rolling up to
+ * `A2002`, at the key that is wrong (`["family"]` or `["variant"]`, see
+ * {@link unavailableOperationKey}). The one spelling — the protocol's absence
+ * answers build theirs with it, so a caller cannot tell which layer answered.
  */
-export declare function operationUnavailableIssue(request: {
+export declare function operationUnavailableIssue(contract: Contract, request: {
     readonly resource: string;
     readonly family: string;
     readonly variant: string;
 }): ValidationIssue;
+/**
+ * The availability answer alone — `V1006` when the active Contract does not advertise
+ * the operation on a Resource it has — read from the request's identity, never its
+ * arguments. A door that refuses unreadable arguments asks this first, so an
+ * unadvertised operation answers `A2002` whatever its arguments hold.
+ */
+export declare function findOperationAvailabilityIssue(contract: Contract, request: OperationIdentity & {
+    readonly resource: string;
+}): ValidationIssue | undefined;
 /**
  * Validates one standard operation's arguments against a Contract. Operation
  * availability and request limits are checked before the arguments' grammar.

package/dist/operations/operation-validator.js

@@ -1,8 +1,8 @@
 import { lookupOwn, lookupResource } from "../contracts/contract-lookup.js";
 import { isOperationVariantAvailable, } from "../contracts/resource-operations.js";
-import { findOperationBooleanNodeIssue } from "./operation-boolean-nodes.js";
-import { findOperationNestingIssue } from "./operation-nesting.js";
+import { isOperationFamily, } from "./operation-identity.js";
 import { validateOperationArguments as validateSemanticOperationArguments, } from "./operation-validator-core.js";
+import { findStructuralLimitIssues } from "./structural-limits.walker.js";
 function isArgumentObject(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -15,13 +15,28 @@ function isOperationAvailable(contract, request) {
     const family = lookupOwn(advertised, request.family);
     return isOperationVariantAvailable(lookupOwn(family, request.variant));
 }
-export function operationUnavailableIssue(request) {
+export function unavailableOperationKey(contract, request) {
+    if (!isOperationFamily(request.family)) {
+        return "family";
+    }
+    const variants = lookupOwn(lookupResource(contract, request.resource)?.operations, request.family);
+    return variants !== undefined &&
+        Object.keys(variants).some((variant) => isOperationVariantAvailable(lookupOwn(variants, variant)))
+        ? "variant"
+        : "family";
+}
+export function operationUnavailableIssue(contract, request) {
     return {
-        path: ["operation"],
+        path: [unavailableOperationKey(contract, request)],
         code: "V1006",
         message: `Operation "${request.family}.${request.variant}" is not available on Resource "${request.resource}".`,
     };
 }
+export function findOperationAvailabilityIssue(contract, request) {
+    return isOperationAvailable(contract, request)
+        ? undefined
+        : operationUnavailableIssue(contract, request);
+}
 function hasGeneralRootWhere(request) {
     if (!("where" in request.arguments)) {
         return false;
@@ -33,15 +48,16 @@ function hasGeneralRootWhere(request) {
             request.family === "upsert"));
 }
 export function validateOperationArguments(contract, request, options) {
-    if (!isOperationAvailable(contract, request)) {
-        return { ok: false, issues: [operationUnavailableIssue(request)] };
+    const unavailable = findOperationAvailabilityIssue(contract, request);
+    if (unavailable !== undefined) {
+        return { ok: false, issues: [unavailable] };
     }
     if (isArgumentObject(request.arguments)) {
-        const nestingIssue = findOperationNestingIssue(contract, request.resource, request.arguments);
-        if (nestingIssue !== undefined) {
-            return { ok: false, issues: [nestingIssue] };
+        const finding = findStructuralLimitIssues(contract, request, request.arguments);
+        if (finding.nesting !== undefined) {
+            return { ok: false, issues: [finding.nesting] };
         }
-        const booleanNodeIssue = findOperationBooleanNodeIssue(contract, request, request.arguments);
+        const booleanNodeIssue = finding.booleanNodes;
         if (booleanNodeIssue !== undefined) {
             return {
                 ok: false,

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

@@ -7,7 +7,7 @@ import type { OperationIdentity } from "./operation-identity.js";
  * in, read off the variant the Resource advertises.
  *
  * Two readers need the answer and they run one after the other over the same
- * request — the `maxBooleanNodes` walk in `operation-boolean-nodes.ts`, then the
+ * request — the `maxBooleanNodes` tally in `structural-limits.walker.ts`, then the
  * grammar walk in `operation-validator-core.ts`. They must agree: a walk that
  * resolved a wider scope than the validator would count nodes inside a projection
  * the validator then refuses (harmless), and a walk that resolved a narrower one

package/dist/operations/structural-limits.walker.d.ts

@@ -0,0 +1,19 @@
+import type { Contract } from "../contracts/contract.js";
+import type { OperationIdentity } from "./operation-identity.js";
+import type { ValidationIssue } from "./validation-code.js";
+type Readable = Readonly<Record<string, unknown>>;
+/** What one walk of an operation's arguments found. */
+export type StructuralLimitsFinding = {
+    /** The nesting issue, which wins over any boolean-node issue. */
+    readonly nesting: ValidationIssue | undefined;
+    /** The boolean-node issue, when there is no nesting issue. */
+    readonly booleanNodes: ValidationIssue | undefined;
+};
+/**
+ * Enforces the structural limits on one operation's argument object: the nesting
+ * issue if there is one, otherwise the boolean-node issue if there is one.
+ */
+export declare function findStructuralLimitIssues(contract: Contract, request: OperationIdentity & {
+    readonly resource: string;
+}, args: Readable): StructuralLimitsFinding;
+export {};

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/protocol/absent-route.responder.d.ts

@@ -1,5 +1,6 @@
 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";
@@ -79,5 +80,5 @@ export declare function checkTransactionsRoute(contracts: FrameworkContracts, re
  * 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/http-request.decoder.d.ts

@@ -67,4 +67,10 @@ export declare function decodeOperationRequest(contracts: FrameworkContracts, re
  * say otherwise. The body is the plan verbatim.
  */
 export declare function decodeTransactionRequest(contracts: FrameworkContracts, received: AvProtocolRequest): DecodedTransaction;
+/**
+ * Whether `value` is a body this decoder parsed from raw content. Only the protocol's
+ * own shortcuts ask, about a request they have just decoded, before any host code
+ * could hold it; it is exported from no entry point.
+ */
+export declare function isParsedByDecoder(value: unknown): boolean;
 export {};

package/dist/protocol/http-request.decoder.js

@@ -16,7 +16,7 @@ export function decodeOperationRequest(contracts, received) {
         ? {
             ok: true,
             request: {
-                scope: "client",
+                origin: "client",
                 requestId: read.requestId,
                 resource: route.resource,
                 ...route.operation,
@@ -42,7 +42,7 @@ export function decodeTransactionRequest(contracts, received) {
         ? {
             ok: true,
             request: {
-                scope: "client",
+                origin: "client",
                 requestId: read.requestId,
                 protocol: route.protocol,
                 transport: transportOf(read),
@@ -85,7 +85,15 @@ function bodyValue(body, contentType, maxRequestBytes) {
     catch {
         return "A2000";
     }
-    return isJsonObject(value) ? { value } : "A2000";
+    if (!isJsonObject(value)) {
+        return "A2000";
+    }
+    PARSED_HERE.add(value);
+    return { value };
+}
+const PARSED_HERE = new WeakSet();
+export function isParsedByDecoder(value) {
+    return typeof value === "object" && value !== null && PARSED_HERE.has(value);
 }
 function isJsonMediaType(contentType) {
     return (contentType

package/dist/protocol/protocol.binder.d.ts

@@ -48,7 +48,7 @@ export type AvProtocolBinding = {
     /**
      * The same for `/_transactions` — what `framework.executeTransaction` answered. An
      * `A3003` is reported to the Framework's diagnostics sink as a `"transaction"`
-     * diagnostic — client scope, this `requestId`, the step it blames as `operation` —
+     * diagnostic — client origin, this `requestId`, the step it blames as `operation` —
      * with the value that had no wire form (or what its getter threw) as `error`.
      */
     readonly encodeTransaction: (response: TransactionResponse, requestId: string) => AvProtocolResponse;
@@ -89,7 +89,9 @@ export type AvProtocolBinding = {
      * `A2005`, `A2001`, `A2002` or `A2012` (with `Allow`) as the operation routes
      * would, `500 A3000` for a mounted route reached with its own method, and
      * `undefined` for a path outside the protocol's namespace, which the host
-     * answers itself.
+     * answers itself. An operation or `/_transactions` route answered `500 A3000`
+     * is also reported once to the Framework's diagnostics sink, as an
+     * `UnmountedRouteError` naming the route the host did not mount.
      */
     readonly answerAbsent: (request: AvProtocolRequest) => AvProtocolResponse | undefined;
 };

package/dist/protocol/protocol.binder.js

@@ -1,4 +1,5 @@
 import { diagnosticsSinkOf } from "../runtime/diagnostics-reporter.js";
+import { ownedExecutionOf } from "../runtime/owned-execution.registry.js";
 import { answerAbsentRequest } from "./absent-route.responder.js";
 import { contractDocumentOf, encodeContractRequest, } from "./contract-document.responder.js";
 import { decodeOperationRequest, decodeTransactionRequest, } from "./http-request.decoder.js";
@@ -15,6 +16,7 @@ export function bind(framework) {
         contracts,
         execute: (request) => framework.execute(request),
         executeTransaction: (request) => framework.executeTransaction(request),
+        owned: ownedExecutionOf(framework),
         sink,
     };
     return Object.freeze({
@@ -29,6 +31,6 @@ export function bind(framework) {
         handleOperation: (request) => handleOperationRequest(handler, request),
         handleTransaction: (request) => handleTransactionRequest(handler, request),
         encodeContract: (request) => encodeContractRequest(document, request),
-        answerAbsent: (request) => answerAbsentRequest(contracts, request),
+        answerAbsent: (request) => answerAbsentRequest(contracts, request, sink),
     });
 }