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

package/dist/protocol/index.d.ts

@@ -1,11 +1,11 @@
 /**
  * `@aventara/core/protocol` — the HTTP protocol, as passive data and pure
- * functions over core (§Q1). It mounts nothing and imports no HTTP library.
+ * 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.
+ * 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.
  */
 export * as AvProtocol from "./av-protocol.js";
 export type { AvProtocolRequest } from "./http-request.decoder.js";

package/dist/protocol/index.js

@@ -1,10 +1 @@
-/**
- * `@aventara/core/protocol` — the HTTP protocol, as passive data and pure
- * functions over core (§Q1). 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.
- */
 export * as AvProtocol from "./av-protocol.js";

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

@@ -1,27 +1,20 @@
 import { type OperationResponse } from "../runtime/operation-response.js";
 /**
- * `AvProtocol.isOperationResponse` — whether a parsed response body is a
- * framework envelope (§13.1), the boundary §13.5 draws: an envelope's A1xxx
- * resolves and its every other code is a `FrameworkError`; anything else means
- * no envelope arrived, which a client raises as `TransportError`. The HTTP
- * status plays no part — a code is read even at an unexpected status.
+ * 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:
+ * `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.
+ * - 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.
  *
- * Members §13.1 does not define are no reason to refuse; a reader drops them.
- *
- * 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
- * (R5, `packages/client`), so the two cannot drift apart silently.
+ * 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/operation-response.guard.js

@@ -1,30 +1,5 @@
 import { VALIDATION_CODES } from "../operations/validation-code.js";
 import { OPERATION_CODES, } from "../runtime/operation-response.js";
-/**
- * `AvProtocol.isOperationResponse` — whether a parsed response body is a
- * framework envelope (§13.1), the boundary §13.5 draws: an envelope's A1xxx
- * resolves and its every other code is a `FrameworkError`; anything else means
- * no envelope arrived, which a client raises as `TransportError`. 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.
- *
- * Members §13.1 does not define are no reason to refuse; a reader drops them.
- *
- * 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
- * (R5, `packages/client`), so the two cannot drift apart silently.
- */
 export function isOperationResponse(value) {
     if (!isRecord(value) || !Object.hasOwn(value, "data")) {
         return false;
@@ -72,10 +47,6 @@ function isValidationIssue(value) {
         (Array.isArray(path) &&
             everyElement(path, (segment) => typeof segment === "string" || Number.isInteger(segment))));
 }
-/**
- * Every element, holes included (a hole reads as `undefined`, which no member
- * test accepts) — unlike `Array.prototype.every`, which skips them.
- */
 function everyElement(list, test) {
     for (const element of list) {
         if (!test(element)) {

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

@@ -1,45 +1,40 @@
 import { type AvProtocolResponse } from "./http-response.encoder.js";
 import type { IdentityHeaderName } from "./protocol-headers.js";
 /**
- * The four transport codes (§13.2): failures of the HTTP request itself, which
- * the protocol answers before any operation exists, so no execution path
- * produces them (N4). 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 (§12.4; the architect, 2026-10-05): its message names the missing
- * header or headers, and echoes nothing the request sent (§13.5) — so a
- * developer calling the API by hand learns what to add.
+ * 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.
  */
 export declare function identityHeadersMissing(missing: readonly IdentityHeaderName[], requestId: string): AvProtocolResponse;
 /**
  * `protocol.failure(code, requestId?)` / `protocol.failure("A2012", requestId,
- * allow)` (§5.9; a bound member, ruled 2026-10-05): 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.
+ * 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 (Q11's parsed arm) 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.
+ * 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` (Q13): 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 (Q10), so a failure is never
- * refused or left uncorrelated.
+ * `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 (RFC 9110 §15.5.6;
- * the director, 2026-10-05), 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"]`.
+ * `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.
+ * 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.
  */
 export declare function transportFailure(code: "A2012", requestId: string | undefined, allow: readonly string[]): AvProtocolResponse;
 export declare function transportFailure(code: Exclude<TransportFailureCode, "A2012">, requestId?: string): AvProtocolResponse;

package/dist/protocol/protocol-failure.js

@@ -1,30 +1,18 @@
 import { operationFailure } from "../runtime/operation-response.js";
 import { requestIdOf } from "../runtime/request-id.js";
 import { encodeOperationResponse, } from "./http-response.encoder.js";
-/**
- * The framework's own text for each transport code. It names the defect and
- * never echoes the request (§13.5): no body, no content type, no method, no
- * configured limit.
- */
 const TRANSPORT_FAILURE_MESSAGES = Object.freeze({
     A2000: "The request is malformed and cannot be interpreted.",
     A2010: "The request body exceeds the maximum request size.",
     A2011: "The request content type is not supported; send application/json.",
     A2012: "The HTTP method is not allowed on this framework route.",
 });
-/**
- * pilot.1 — the `400 A2000` answering a request that did not send an identity
- * header (§12.4; the architect, 2026-10-05): its message names the missing
- * header or headers, and echoes nothing the request sent (§13.5) — so a
- * developer calling the API by hand learns what to add.
- */
 export function identityHeadersMissing(missing, requestId) {
     const named = missing.length === 1
         ? `The ${missing[0]} header is`
         : `The ${missing.join(" and ")} headers are`;
     return encodeOperationResponse(operationFailure("A2000", { message: `${named} missing.` }), requestIdOf({ requestId }));
 }
-/** An HTTP method as RFC 9110 §9.1 spells one: a `token` (§5.6.2). */
 const METHOD_TOKEN = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;
 export function transportFailure(code, requestId, allow) {
     if (!Object.hasOwn(TRANSPORT_FAILURE_MESSAGES, code)) {

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

@@ -3,19 +3,18 @@ import type { ClientProtocolIdentity } from "../runtime/operation-request.js";
  * `AvProtocol.headers` — the header names the protocol owns, as passive data.
  *
  * - `protocolVersion`, `contractHash`: the two identity headers every
- *   generated-client resource and transaction request sends (§12.4); the
- *   `_contract` request needs neither.
- * - `requestId`: the correlation header (Q13). A valid one is adopted as the
- *   request's id, an invalid one ignored, and every framework-produced
- *   response echoes it.
+ *   generated-client resource and transaction request sends; the `_contract`
+ *   request needs neither.
+ * - `requestId`: the correlation header. A valid one is adopted as the request's
+ *   id, an invalid one ignored, and every framework-produced response echoes it.
  *
- * Spelled as the canonical wire text. HTTP header names are case-insensitive
- * (§12.4), so a reader matches them without regard to case; these spellings are
- * what the framework and the generated client SEND.
+ * Spelled as the canonical wire text. HTTP header names are case-insensitive, so a
+ * reader matches them without regard to case; these spellings are what the
+ * framework and the generated client SEND.
  *
- * Passive data (P5): strings only, frozen, so a consumer — the client generator
- * emits it by value into generated source — can neither mutate it nor receive
- * anything `JSON.stringify` would drop or reshape.
+ * Passive data: strings only, frozen, so a consumer — the client generator emits
+ * it by value into generated source — can neither mutate it nor receive anything
+ * `JSON.stringify` would drop or reshape.
  */
 export declare const headers: Readonly<{
     readonly protocolVersion: "Aventara-Protocol-Version";
@@ -25,10 +24,9 @@ export declare const headers: Readonly<{
 /** A request's headers as a host hands them over (`AvProtocolRequest.headers`). */
 type ReceivedHeaders = Readonly<Record<string, string | readonly string[] | undefined>>;
 /**
- * The request's headers as one spelling (Q7, accepted 2026-10-04): names
- * lower-cased (they are case-insensitive, §12.4), a repeated header's values —
- * a list, or one name received in several casings — joined with `", "` in the
- * order received (RFC 9110 §5.3), and an `undefined` entry or an empty list
+ * The request's headers as one spelling: names lower-cased, a repeated header's
+ * values — a list, or one name received in several casings — joined with `", "` in
+ * the order received (RFC 9110 §5.3), and an `undefined` entry or an empty list
  * dropped as absent. Values are otherwise as received. This is what a client
  * request's `transport.headers` carries to the developer's pipelines, and what
  * every header read below reads.
@@ -43,32 +41,29 @@ export declare function normalizeHeaders(received: ReceivedHeaders): Readonly<Re
  */
 export declare function headerValue(normalized: Readonly<Record<string, string>>, name: string): string | undefined;
 /**
- * The identity headers (§12.4) as the `ClientProtocolIdentity` core checks, or
- * `undefined` when either is ABSENT — a request without them is malformed
- * (`A2000`; the architect, 2026-10-05): it does not say which protocol and
- * ClientContract it speaks, so there is nothing to compare.
+ * The identity headers as the `ClientProtocolIdentity` core checks, or `undefined`
+ * when either is ABSENT — a request without them is malformed: it does not say
+ * which protocol and ClientContract it speaks, so there is nothing to compare.
  *
  * Present values are read, never judged: whether they match is the Framework
  * Validation Layer's call (cross-phase invariant 13), made by core's one
- * stale-client check. A present version that is not a decimal integer (no
- * sign, no leading zero) reads as `NaN`, so it cannot match (`A2006`); a
- * present hash is passed as received (`A2005` unless it is the current one).
- * Present includes empty: a header sent with no value was still sent.
+ * stale-client check. A present version that is not a decimal integer (no sign, no
+ * leading zero) reads as `NaN`, so it cannot match (`A2006`); a present hash is
+ * passed as received (`A2005` unless it is the current one). Present includes
+ * empty: a header sent with no value was still sent.
  */
 export declare function protocolIdentityOf(normalized: Readonly<Record<string, string>>): ClientProtocolIdentity | undefined;
 /**
- * The identity headers (§12.4) a request did not send, in the order the
- * framework sends them — what the `A2000` answering it names (pilot.1).
- * Empty exactly when {@link protocolIdentityOf} reads an identity.
+ * The identity headers a request did not send, in the order the framework sends
+ * them — what the `A2000` answering it names (pilot.1). Empty exactly when {@link
+ * protocolIdentityOf} reads an identity.
  */
 export declare function missingIdentityHeaders(normalized: Readonly<Record<string, string>>): readonly IdentityHeaderName[];
 /** The two identity headers' names, as the framework spells them. */
 export type IdentityHeaderName = (typeof headers)["protocolVersion"] | (typeof headers)["contractHash"];
 /**
- * Q13 (the architect's, 2026-10-04): the request's `Aventara-Request-Id` when
- * it is 1–128 characters of visible ASCII; otherwise `undefined` — the header
- * is ignored, never refused, and core mints an id instead. A repeated header
- * joins with `", "`, which holds a space, so it is never adopted.
+ * A repeated header joins with `", "`, which holds a space, so it is never
+ * adopted.
  */
 export declare function adoptedRequestId(normalized: Readonly<Record<string, string>>): string | undefined;
 export {};

package/dist/protocol/protocol-headers.js

@@ -1,44 +1,9 @@
-/**
- * The wire prefix of every framework-owned header (§12.4: "the working wire
- * prefix for v1", to be frozen before the first externally published release).
- * One place, so that freeze is a one-line change, and every name below is
- * spelled from it rather than restating it.
- */
 const WIRE_PREFIX = "Aventara";
-/**
- * `AvProtocol.headers` — the header names the protocol owns, as passive data.
- *
- * - `protocolVersion`, `contractHash`: the two identity headers every
- *   generated-client resource and transaction request sends (§12.4); the
- *   `_contract` request needs neither.
- * - `requestId`: the correlation header (Q13). A valid one is adopted as the
- *   request's id, an invalid one ignored, and every framework-produced
- *   response echoes it.
- *
- * Spelled as the canonical wire text. HTTP header names are case-insensitive
- * (§12.4), so a reader matches them without regard to case; these spellings are
- * what the framework and the generated client SEND.
- *
- * Passive data (P5): strings only, frozen, so a consumer — the client generator
- * emits it by value into generated source — can neither mutate it nor receive
- * anything `JSON.stringify` would drop or reshape.
- */
 export const headers = Object.freeze({
     protocolVersion: `${WIRE_PREFIX}-Protocol-Version`,
     contractHash: `${WIRE_PREFIX}-Contract-Hash`,
     requestId: `${WIRE_PREFIX}-Request-Id`,
 });
-/**
- * The request's headers as one spelling (Q7, accepted 2026-10-04): names
- * lower-cased (they are case-insensitive, §12.4), a repeated header's values —
- * a list, or one name received in several casings — joined with `", "` in the
- * order received (RFC 9110 §5.3), and an `undefined` entry or an empty list
- * dropped as absent. Values are otherwise as received. This is what a client
- * request's `transport.headers` carries to the developer's pipelines, and what
- * every header read below reads.
- *
- * Built with `Object.fromEntries`, so a header named `__proto__` stays data.
- */
 export function normalizeHeaders(received) {
     const merged = new Map();
     for (const [name, value] of Object.entries(received)) {
@@ -51,32 +16,13 @@ export function normalizeHeaders(received) {
     }
     return Object.fromEntries(Array.from(merged, ([name, values]) => [name, values.join(", ")]));
 }
-/**
- * One header's value as the framework reads it, from {@link normalizeHeaders}'
- * output: surrounding spaces and tabs are not part of a field value (RFC 9110
- * §5.5), so they are removed. `undefined` when the header is absent.
- */
 export function headerValue(normalized, name) {
     const key = name.toLowerCase();
     return Object.hasOwn(normalized, key)
         ? normalized[key]?.replace(/^[ \t]+|[ \t]+$/g, "")
         : undefined;
 }
-/** A protocol version as the header spells it: a decimal integer, no sign, no leading zero. */
 const PROTOCOL_VERSION_TEXT = /^(?:0|[1-9]\d*)$/;
-/**
- * The identity headers (§12.4) as the `ClientProtocolIdentity` core checks, or
- * `undefined` when either is ABSENT — a request without them is malformed
- * (`A2000`; the architect, 2026-10-05): it does not say which protocol and
- * ClientContract it speaks, so there is nothing to compare.
- *
- * Present values are read, never judged: whether they match is the Framework
- * Validation Layer's call (cross-phase invariant 13), made by core's one
- * stale-client check. A present version that is not a decimal integer (no
- * sign, no leading zero) reads as `NaN`, so it cannot match (`A2006`); a
- * present hash is passed as received (`A2005` unless it is the current one).
- * Present includes empty: a header sent with no value was still sent.
- */
 export function protocolIdentityOf(normalized) {
     const version = headerValue(normalized, headers.protocolVersion);
     const hash = headerValue(normalized, headers.contractHash);
@@ -88,22 +34,10 @@ export function protocolIdentityOf(normalized) {
         hash,
     };
 }
-/**
- * The identity headers (§12.4) a request did not send, in the order the
- * framework sends them — what the `A2000` answering it names (pilot.1).
- * Empty exactly when {@link protocolIdentityOf} reads an identity.
- */
 export function missingIdentityHeaders(normalized) {
     return [headers.protocolVersion, headers.contractHash].filter((name) => headerValue(normalized, name) === undefined);
 }
-/** Q13's adoptable correlation id: 1–128 characters of visible ASCII (`0x21`–`0x7E`). */
 const ADOPTABLE_REQUEST_ID = /^[\x21-\x7e]{1,128}$/;
-/**
- * Q13 (the architect's, 2026-10-04): the request's `Aventara-Request-Id` when
- * it is 1–128 characters of visible ASCII; otherwise `undefined` — the header
- * is ignored, never refused, and core mints an id instead. A repeated header
- * joins with `", "`, which holds a space, so it is never adopted.
- */
 export function adoptedRequestId(normalized) {
     const value = headerValue(normalized, headers.requestId);
     return value !== undefined && ADOPTABLE_REQUEST_ID.test(value)

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

@@ -2,20 +2,17 @@ import type { ClientContract } from "../contracts/contract.js";
 import { type OperationIdentity } from "../operations/operation-identity.js";
 /**
  * One route of the protocol surface: a route a host mounts for the bound
- * ClientContract, tagged by `kind` (the architect's ruling, 2026-10-05). Every
- * `path` is RELATIVE to the configured entrypoint, in the same space as
- * `AvProtocolRequest.path`; the canonical `framework.entrypoint` (`""` or
- * `/seg(/seg)*`, R4) joins it without a doubled slash.
+ * ClientContract, tagged by `kind`.
  *
- * - `operation`: a `(resource, family, variant)` the ClientContract
- *   advertises. `method` is always `POST` — every Resource operation is, reads
- *   included (§12.2). `path` is `/_resources/<resource>/<family>/<variant>`
- *   (§12.1), each segment percent-encoded exactly as the generated client
- *   sends it, so it decodes back to the exact registry key (§12.6). Family and
- *   variant are one standard operation identity.
- * - `contract`: `GET /_contract` (§12.1, §12.2, §12.5) — always present.
- * - `transactions`: `POST /_transactions` (§12.1, §12.2) — present exactly
- *   when the ClientContract's `transactions` is `"interactive"` (§14 item 2).
+ * - `operation`: a `(resource, family, variant)` the ClientContract advertises.
+ *   `method` is always `POST` — every Resource operation is, reads included.
+ *   `path` is `/_resources/<resource>/<family>/<variant>`, each segment
+ *   percent-encoded exactly as the generated client sends it, so it decodes back
+ *   to the exact registry key. Family and variant are one standard operation
+ *   identity.
+ * - `contract`: `GET /_contract` — always present.
+ * - `transactions`: `POST /_transactions` — present exactly when the
+ *   ClientContract's `transactions` is `"interactive"`.
  */
 export type SurfaceRoute = ({
     readonly kind: "operation";
@@ -32,22 +29,21 @@ export type SurfaceRoute = ({
     readonly path: "/_transactions";
 };
 /**
- * The route list of one ClientContract (ADR 0007 DA-13): every route a host
- * mounts, from one list, deep-frozen — exactly the advertised operation
- * triples in the Contract's own key order, then `GET /_contract`, then
- * `POST /_transactions` when, and only when, `transactions === "interactive"`.
+ * The route list of one ClientContract: every route a host mounts, from one list,
+ * deep-frozen — exactly the advertised operation triples in the Contract's own key
+ * order, then `GET /_contract`, then `POST /_transactions` when, and only when,
+ * `transactions === "interactive"`.
  *
- * Derived from the ClientContract alone — never configuration, the adapter
- * model, or another layer's Contract — so a client-hidden resource has no
- * route (M7), and a resource whose every operation was restricted away keeps
- * its `operations: {}` and contributes nothing (M6). Availability is read
- * ONLY through `isOperationVariantAvailable` (§4), so a scope-qualified leaf
- * is a route exactly as `true` is, and the next widening of
- * `OperationAvailability` reaches this reader with every other. A family or
- * variant key outside the standard operation set is not a route: segments go
- * through `parseOperationIdentity`, the same decoder that reads a request's.
- * The transaction route is tested against `"interactive"` itself, never as
- * "not `none`", so a capability value this reader does not know mounts
- * nothing.
+ * Derived from the ClientContract alone — never configuration, the adapter model,
+ * or another layer's Contract — so a client-hidden resource has no route, and a
+ * resource whose every operation was restricted away keeps its `operations: {}`
+ * and contributes nothing. Availability is read ONLY through
+ * `isOperationVariantAvailable`, so a scope-qualified leaf is a route exactly as
+ * `true` is, and the next widening of `OperationAvailability` reaches this reader
+ * with every other. A family or variant key outside the standard operation set is
+ * not a route: segments go through `parseOperationIdentity`, the same decoder that
+ * reads a request's. The transaction route is tested against `"interactive"`
+ * itself, never as "not `none`", so a capability value this reader does not know
+ * mounts nothing.
  */
 export declare function surfaceOf(client: ClientContract): readonly SurfaceRoute[];

package/dist/protocol/protocol-surface.js

@@ -2,25 +2,6 @@ import { lookupOwn, lookupResource } from "../contracts/contract-lookup.js";
 import { isOperationVariantAvailable } from "../contracts/resource-operations.js";
 import { parseOperationIdentity, } from "../operations/operation-identity.js";
 const ownKeys = (record) => record === undefined ? [] : Object.keys(record);
-/**
- * The route list of one ClientContract (ADR 0007 DA-13): every route a host
- * mounts, from one list, deep-frozen — exactly the advertised operation
- * triples in the Contract's own key order, then `GET /_contract`, then
- * `POST /_transactions` when, and only when, `transactions === "interactive"`.
- *
- * Derived from the ClientContract alone — never configuration, the adapter
- * model, or another layer's Contract — so a client-hidden resource has no
- * route (M7), and a resource whose every operation was restricted away keeps
- * its `operations: {}` and contributes nothing (M6). Availability is read
- * ONLY through `isOperationVariantAvailable` (§4), so a scope-qualified leaf
- * is a route exactly as `true` is, and the next widening of
- * `OperationAvailability` reaches this reader with every other. A family or
- * variant key outside the standard operation set is not a route: segments go
- * through `parseOperationIdentity`, the same decoder that reads a request's.
- * The transaction route is tested against `"interactive"` itself, never as
- * "not `none`", so a capability value this reader does not know mounts
- * nothing.
- */
 export function surfaceOf(client) {
     const routes = [];
     for (const resourceName of ownKeys(client.resources)) {