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

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

@@ -1,6 +1,7 @@
 import type { Contract } from "../contracts/contract.js";
 import type { OperationIdentity } from "./operation-identity.js";
 import type { ValidationIssue } from "./validation-code.js";
+/** An operation's arguments as an object, before validation. */
 export type SemanticOperationArguments = Readonly<Record<string, unknown>>;
 type OperationValidationSuccess = {
     readonly ok: true;
@@ -10,15 +11,15 @@ type OperationValidationFailure = {
     readonly ok: false;
     readonly issues: readonly ValidationIssue[];
 };
+/** The answer of {@link validateOperationArguments}: success, or the issues found. */
 export type OperationValidationResult = OperationValidationSuccess | OperationValidationFailure;
 export type OperationValidationOptions = {
     readonly transactionReferences?: boolean;
 };
 /**
- * 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 build theirs with
- * it.
+ * 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 build theirs with it.
  */
 export declare function resourceUnavailableIssue(resource: string): ValidationIssue;
 export declare function validateOperationArguments(contract: Contract, request: OperationIdentity & {

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

@@ -5,10 +5,9 @@ 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
- * `["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` 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.
  */
 export declare function operationUnavailableIssue(request: {
     readonly resource: string;
@@ -16,9 +15,8 @@ export declare function operationUnavailableIssue(request: {
     readonly variant: string;
 }): ValidationIssue;
 /**
- * Validates one standard operation's semantic arguments against the active
- * Contract. Operation availability and request-wide structural limits are
- * enforced before deeper grammar validation.
+ * Validates one standard operation's arguments against a Contract. Operation
+ * availability and request limits are checked before the arguments' grammar.
  */
 export declare function validateOperationArguments(contract: Contract, request: OperationIdentity & {
     readonly resource: string;

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

@@ -25,15 +25,5 @@ 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.
- *
- * Naming it is the point.
  */
 export declare const NESTED_PROJECTION_SCOPE: ProjectionScope;

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

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

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

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

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

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

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

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

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

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

package/dist/protocol/http-request.decoder.d.ts

@@ -2,13 +2,7 @@ import type { FrameworkContracts } from "../compiler/contract.compiler.js";
 import type { ClientOperationRequest } from "../runtime/operation-request.js";
 import type { ClientTransactionRequest } from "../transactions/transaction-request.js";
 import type { AvProtocolResponse } from "./http-response.encoder.js";
-/**
- * One HTTP request as a host hands it to the protocol: what the decoders read, and
- * what each row of the fixture corpus carries as its `request`.
- *
- * Host-independent by construction: no host's request object, only the four facts
- * every host can supply.
- */
+/** One HTTP request as a host hands it to the protocol. */
 export type AvProtocolRequest = {
     /** The HTTP method as received. Anything but `POST` on a framework route is `A2012`. */
     readonly method: string;
@@ -27,13 +21,6 @@ export type AvProtocolRequest = {
     /**
      * The body, in one of two explicitly named arms — the decoder never guesses which
      * one it was given:
-     *
-     * - `raw`: the decoded body as received, bytes or text. The decoder enforces all
-     *   of it: the size limit (`A2010`), the content type (`A2011`), JSON syntax and
-     *   the body's shape (`A2000`). An absent body is zero bytes (`""`).
-     * - `parsed`: a value the host's own JSON parser already produced. Size, content
-     *   type and JSON syntax were the host's to enforce before the decoder ran; the
-     *   decoder still refuses a non-object shape (`A2000`).
      */
     readonly body: {
         readonly kind: "raw";
@@ -44,9 +31,9 @@ export type AvProtocolRequest = {
     };
 };
 /**
- * What a decoder answers: the request core executes, or the framework response
- * that answers the HTTP request instead — and, either way, the request id it runs
- * or is answered under, which the host passes to the encoder:
+ * What a decoder answers: the request core executes, or the framework response that
+ * answers the HTTP request instead — and, either way, the request id it runs or is
+ * answered under, which the host passes to the encoder:
  * `protocol.encodeOperation(response, decoded.requestId)`.
  */
 type Decoded<Request> = {
@@ -67,51 +54,17 @@ export type DecodedOperationRequest = Extract<DecodedOperation, {
 /** What `protocol.decodeTransaction` answers. */
 export type DecodedTransaction = Decoded<ClientTransactionRequest>;
 /**
- * `protocol.decodeOperation(request)` — one operation route's HTTP request as the
- * client-origin request `framework.execute` takes, or its answer.
- *
- * Total over ANY value: a value that is not an `AvProtocolRequest` at all — not an
- * object, a missing or mistyped member, a member behind a getter or trap that
- * throws — is malformed, `A2000` under a minted id, before anything else is read;
- * nothing it carries is believed. Otherwise, in order, each step answering before
- * the next runs:
- *
- * 1. the request id: `Aventara-Request-Id` adopted when it is 1–128 visible ASCII
- *    characters, otherwise minted by core's one helper — never a refusal;
- * 2. the path: `/_resources/<resource>/<family>/<variant>`, each segment
- *    URL-decoded once and none empty, or `A2000`;
- * 3. identity and absence, with no body read: a request missing either identity
- *    header is malformed; then the protocol version (`A2006`), the ClientContract
- *    hash (`A2005`), the Resource (`A2001`) and the operation (`A2002`), each
- *    core's own envelope — so an unadvertised triple never reaches `execute`, in
- *    either route style;
- * 4. the method: anything but `POST` is `A2012`, carrying `Allow: POST` (RFC 9110
- *    §15.5.6);
- * 5. the body. On the RAW arm the decoder enforces all of it: the content type
- *    must be `application/json` (`A2011`; parameters are not read), the decoded
- *    byte count must not exceed the ClientContract's `limits.maxRequestBytes`, and
- *    the bytes must be UTF-8 JSON (`A2000`). On the PARSED arm the host's own
- *    parser already read the bytes, so size, content type and JSON syntax were the
- *    HOST's to enforce — answering its parser's failures with `protocol.failure` —
- *    and the decoder checks none of them. Both arms then refuse a body that is not
- *    a JSON object — an array, a scalar, `null`, or none (`A2000`). One gap is the
- *    host's by construction: a parser that turns an absent body into `{}` makes
- *    absence indistinguishable from `{}`, which is valid.
- *
- * The request is client origin, always: nothing the caller sends spells
- * application origin. `transport` carries `POST` and the request's headers. The
- * body is the operation's arguments verbatim: the decoder never reads into it, so
- * routing metadata in it is core's to refuse, and a parsed body reaches core as
- * the same object.
+ * `protocol.decodeOperation(request)` — one operation route's HTTP request as
+ * the client-origin request `framework.execute` takes, or its answer.
  */
 export declare function decodeOperationRequest(contracts: FrameworkContracts, received: AvProtocolRequest): DecodedOperation;
 /**
- * `protocol.decodeTransaction(request)` — the `/_transactions` request as the
- * client-origin plan request `framework.executeTransaction` takes, or its answer.
- * The same steps as {@link decodeOperationRequest}, with the path exactly
- * `/_transactions` and its absence being a ClientContract without interactive
- * transactions. Every step of the plan then runs under ClientContract rules: the
- * plan is client origin and cannot say otherwise. The body is the plan verbatim.
+ * `protocol.decodeTransaction(request)` — the `/_transactions` request as the client-
+ * origin plan request `framework.executeTransaction` takes, or its answer. The same
+ * steps as {@link decodeOperationRequest}, with the path exactly `/_transactions` and
+ * its absence being a ClientContract without interactive transactions. Every step of
+ * the plan then runs under ClientContract rules: the plan is client origin and cannot
+ * say otherwise. The body is the plan verbatim.
  */
 export declare function decodeTransactionRequest(contracts: FrameworkContracts, received: AvProtocolRequest): DecodedTransaction;
 export {};

package/dist/protocol/http-request.reader.d.ts

@@ -11,9 +11,9 @@ export declare const POST_ONLY: readonly string[];
 /** The methods the contract route accepts: `GET`, only. */
 export declare const GET_ONLY: readonly string[];
 /**
- * Whether a path lies in the protocol's namespace: underscore-prefixed paths
- * beneath the entrypoint are reserved for framework facilities; every other path
- * is the host's.
+ * Whether a path lies in the protocol's namespace: underscore-prefixed paths beneath
+ * the entrypoint are reserved for framework facilities; every other path is the
+ * host's.
  */
 export declare function isProtocolPath(path: string): boolean;
 /** A request the protocol could read, with what every route reads off it first. */
@@ -34,8 +34,8 @@ export type UnreadableRequest = {
     readonly requestId: string;
 };
 /**
- * The host's value read as a request, or — when it is not an `AvProtocolRequest`
- * at all — the `400 A2000` answering it, under a minted id.
+ * The host's value read as a request, or — when it is not an `AvProtocolRequest` at
+ * all — the `400 A2000` answering it, under a minted id.
  */
 export declare function readRequest(received: unknown): ReadRequest | UnreadableRequest;
 /**

package/dist/protocol/http-response.encoder.d.ts

@@ -10,37 +10,31 @@ export type AvProtocolResponse = {
     /** `AvProtocol.httpStatus` of the envelope's code. */
     readonly status: number;
     /**
-     * The headers the framework owns on this response, canonically spelled:
-     * `Content-Type: application/json` and the `Aventara-Request-Id` it echoes.
+     * The headers to send, canonically spelled: `Content-Type: application/json`
+     * and the echoed `Aventara-Request-Id`.
      */
     readonly headers: Readonly<Record<string, string>>;
     /** The JSON text of the envelope, its data in wire forms. */
     readonly body: string;
 };
 /**
- * Where an encoder hands the raw failure behind an `A3003` — the binding's
- * diagnostics channel — with the plan step it blames, if any. The wire never
- * carries it.
+ * Where an encoder hands the raw failure behind an `A3003` — the binding's diagnostics
+ * channel — with the plan step it blames, if any. The wire never carries it.
  */
 export type UnencodableReport = (error: unknown, operation?: number) => void;
 /**
- * `protocol.encodeOperation(response, requestId)`: one operation's framework
- * response as the HTTP response a host writes. Status is the code's; `data` is
- * wire-encoded; `requestId` is echoed as `Aventara-Request-Id` — pass the id the
- * request ran under, which the decoder supplies.
- *
- * Total: a result it cannot encode — and a response whose code is not allocated —
- * answers `A3003` → 500 with the framework's own text, and none of the result
- * reaches the body.
+ * `protocol.encodeOperation(response, requestId)`: one operation's framework response
+ * as the HTTP response a host writes. Status is the code's; `data` is wire-encoded;
+ * `requestId` is echoed as `Aventara-Request-Id` — pass the id the request ran under,
+ * which the decoder supplies.
  */
 export declare function encodeOperationResponse(response: OperationResponse, requestId: string, report?: UnencodableReport): AvProtocolResponse;
 /**
- * `protocol.encodeTransaction(response, requestId)`: the same for a plan's
- * response. A committed plan is `200 A1009` — even when it created something —
- * with each operation's data wire-encoded in plan order by the same walker as
- * {@link encodeOperationResponse}; a rolled-back plan answers its failing
- * operation's own status. A step whose result cannot be encoded answers `A3003` →
- * 500 naming that step as `cause.operation`, as every internal failure inside a
- * plan does.
+ * `protocol.encodeTransaction(response, requestId)`: the same for a plan's response. A
+ * committed plan is `200 A1009` — even when it created something — with each
+ * operation's data wire-encoded in plan order by the same walker as {@link
+ * encodeOperationResponse}; a rolled-back plan answers its failing operation's own
+ * status. A step whose result cannot be encoded answers `A3003` → 500 naming that step
+ * as `cause.operation`, as every internal failure inside a plan does.
  */
 export declare function encodeTransactionResponse(response: TransactionResponse, requestId: string, report?: UnencodableReport): AvProtocolResponse;

package/dist/protocol/http-status.table.d.ts

@@ -1,14 +1,6 @@
 import type { OperationCode } from "../runtime/operation-response.js";
 /**
  * `AvProtocol.httpStatus` — the HTTP status each A-code carries, as passive data.
- *
- * So this one table serves both encoders — an operation's response and a plan's —
- * and a rolled-back plan answers its failing operation's own status. The status is
- * the coarse signal; the A-code is the exact one.
- *
- * Total by type: the literal `satisfies` the mapped type over `OperationCode`, so
- * a code added to core does not compile until its status is written here. Passive:
- * numbers only, frozen, emitted by value where a consumer needs it.
  */
 export declare const httpStatus: {
     readonly [C in OperationCode]: number;

package/dist/protocol/index.d.ts

@@ -1,11 +1,6 @@
 /**
- * `@aventara/core/protocol` — the HTTP protocol, as passive data and pure
- * functions over core. It mounts nothing and imports no HTTP library.
- *
- * The direction is one-way: this entry may import core's internals, and no module
- * of core's execution side imports anything under `protocol/`
- * (`protocol-direction.spec.ts`). The main `@aventara/core` entry exports no name
- * from here.
+ * `@aventara/core/protocol` — the HTTP protocol, as passive data and pure functions
+ * over core. It mounts nothing and imports no HTTP library.
  */
 export * as AvProtocol from "./av-protocol.js";
 export type { AvProtocolRequest } from "./http-request.decoder.js";

package/dist/protocol/operation-response.guard.d.ts

@@ -1,20 +1,5 @@
 import { type OperationResponse } from "../runtime/operation-response.js";
 /**
  * The HTTP status plays no part — a code is read even at an unexpected status.
- *
- * `value` is the body as parsed JSON, or `undefined` when there was no body or it
- * was not JSON (neither is an envelope). An envelope here is:
- *
- * - an object (not an array) with an own `data` member and an allocated `code`;
- * - for an A1xxx code, a `cause` of exactly `null`, and `data` of `null` when the
- *   code is `A1001`;
- * - for every other code, `data` of `null` and a cause: an object whose `message`
- *   is a string, whose `issues`, if present, is a list of objects each with an
- *   allocated V-code, a string `message` and, if present, a `path` of strings and
- *   integers, and whose `operation`, if present, is a non-negative integer.
- *
- * The generated client's own check (`envelopeOf` in its emitted transport) is held
- * to agree with this one on every row of the fixture corpus's family 11, so the
- * two cannot drift apart silently.
  */
 export declare function isOperationResponse(value: unknown): value is OperationResponse;

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

@@ -1,40 +1,21 @@
 import { type AvProtocolResponse } from "./http-response.encoder.js";
 import type { IdentityHeaderName } from "./protocol-headers.js";
 /**
- * The four transport codes: failures of the HTTP request itself, which the
- * protocol answers before any operation exists, so no execution path produces
- * them. Module type — not an entry export.
+ * The four transport codes: failures of the HTTP request itself, which the protocol
+ * answers before any operation exists, so no execution path produces them. Module type
+ * — not an entry export.
  */
 export type TransportFailureCode = "A2000" | "A2010" | "A2011" | "A2012";
 /**
- * pilot.1 — the `400 A2000` answering a request that did not send an identity
- * header: its message names the missing header or headers, and echoes nothing the
- * request sent — so a developer calling the API by hand learns what to add.
+ * The `400 A2000` answering a request that did not send an identity header: its
+ * message names the missing header or headers and echoes nothing the request sent.
  */
 export declare function identityHeadersMissing(missing: readonly IdentityHeaderName[], requestId: string): AvProtocolResponse;
 /**
  * `protocol.failure(code, requestId?)` / `protocol.failure("A2012", requestId,
- * allow)`: a transport code as the complete framework response — the envelope `{
- * data: null, code, cause: { message } }`, encoded exactly as
- * `protocol.encodeOperation` encodes it, at the code's status.
- *
- * The decoders produce their transport failures through it. A host that parses the
- * body itself answers its own parser's failures with it — `A2000` for text that is
- * not JSON, `A2010` for a body over the limit, `A2011` for another content type.
- *
- * `requestId` is echoed as `Aventara-Request-Id`: pass the id the decoder gave the
- * request when there is one. When there is none — or it is empty — core mints one
- * through its one helper, so a failure is never refused or left uncorrelated.
- *
- * `allow` belongs to `A2012`, and `A2012` requires it: every 405 carries the
- * `Allow` header naming the methods its route DOES accept, joined with `", "` —
- * `[]` is RFC 9110's "no method", still a header. `failure` knows no route, so the
- * caller names the methods; the decoders pass `["POST"]`.
- *
- * A code outside the four, `A2012` without `allow`, `allow` with any other code,
- * or a method that is not an RFC 9110 token is a programming error that the type
- * already refuses; an untyped caller gets a `TypeError`, and no envelope or header
- * is invented for it.
+ * allow)`: a transport code as the complete framework response — the envelope `{ data:
+ * null, code, cause: { message } }`, encoded exactly as `protocol.encodeOperation`
+ * encodes it, at the code's status.
  */
 export declare function transportFailure(code: "A2012", requestId: string | undefined, allow: readonly string[]): AvProtocolResponse;
 export declare function transportFailure(code: Exclude<TransportFailureCode, "A2012">, requestId?: string): AvProtocolResponse;