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

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 {};

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

@@ -11,13 +11,6 @@ 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";
-/**
- * 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).
- */
 export function resolveOperationRoute(contracts, protocol, route) {
     const identityFailure = protocolIdentityFailure(contracts, protocol);
     if (identityFailure !== undefined) {
@@ -41,28 +34,12 @@ export function resolveOperationRoute(contracts, protocol, route) {
     }
     return { ok: true, operation };
 }
-/**
- * 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.
- */
 export function transactionsRouteFailure(contracts, protocol) {
     return (protocolIdentityFailure(contracts, protocol) ??
         (contracts.client.transactions === "interactive"
             ? undefined
             : transactionsUnavailableFailure()));
 }
-/**
- * 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.
- */
 export function checkOperationRoute(contracts, read) {
     const segments = operationRouteSegments(read.request.path);
     if (segments === undefined) {
@@ -84,12 +61,6 @@ export function checkOperationRoute(contracts, read) {
         }
         : refusedWith(transportFailure("A2012", read.requestId, POST_ONLY));
 }
-/**
- * `/_transactions`' checks before its body: the path (`A2000` unless exactly
- * `/_transactions`), the identity headers' presence (`A2000`), then
- * {@link transactionsRouteFailure} — version, hash, `"interactive"` — and the
- * method (`A2012`, `Allow: POST`).
- */
 export function checkTransactionsRoute(contracts, read) {
     if (read.request.path !== TRANSACTIONS_ROUTE) {
         return refusedWith(transportFailure("A2000", read.requestId));
@@ -105,37 +76,12 @@ export function checkTransactionsRoute(contracts, read) {
         ? { ok: true, protocol: read.protocol }
         : refusedWith(transportFailure("A2012", read.requestId, POST_ONLY));
 }
-/** The `A2000` for a request whose identity headers are not all there, naming the missing ones (pilot.1). */
 function identityFailureOf(read) {
     return identityHeadersMissing(missingIdentityHeaders(read.headers), read.requestId);
 }
 function refusedWith(response) {
     return { ok: false, response };
 }
-/**
- * `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:
- *
- * 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);
- * 3. `/_contract`: any method but `GET` → `405 A2012` with `Allow: GET`; no
- *    identity header is read (§12.4);
- * 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).
- *
- * Every framework answer echoes `Aventara-Request-Id` (Q13).
- */
 export function answerAbsentRequest(contracts, received) {
     const read = readRequest(received);
     if (!read.ok) {
@@ -155,7 +101,6 @@ export function answerAbsentRequest(contracts, received) {
         : checkOperationRoute(contracts, read);
     return route.ok ? unmounted(read.requestId) : route.response;
 }
-/** A mounted route's request at the fallback: the framework failed to route it. */
 function unmounted(requestId) {
     return encodeOperationResponse(operationFailure("A3000", { message: INTERNAL_FAILURE_MESSAGE }), requestId);
 }

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

@@ -1,12 +1,12 @@
 /**
  * The members of `AvProtocol`, as this module's own named exports. The entry
- * (`./index.ts`) publishes this module whole as the namespace `AvProtocol`
- * (P5): the language freezes a module namespace, and a bundler drops the
- * members a consumer does not read.
+ * (`./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.
+ * 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.
  */
 export { normalizeEntrypoint } from "../config/entrypoint.normalizer.js";
 export { scalarFormats } from "../contracts/wire-scalar-format.js";

package/dist/protocol/av-protocol.js

@@ -1,13 +1,3 @@
-/**
- * The members of `AvProtocol`, as this module's own named exports. The entry
- * (`./index.ts`) publishes this module whole as the namespace `AvProtocol`
- * (P5): 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.
- */
 export { normalizeEntrypoint } from "../config/entrypoint.normalizer.js";
 export { scalarFormats } from "../contracts/wire-scalar-format.js";
 export { httpStatus } from "./http-status.table.js";

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

@@ -2,10 +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 (RFC 8785, Q8) and its entity tag, the quoted contract hash (§12.5).
- * The bytes include `protocol.hash`, although the hash's own input excludes
- * it (M22).
+ * 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;
@@ -14,22 +13,20 @@ export type ContractDocument = {
 /** The bound ClientContract as the document `_contract` serves. */
 export declare function contractDocumentOf(client: ClientContract): ContractDocument;
 /**
- * `protocol.encodeContract(request)` (§5.9, Q8; S11): the `GET
- * <entrypoint>/_contract` responder. In order:
+ * `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);
- * 2. the request id: `Aventara-Request-Id` adopted per Q13, else minted;
- * 3. a path other than `/_contract` → `400 A2000` (path syntax this route
- *    cannot read, as a decoder answers one);
+ * 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` (§15.4.5);
- *    otherwise `200` with the canonical bytes, `ETag`, `Cache-Control:
- *    no-cache` and `Content-Type: application/json`.
+ * 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 (§12.4: the contract GET is the
- * discovery mechanism), and the body is never read.
+ * No identity header is required or read, and the body is never read.
  */
 export declare function encodeContractRequest(document: ContractDocument, received: AvProtocolRequest): AvProtocolResponse;

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

@@ -2,32 +2,12 @@ import { canonicalizeContract } 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";
-/** The bound ClientContract as the document `_contract` serves. */
 export function contractDocumentOf(client) {
     return Object.freeze({
         body: canonicalizeContract(client),
         etag: `"${client.protocol.hash}"`,
     });
 }
-/**
- * `protocol.encodeContract(request)` (§5.9, Q8; S11): 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);
- * 2. the request id: `Aventara-Request-Id` adopted per Q13, else minted;
- * 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` (§15.4.5);
- *    otherwise `200` with the canonical bytes, `ETag`, `Cache-Control:
- *    no-cache` and `Content-Type: application/json`.
- *
- * No identity header is required or read (§12.4: the contract GET is the
- * discovery mechanism), and the body is never read.
- */
 export function encodeContractRequest(document, received) {
     const read = readRequest(received);
     if (!read.ok) {
@@ -53,20 +33,7 @@ export function encodeContractRequest(document, received) {
             body: document.body,
         };
 }
-/**
- * One member of an `If-None-Match` list (RFC 9110 §5.6.1, §8.8.3): optional
- * whitespace, an optional entity tag — `W/` optional, then an opaque tag of
- * `etagc` between quotes — optional whitespace, then a comma or the end. An
- * empty member is allowed, as the list rule allows it.
- */
 const IF_NONE_MATCH_MEMBER = /[ \t]*(?:(?:W\/)?("[\x21\x23-\x7e\x80-\xff]*"))?[ \t]*(,|$)/y;
-/**
- * Whether `If-None-Match` names the current representation: `*`, or a list
- * holding an entity tag whose opaque tag equals `etag`'s — the WEAK
- * comparison (RFC 9110 §8.8.3.2), which `If-None-Match` uses (§13.1.2), so a
- * `W/` prefix does not matter. A value that is not a well-formed list matches
- * nothing; an absent header matches nothing.
- */
 function noneMatchHolds(value, etag) {
     if (value === undefined) {
         return false;