@aventara/core 0.1.0-pilot.0 → 0.1.0-pilot.2

package/dist/operations/operation-validator-core.js

@@ -168,11 +168,6 @@ function validateScalarFilter(fieldName, field, value, path, state) {
         }
         return;
     }
-    // Equality shorthand: anything that is not a plain record is a value — a
-    // `Date`, a `Decimal` and a `Uint8Array` included — read through the scalar
-    // runtime's own discriminant, which holds it to the field's scalar after
-    // this layer (`normalizeScalarFilter`). Reading every object as operators
-    // refused the shorthand the ORM accepts (C-855, sign flipped).
     if (!isPlainRecord(value)) {
         if (!includes(supported, "equals")) {
             addIssue(state.issues, "V1006", path, `Equality filtering is not available on field "${fieldName}".`);
@@ -409,14 +404,7 @@ function validateCursor(contract, resourceName, cursor, orderBy, path, issues) {
         addIssue(issues, "V1009", path, "orderBy must include a complete Resource identifier as an explicit tie-breaker.");
     }
 }
-function validateProjection(contract, resourceName, mode, value, 
-/**
- * The projection position THIS projection's own field and relation entries sit
- * in. The caller resolves it once from the advertised variant; a nested call
- * passes {@link NESTED_PROJECTION_SCOPE}, because a scope qualifies the top level
- * only. A `$count` entry is the exception and reads {@link ReducerOwner.scope}.
- */
-scope, path, issues, reducerOwner) {
+function validateProjection(contract, resourceName, mode, value, scope, path, issues, reducerOwner) {
     if (!Array.isArray(value)) {
         addIssue(issues, "V1008", path, `${mode} must be an array.`);
         return;
@@ -431,10 +419,7 @@ scope, path, issues, reducerOwner) {
         if (entry === "$count") {
             if (mode !== "select" ||
                 reducerOwner?.edge.cardinality !== "many" ||
-                !includes(advertisedReducersAt(reducerOwner.edge.capabilities.reducers, 
-                // The OWNER's position, not this projection's: see
-                // {@link ReducerOwner}.
-                reducerOwner.scope), "$count")) {
+                !includes(advertisedReducersAt(reducerOwner.edge.capabilities.reducers, reducerOwner.scope), "$count")) {
                 addIssue(issues, "V1008", entryPath, "$count is available only as an advertised to-many relation reducer.");
             }
             return;
@@ -477,16 +462,10 @@ scope, path, issues, reducerOwner) {
             addIssue(issues, "V1008", relationPath, `Relation "${relationName}" is not available for ${mode}.`);
             return;
         }
-        validateRelationProjection(contract, field, 
-        // The position the edge itself was admitted in. The edge's nested
-        // projection is unrestricted, but a `$count` of this edge is carried at
-        // THIS level, so the scope has to travel with the edge.
-        scope, entry[relationName], relationPath, issues);
+        validateRelationProjection(contract, field, scope, entry[relationName], relationPath, issues);
     });
 }
-function validateRelationProjection(contract, edge, 
-/** The projection position `edge` itself was admitted in — see {@link ReducerOwner}. */
-scope, value, path, issues) {
+function validateRelationProjection(contract, edge, scope, value, path, issues) {
     if (!isRecord(value)) {
         addIssue(issues, "V1008", path, "Customized relation projection must be an object.");
         return;
@@ -551,10 +530,6 @@ scope, value, path, issues) {
             validateCursor(contract, edge.target, value.cursor, value.orderBy, [...path, "cursor"], issues);
         }
     }
-    // Past an admitted relation the unrestricted surface returns, measured on both
-    // pilot engines — see {@link NESTED_PROJECTION_SCOPE}. The edge's own scope is
-    // deliberately NOT passed down: a recursive narrowing would refuse what the ORM
-    // accepts.
     if ("select" in value) {
         validateProjection(contract, edge.target, "select", value.select, NESTED_PROJECTION_SCOPE, [...path, "select"], issues, { edge, scope });
     }
@@ -595,16 +570,6 @@ function validateScalarMutation(fieldName, field, value, stage, path, issues, tr
         }
     }
 }
-/**
- * One relation mutation directive's operand, past the point where the directive
- * itself was admitted.
- *
- * It takes **no write scope**, and that is the rule rather than an omission: every
- * data object it reaches is nested, and {@link NESTED_WRITE_SCOPE} is the answer at
- * every depth. A parameter here would be a parameter this function could only
- * ignore, and the next reader would thread the caller's scope through it and refuse
- * what the ORM accepts.
- */
 function validateRelationMutationEntry(contract, edge, directive, value, path, issues) {
     const target = edge.target;
     if (edge.cardinality === "one" && Array.isArray(value)) {
@@ -747,13 +712,7 @@ function validateRelationMutationEntry(contract, edge, directive, value, path, i
         }
     }
 }
-function validateRelationMutation(contract, fieldName, field, value, stage, 
-/** The write position this relation member itself sits in; see {@link WriteScope}. */
-scope, path, issues) {
-    // Scope-aware, through the shape owner's one reader. A stage that does not hold
-    // at this write position is not writable at this write position, and says so with
-    // the message an absent member already has — which is why the two answers
-    // `advertisedDirectivesAt` can give are the two this branch already handled.
+function validateRelationMutation(contract, fieldName, field, value, stage, scope, path, issues) {
     const directives = advertisedDirectivesAt(field.capabilities[stage], scope);
     if (directives === undefined) {
         addIssue(issues, "V1006", path, `Relation "${fieldName}" is not writable during ${stage}.`);
@@ -772,15 +731,7 @@ scope, path, issues) {
         validateRelationMutationEntry(contract, field, directive, directiveValue, directivePath, issues);
     }
 }
-function validateMutationData(contract, resourceName, data, stage, 
-/**
- * The write position THIS data object's own relation members sit in. The caller
- * resolves it once from the advertised variant; a nested call passes
- * {@link NESTED_WRITE_SCOPE}, because a scope qualifies the top level only.
- * Scalar members never read it — all six scalar capability members were measured
- * uniform across every variant on the axis.
- */
-scope, path, issues, transactionReferences = false) {
+function validateMutationData(contract, resourceName, data, stage, scope, path, issues, transactionReferences = false) {
     if (!isRecord(data)) {
         addIssue(issues, "V1001", path, `${stage} data must be an object.`);
         return;
@@ -806,14 +757,6 @@ scope, path, issues, transactionReferences = false) {
     }
 }
 function validateMutationArguments(contract, resourceName, request, args, issues, options) {
-    // The one resolution, from the variant the Resource advertises, and the write
-    // mirror of the projection scope resolved at the top level. It qualifies the top
-    // level of the write argument only; everything beneath an admitted relation
-    // directive is nested and asks about the unrestricted position instead.
-    //
-    // Resolved here rather than passed in because `request` is what carries the
-    // variant, and an argument walk handed a scope could be handed one resolved for a
-    // different request.
     const scope = resolveWriteScope(getResource(contract, resourceName), request);
     if (request.family === "create") {
         if (!("data" in args)) {
@@ -853,12 +796,6 @@ function isUniqueOperation(request) {
             request.family === "delete" ||
             request.family === "upsert"));
 }
-/**
- * The Framework Validation Layer's issue for a request naming a Resource the
- * active Contract does not have (`V1005` at `["resource"]`, rolling up to
- * `A2001`). The one spelling — the protocol's absence answers
- * (`@aventara/core/protocol`, Q2's O3) build theirs with it.
- */
 export function resourceUnavailableIssue(resource) {
     return {
         code: "V1005",
@@ -911,8 +848,6 @@ export function validateOperationArguments(contract, request, options) {
     if ("cursor" in request.arguments) {
         validateCursor(contract, request.resource, request.arguments.cursor, request.arguments.orderBy, ["arguments", "cursor"], issues);
     }
-    // The one resolution, from the variant the Resource advertises. Everything below
-    // the top level is nested and asks about the unrestricted position instead.
     const projectionScope = resolveProjectionScope(resource, request);
     if ("select" in request.arguments) {
         validateProjection(contract, request.resource, "select", request.arguments.select, projectionScope, ["arguments", "select"], issues);

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

@@ -4,11 +4,11 @@ import { type OperationValidationOptions, type OperationValidationResult } from
 import type { ValidationIssue } from "./validation-code.js";
 export type { OperationValidationOptions, OperationValidationResult, SemanticOperationArguments, } from "./operation-validator-core.js";
 /**
- * The Framework Validation Layer's issue for a `(resource, family, variant)`
- * the active Contract does not advertise on a Resource it has (`V1006` at
+ * 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 (`@aventara/core/protocol`, Q2's O3) build theirs with it, so
- * a caller cannot tell which layer answered.
+ * absence answers build theirs with it, so a caller cannot tell which layer
+ * answered.
  */
 export declare function operationUnavailableIssue(request: {
     readonly resource: string;

package/dist/operations/operation-validator.js

@@ -15,13 +15,6 @@ function isOperationAvailable(contract, request) {
     const family = lookupOwn(advertised, request.family);
     return isOperationVariantAvailable(lookupOwn(family, request.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 (`@aventara/core/protocol`, Q2's O3) build theirs with it, so
- * a caller cannot tell which layer answered.
- */
 export function operationUnavailableIssue(request) {
     return {
         path: ["operation"],
@@ -39,11 +32,6 @@ function hasGeneralRootWhere(request) {
             request.family === "delete" ||
             request.family === "upsert"));
 }
-/**
- * Validates one standard operation's semantic arguments against the active
- * Contract. Operation availability and request-wide structural limits are
- * enforced before deeper grammar validation.
- */
 export function validateOperationArguments(contract, request, options) {
     if (!isOperationAvailable(contract, request)) {
         return { ok: false, issues: [operationUnavailableIssue(request)] };

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

@@ -26,16 +26,14 @@ export declare function resolveProjectionScope(resource: Resource<Contract> | un
  * The position a projection NESTED beneath an admitted relation sits in: the
  * unrestricted one, at every depth, under every top-level scope.
  *
- * **Measured at runtime on both pilot engines, 2026-10-03** — not inferred from the
- * types, which permit more than they accept. A bulk-returning write accepted
- * `include: { <owned to-one>: { include: { <to-many>: true } } }` and populated the
- * rows, while the same to-many asked for at the top level was refused outright. The
- * generated types say why: a bulk projection types an admitted relation as the
- * *unrestricted* projection argument, so the full surface returns one level in.
+ * **Measured at runtime on both pilot engines, 2026-10-03** — not inferred from
+ * the types, which permit more than they accept. A bulk-returning write accepted
+ * `include: { <owned to-one>: { include: { <to-many>: true } } }` and populated
+ * the rows, while the same to-many asked for at the top level was refused
+ * outright. The generated types say why: a bulk projection types an admitted
+ * relation as the *unrestricted* projection argument, so the full surface returns
+ * one level in.
  *
- * Naming it is the point. A recursive walk that passed its own scope down would
- * refuse what the ORM accepts, which is C-855 with the sign flipped and the same
- * defect; this constant is the single place that decision is written, and S7's
- * `bulkDoesNotNarrowRecursively` pins the identical rule at the type level.
+ * Naming it is the point.
  */
 export declare const NESTED_PROJECTION_SCOPE: ProjectionScope;

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

@@ -1,42 +1,7 @@
 import { lookupOwn } from "../contracts/contract-lookup.js";
 import { projectionScopeOf, } from "../contracts/resource-operations.js";
-/**
- * Which projection position one request's **top-level** projection arguments sit
- * 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
- * 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
- * would stop counting inside a projection the validator admits, which is a limit
- * silently not enforced. So the resolution has one home.
- *
- * `"record"` is the answer wherever nothing narrower is stated — an absent
- * Resource, an unadvertised variant, `true`, or a descriptor that qualifies only
- * its write argument. Availability is **not** decided here: an unadvertised
- * operation is refused by `operation-validator.ts` before either walk runs, and
- * answering `"record"` for one keeps this function a projection question rather
- * than a second, weaker copy of the availability gate.
- */
 export function resolveProjectionScope(resource, request) {
     const advertised = lookupOwn(resource?.operations, request.family);
     return projectionScopeOf(lookupOwn(advertised, request.variant));
 }
-/**
- * The position a projection NESTED beneath an admitted relation sits in: the
- * unrestricted one, at every depth, under every top-level scope.
- *
- * **Measured at runtime on both pilot engines, 2026-10-03** — not inferred from the
- * types, which permit more than they accept. A bulk-returning write accepted
- * `include: { <owned to-one>: { include: { <to-many>: true } } }` and populated the
- * rows, while the same to-many asked for at the top level was refused outright. The
- * generated types say why: a bulk projection types an admitted relation as the
- * *unrestricted* projection argument, so the full surface returns one level in.
- *
- * Naming it is the point. A recursive walk that passed its own scope down would
- * refuse what the ORM accepts, which is C-855 with the sign flipped and the same
- * defect; this constant is the single place that decision is written, and S7's
- * `bulkDoesNotNarrowRecursively` pins the identical rule at the type level.
- */
 export const NESTED_PROJECTION_SCOPE = "record";

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

@@ -1,27 +1,20 @@
 /**
- * The closed Validation-code vocabulary, allocated by specification 13.3 as
- * `V1000`-`V1015`, amended to `V1018` by ADR 0006 DA-4 and to `V1019` by the
- * Phase 9 cascade refusal (§13.3, ADR 0008 decision 4). 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 (ADR 0005
- * applied to the V axis, ADR 0008 decision 4).
+ * 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.
  */
 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 type ValidationCode = (typeof VALIDATION_CODES)[number];
 /**
- * The framework's own text for each Validation code: the published meaning
- * from specification 13.3, and from ADR 0006 DA-4 for the three codes it
- * amended in. `V1019` is the architect's wording, verbatim (2026-10-04). 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`.
+ * 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.
+ * 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.
  */
 export declare const VALIDATION_CODE_MESSAGES: Readonly<Record<ValidationCode, string>>;
 export type ValidationIssue = {

package/dist/operations/validation-code.js

@@ -1,12 +1,3 @@
-/**
- * The closed Validation-code vocabulary, allocated by specification 13.3 as
- * `V1000`-`V1015`, amended to `V1018` by ADR 0006 DA-4 and to `V1019` by the
- * Phase 9 cascade refusal (§13.3, ADR 0008 decision 4). 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 (ADR 0005
- * applied to the V axis, ADR 0008 decision 4).
- */
 export const VALIDATION_CODES = [
     "V1000",
     "V1001",
@@ -29,20 +20,6 @@ export const VALIDATION_CODES = [
     "V1018",
     "V1019",
 ];
-/**
- * The framework's own text for each Validation code: the published meaning
- * from specification 13.3, and from ADR 0006 DA-4 for the three codes it
- * amended in. `V1019` is the architect's wording, verbatim (2026-10-04). 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.
- */
 export const VALIDATION_CODE_MESSAGES = {
     V1000: "Required value missing.",
     V1001: "Invalid runtime/wire type.",
@@ -65,7 +42,6 @@ export const VALIDATION_CODE_MESSAGES = {
     V1018: "Transaction reference resolved to no value.",
     V1019: "Transaction step depends on a row removed by an earlier step's cascade",
 };
-/** Builds one Framework Validation Layer issue at its path. */
 export function validationIssue(code, path, message) {
     return { code, path, message };
 }

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

@@ -30,14 +30,11 @@ export declare function resolveWriteScope(resource: Resource<Contract> | undefin
  * `$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.
+ * **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. A recursive walk that passed its own scope down would
- * refuse what the ORM accepts, which is C-855 with the sign flipped and the same
- * defect; this constant is the single place that decision is written, and S7's
- * non-recursion rows pin the identical rule at the type level.
+ * decision on the read axis.
  */
 export declare const NESTED_WRITE_SCOPE: WriteScope;

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

@@ -1,44 +1,7 @@
 import { lookupOwn } from "../contracts/contract-lookup.js";
 import { writeScopeOf, } from "../contracts/resource-operations.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.
- */
 export function resolveWriteScope(resource, request) {
     const advertised = lookupOwn(resource?.operations, request.family);
     return writeScopeOf(lookupOwn(advertised, request.variant));
 }
-/**
- * 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. A recursive walk that passed its own scope down would
- * refuse what the ORM accepts, which is C-855 with the sign flipped and the same
- * defect; this constant is the single place that decision is written, and S7's
- * non-recursion rows pin the identical rule at the type level.
- */
 export const NESTED_WRITE_SCOPE = "nested";

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

@@ -6,23 +6,11 @@ import type { AvProtocolRequest } from "./http-request.decoder.js";
 import { type ReadRequest } from "./http-request.reader.js";
 import { type AvProtocolResponse } from "./http-response.encoder.js";
 /**
- * The absence answers of Q2's O3 — the contract-lookup absence responder — as
- * 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`). One implementation, for both route styles Q12 permits:
- * the decoders answer a catch-all host's unadvertised path with it, and
- * `protocol.answerAbsent` (S10) is the fallback a per-operation host mounts.
+ * "Removed" and "never existed" are not distinguished; a stale client hears
+ * `A2005` first.
  *
- * Every envelope is the one core's Framework Validation Layer answers for the
- * same request — built by the same functions (`protocolIdentityFailure`,
- * `resourceUnavailableIssue`, `operationUnavailableIssue`,
- * `mapValidationOutcome`, `transactionsUnavailableFailure`) — so a caller
- * cannot tell which layer answered [M4, M5, M17]. "Removed" and "never
- * existed" are not distinguished; a stale client hears `A2005` first (Q3).
- *
- * It reads the compiled Contracts only — passive data — so nothing it depends
- * on can execute an operation.
+ * It reads the compiled Contracts only — passive data — so nothing it depends on
+ * can execute an operation.
  */
 /** A route's three decoded segments, still untrusted strings. */
 export type OperationRouteSegments = {
@@ -39,20 +27,19 @@ export type OperationRouteResolution = {
     readonly failure: OperationFailureResponse;
 };
 /**
- * An operation route `/_resources/<resource>/<family>/<variant>` under one
- * client protocol identity: version → hash → Resource → operation. A Resource
- * key is matched exactly (§12.6) 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 (§4).
+ * 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
+ * `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"` (A4) — tested against the value
- * itself, as `protocol.surface()` tests it — and is otherwise absent with
- * core's own refusal of a plan (`A2002`, `V1006` at `["operations"]`, M17).
- * `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;
 /**
@@ -69,10 +56,10 @@ type RouteCheck<Route> = ({
 /**
  * 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 (Q12):
- * `decodeOperation` reads the body only after it passes, `answerAbsent` never.
+ * 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;
@@ -86,28 +73,26 @@ export declare function checkOperationRoute(contracts: FrameworkContracts, read:
  */
 export declare function checkTransactionsRoute(contracts: FrameworkContracts, read: ReadRequest): RouteCheck<object>;
 /**
- * `protocol.answerAbsent(request)` (§5.9, Q2's O3; S10) — 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:
+ * `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 (§12.1) →
- *    `undefined`: the host answers it itself — `/favicon.ico` is not the
- *    framework's (the architect, 2026-10-05);
+ * 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 (§12.4);
+ *    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 (the architect, 2026-10-05).
+ *    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` (Q13).
+ * Every framework answer echoes `Aventara-Request-Id`.
  */
 export declare function answerAbsentRequest(contracts: FrameworkContracts, received: AvProtocolRequest): AvProtocolResponse | undefined;
 export {};