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

package/dist/contracts/contract-protocol.js

@@ -1,11 +1 @@
-/**
- * Aventara's external communication protocol version.
- *
- * This is intentionally independent from framework/package versions and from
- * application-specific Contract changes. Resource/field/configuration/database
- * changes are identified by the ClientContract hash and do not require a
- * protocol-version bump by themselves. Increment this value only when a
- * breaking change makes previous-protocol clients unable to correctly parse or
- * interpret Aventara's external protocol semantics.
- */
 export const AVENTARA_PROTOCOL_VERSION = 1;

package/dist/contracts/field.d.ts

@@ -11,12 +11,11 @@ export type ScalarFormat = string;
  * already acts on the difference, so the empty list has to be unrepresentable
  * rather than merely discouraged. An absent capability member is "not available at
  * all"; an empty list would say the same thing in a second encoding, which is one
- * semantic fact with two hashes (C-843).
+ * semantic fact with two hashes.
  *
  * **A scope list qualifies the TOP LEVEL of a projection only. It does not narrow
  * recursively** — see {@link ProjectionScope}, where the runtime measurement and
- * the reason are recorded. A reader who assumes recursion will write a rule that
- * refuses what the ORM accepts, which is C-855 with the sign flipped.
+ * the reason are recorded.
  */
 export type ProjectionScopes = readonly [ProjectionScope, ...ProjectionScope[]];
 /**
@@ -44,9 +43,7 @@ export type WriteScopes = readonly [WriteScope, ...WriteScope[]];
  *
  * The unqualified arm is retained deliberately: an adapter that has not measured
  * the axis must be able to say so, and a Contract that predates the measurement
- * must keep its meaning. It also means the canonicalizer, not the type, owns the
- * degenerate overlap — a list naming every scope says what `true` says, and C-843
- * makes collapsing it the canonicalizer's job.
+ * must keep its meaning.
  */
 export type RelationProjectionCapability = boolean | ProjectionScopes;
 /**
@@ -142,7 +139,6 @@ export declare function advertisedReducers(capability: RelationReducerCapability
  * `select`/`include` comparisons this function replaces read a measured
  * `["record"]` as **unavailable everywhere** — a to-many projection refused on
  * `update.first`, which is the single-record scope the adapter advertises it in.
- * Under-advertisement is C-855 with the sign flipped and it is the same defect.
  *
  * The parameter admits `boolean` as well as {@link ProjectionScopes} because the
  * unqualified arm means *holds in every scope*: an adapter that has not measured
@@ -150,10 +146,10 @@ export declare function advertisedReducers(capability: RelationReducerCapability
  * what they answered before. So `true` holds at every scope and `false`/absent at
  * none, and the qualified arm is consulted only where one exists.
  *
- * **A scope qualifies the TOP LEVEL of a projection only** — see
- * {@link ProjectionScope}, where the runtime measurement is recorded. A caller
- * that recurses must ask about the nested position with the unrestricted scope,
- * not with its own.
+ * **A scope qualifies the TOP LEVEL of a projection only** — see {@link
+ * ProjectionScope}, where the runtime measurement is recorded. A caller that
+ * recurses must ask about the nested position with the unrestricted scope, not
+ * with its own.
  */
 export declare function holdsAt(capability: RelationProjectionCapability | undefined, scope: ProjectionScope): boolean;
 /**
@@ -176,12 +172,13 @@ export declare function holdsInAnyScope(capability: RelationProjectionCapability
  * One call rather than two, because the two-call form is the defect. A reader that
  * asks {@link advertisedReducers} for the tokens and then has to remember a second
  * {@link holdsAt} call will forget it, and a forgotten scope check is a silent
- * over-advertisement (C-855). Here the scope cannot be forgotten: there is no way
- * to get the tokens without naming the position they are wanted in.
+ * over-advertisement. Here the scope cannot be forgotten: there is no way to get
+ * the tokens without naming the position they are wanted in.
  *
  * `undefined` is the same answer an absent member gives, which is correct — a
- * reducer that does not hold at this scope is not advertised at this scope — and it
- * keeps `[]` meaning what it means everywhere else: advertised, with no reducer.
+ * reducer that does not hold at this scope is not advertised at this scope — and
+ * it keeps `[]` meaning what it means everywhere else: advertised, with no
+ * reducer.
  */
 export declare function advertisedReducersAt(capability: RelationReducerCapability | undefined, scope: ProjectionScope): readonly RelationReducer[] | undefined;
 /**
@@ -197,10 +194,10 @@ export declare function advertisedReducersAt(capability: RelationReducerCapabili
  * direction — it counts inside a write that is about to be refused, and it can
  * never stop counting inside one that is admitted. An adapter's own write
  * translator is the other: it is handed the write site's verdict by whoever
- * dispatched it (C-818) and holds no advertised variant to resolve a scope from.
+ * dispatched it and holds no advertised variant to resolve a scope from.
  *
- * Every reader on the write axis that HAS a position wants
- * {@link advertisedDirectivesAt} instead.
+ * Every reader on the write axis that HAS a position wants {@link
+ * advertisedDirectivesAt} instead.
  *
  * See {@link advertisedReducers} for why the scopes are not returned beside them.
  */
@@ -208,29 +205,29 @@ export declare function advertisedDirectives(capability: RelationMutationCapabil
 /**
  * The mutation directives a relation advertises **at one write scope**: the
  * directives where the member holds there, and `undefined` where it does not —
- * **the one home of the scope-aware write read**, and the write mirror of
- * {@link advertisedReducersAt}.
+ * **the one home of the scope-aware write read**, and the write mirror of {@link
+ * advertisedReducersAt}.
  *
  * One call rather than two, for the reason {@link advertisedReducersAt} gives: a
  * reader that fetches the directives and then has to remember a separate scope
  * check will forget it, and a forgotten scope check is a silent
- * over-advertisement (C-855). Here the position cannot be forgotten, because
- * there is no way to reach the directives without naming it.
+ * over-advertisement. Here the position cannot be forgotten, because there is no
+ * way to reach the directives without naming it.
  *
  * `undefined` for a stage that does not hold at this scope is the same answer an
  * absent member gives, which is what the caller must say: a relation that is not
  * writable in this write position is *"not writable during <stage>"* there. That
  * keeps `[]` meaning what it means everywhere else — advertised, with no directive
  * — so the two live answers `V1006` already distinguishes stay two, and the scope
- * does not invent a third (C-843).
+ * does not invent a third.
  *
  * The unqualified arm is an array and means *holds in every write position*: an
  * adapter that has not measured the axis, and every Contract that predates the
  * measurement, keep the write surface they had.
  *
- * **A scope qualifies the TOP LEVEL of a write argument only** — see
- * {@link WriteScope}. A caller that recurses into a nested write must ask about
- * the nested position with the unrestricted scope, not with its own.
+ * **A scope qualifies the TOP LEVEL of a write argument only** — see {@link
+ * WriteScope}. A caller that recurses into a nested write must ask about the
+ * nested position with the unrestricted scope, not with its own.
  */
 export declare function advertisedDirectivesAt(capability: RelationMutationCapability | undefined, scope: WriteScope): readonly RelationMutationDirective[] | undefined;
 /** Atomic field from the API/query perspective, including enum-backed fields. */

package/dist/contracts/field.js

@@ -1,43 +1,9 @@
-/**
- * The reducers a relation advertises, whichever arm the member is written in,
- * **ignoring the scope qualifier**.
- *
- * Scope-blind on purpose, and only for a reader on an axis the scope does not
- * qualify. `orderBy: { <to-many>: { $count: … } }` is the one such reader: ordering
- * was measured uniform across every variant that carries an `orderBy` argument, so
- * there is no projection position to ask about and asking would invent one.
- *
- * Every reader on the projection axis wants {@link advertisedReducersAt} instead.
- */
 export function advertisedReducers(capability) {
     if (capability === undefined) {
         return undefined;
     }
     return "scopes" in capability ? capability.reducers : capability;
 }
-/**
- * Whether a projection capability holds at one projection scope — **the one home
- * of the scope-aware capability read.**
- *
- * Every reader that has a scope asks this, and no reader compares a capability
- * member to `true` any more. That is not tidiness: a qualified member is an
- * object/array, so `member === true` is `false` for *every* scope, and the six
- * `select`/`include` comparisons this function replaces read a measured
- * `["record"]` as **unavailable everywhere** — a to-many projection refused on
- * `update.first`, which is the single-record scope the adapter advertises it in.
- * Under-advertisement is C-855 with the sign flipped and it is the same defect.
- *
- * The parameter admits `boolean` as well as {@link ProjectionScopes} because the
- * unqualified arm means *holds in every scope*: an adapter that has not measured
- * the axis, and every Contract that predates the measurement, must keep answering
- * what they answered before. So `true` holds at every scope and `false`/absent at
- * none, and the qualified arm is consulted only where one exists.
- *
- * **A scope qualifies the TOP LEVEL of a projection only** — see
- * {@link ProjectionScope}, where the runtime measurement is recorded. A caller
- * that recurses must ask about the nested position with the unrestricted scope,
- * not with its own.
- */
 export function holdsAt(capability, scope) {
     if (capability === undefined || capability === false) {
         return false;
@@ -47,38 +13,12 @@ export function holdsAt(capability, scope) {
     }
     return capability.includes(scope);
 }
-/**
- * Whether a projection capability holds in **any** scope — the scope-blind
- * question, for the one reader that legitimately has no scope to ask about.
- *
- * It exists so that reader does not hand-roll `=== true` either. The Contract
- * compiler's VIRTUAL lifecycle check asks whether a field is selectable *at all*
- * before requiring an effective read behavior; a field selectable in one scope
- * needs that behavior exactly as much as one selectable in every scope.
- *
- * A reader with a scope must use {@link holdsAt}. This one answers a strictly
- * weaker question and will over-advertise if used in its place.
- */
 export function holdsInAnyScope(capability) {
     if (capability === undefined || capability === false) {
         return false;
     }
     return capability === true || capability.length > 0;
 }
-/**
- * The reducers a relation advertises **at one projection scope**: the tokens where
- * the member holds there, and `undefined` where it does not.
- *
- * One call rather than two, because the two-call form is the defect. A reader that
- * asks {@link advertisedReducers} for the tokens and then has to remember a second
- * {@link holdsAt} call will forget it, and a forgotten scope check is a silent
- * over-advertisement (C-855). Here the scope cannot be forgotten: there is no way
- * to get the tokens without naming the position they are wanted in.
- *
- * `undefined` is the same answer an absent member gives, which is correct — a
- * reducer that does not hold at this scope is not advertised at this scope — and it
- * keeps `[]` meaning what it means everywhere else: advertised, with no reducer.
- */
 export function advertisedReducersAt(capability, scope) {
     if (capability === undefined) {
         return undefined;
@@ -88,59 +28,12 @@ export function advertisedReducersAt(capability, scope) {
     }
     return capability.scopes.includes(scope) ? capability.reducers : undefined;
 }
-/**
- * The mutation directives a relation advertises at one write stage, whichever arm
- * the member is written in, **ignoring the scope qualifier**. `undefined` and `[]`
- * stay distinct: the stage is unavailable, or available with no directive.
- *
- * Scope-blind on purpose, and only for a reader that has no write position to ask
- * about or whose answer may only be WIDER than the validator's. Two readers
- * qualify. `operation-boolean-nodes.ts`'s `maxBooleanNodes` walk descends a
- * relation mutation to count the filter nodes inside it; reading scope-blind makes
- * that walk a superset of what the grammar walk admits, which is the harmless
- * direction — it counts inside a write that is about to be refused, and it can
- * never stop counting inside one that is admitted. An adapter's own write
- * translator is the other: it is handed the write site's verdict by whoever
- * dispatched it (C-818) and holds no advertised variant to resolve a scope from.
- *
- * Every reader on the write axis that HAS a position wants
- * {@link advertisedDirectivesAt} instead.
- *
- * See {@link advertisedReducers} for why the scopes are not returned beside them.
- */
 export function advertisedDirectives(capability) {
     if (capability === undefined) {
         return undefined;
     }
     return "scopes" in capability ? capability.directives : capability;
 }
-/**
- * The mutation directives a relation advertises **at one write scope**: the
- * directives where the member holds there, and `undefined` where it does not —
- * **the one home of the scope-aware write read**, and the write mirror of
- * {@link advertisedReducersAt}.
- *
- * One call rather than two, for the reason {@link advertisedReducersAt} gives: a
- * reader that fetches the directives and then has to remember a separate scope
- * check will forget it, and a forgotten scope check is a silent
- * over-advertisement (C-855). Here the position cannot be forgotten, because
- * there is no way to reach the directives without naming it.
- *
- * `undefined` for a stage that does not hold at this scope is the same answer an
- * absent member gives, which is what the caller must say: a relation that is not
- * writable in this write position is *"not writable during <stage>"* there. That
- * keeps `[]` meaning what it means everywhere else — advertised, with no directive
- * — so the two live answers `V1006` already distinguishes stay two, and the scope
- * does not invent a third (C-843).
- *
- * The unqualified arm is an array and means *holds in every write position*: an
- * adapter that has not measured the axis, and every Contract that predates the
- * measurement, keep the write surface they had.
- *
- * **A scope qualifies the TOP LEVEL of a write argument only** — see
- * {@link WriteScope}. A caller that recurses into a nested write must ask about
- * the nested position with the unrestricted scope, not with its own.
- */
 export function advertisedDirectivesAt(capability, scope) {
     if (capability === undefined) {
         return undefined;

package/dist/contracts/lifecycle-trait.js

@@ -1,8 +1,3 @@
-/**
- * Lifecycle traits describe value ownership/derivation without implying
- * writability. Generated values are ORM/database-owned; computed values are
- * framework/developer-owned; virtual describes persistence only.
- */
 export const LIFECYCLE_TRAITS = [
     "DEFAULTED",
     "GENERATED_ON_CREATE",

package/dist/contracts/resource-operations.d.ts

@@ -6,12 +6,11 @@ import type { ProjectionScope, WriteScope } from "./capability.js";
  *
  * The variant-to-scope map is an ADAPTER fact, not a protocol constant — a
  * variant's projection position depends on which ORM call the adapter routes it to
- * — so the advertised variant carries the answer rather than core tabulating it
- * (D-802).
+ * — so the advertised variant carries the answer rather than core tabulating it.
  *
- * At least one scope must be stated. A descriptor stating neither says exactly what
- * `true` says, and one semantic fact with two encodings is one fact with two
- * hashes (C-843).
+ * At least one scope must be stated. A descriptor stating neither says exactly
+ * what `true` says, and one semantic fact with two encodings is one fact with two
+ * hashes.
  *
  * Named for the variant it qualifies, and deliberately not `OperationScopes`:
  * `OperationScope` is a public (now deprecated) alias of `RequestOrigin`, meaning
@@ -88,11 +87,11 @@ export declare function isOperationVariantAvailable(availability: unknown): avai
  * the widening in {@link OperationAvailability} non-breaking for a producer that
  * has not measured it.
  *
- * The map from variant to scope is **not** here and must never be: `update.first`'s
- * projection position is the single-record one only because an adapter chose to
- * route that variant to a single-record provider call, and an adapter that routes it
- * to a bulk one moves the answer. Core reads what the advertised variant carries
- * (D-802, §4 Q2) rather than tabulating one scope per variant name.
+ * The map from variant to scope is **not** here and must never be:
+ * `update.first`'s projection position is the single-record one only because an
+ * adapter chose to route that variant to a single-record provider call, and an
+ * adapter that routes it to a bulk one moves the answer. Core reads what the
+ * advertised variant carries rather than tabulating one scope per variant name.
  *
  * `unknown` for the same reason {@link isOperationVariantAvailable} takes it: the
  * caller holds the leaf keyed by an untrusted request string.
@@ -108,16 +107,16 @@ export declare function projectionScopeOf(availability: unknown): ProjectionScop
  * *nothing is narrowed here*, so a Contract written before the axis existed keeps
  * the write surface it had.
  *
- * The two axes are read by two functions, not one that returns a pair, because they
- * are measured and consulted separately — `WRITE_SCOPES` is a separate array from
- * `PROJECTION_SCOPES` for that reason — and a caller that needs only one position
- * should not be handed the other to discard.
+ * The two axes are read by two functions, not one that returns a pair, because
+ * they are measured and consulted separately — `WRITE_SCOPES` is a separate array
+ * from `PROJECTION_SCOPES` for that reason — and a caller that needs only one
+ * position should not be handed the other to discard.
  *
  * The mirror exists so that *"what does this descriptor mean?"* has one answer per
- * axis rather than one answer and one convention. The canonicalizer's collapse of a
- * redundant descriptor is keyed on these two functions' answer for `true`: a
+ * axis rather than one answer and one convention. The canonicalizer's collapse of
+ * a redundant descriptor is keyed on these two functions' answer for `true`: a
  * descriptor says nothing beyond `true` exactly when every reader answers for it
- * what it answers for `true` (C-843), and that test is only as honest as the readers
- * being the single statement of each axis's unqualified scope.
+ * what it answers for `true`, and that test is only as honest as the readers being
+ * the single statement of each axis's unqualified scope.
  */
 export declare function writeScopeOf(availability: unknown): WriteScope;

package/dist/contracts/resource-operations.js

@@ -1,81 +1,18 @@
-/**
- * Whether one `ResourceOperations` leaf advertises an available variant.
- *
- * Availability is **presence**: the leaf is `true`, or it is the descriptor that
- * qualifies the variant's arguments. A descriptor states how the variant's
- * arguments are scoped — it never retracts the variant — so `leaf === true` is
- * the wrong question wherever availability is read, and the leaf's widening to
- * `true | OperationVariantScopes` made every hand-rolled copy of that question
- * silently wrong. The question has one home so the next widening of
- * `OperationAvailability` reaches every reader at once.
- *
- * The parameter is `unknown` because the readers are the request validator and
- * the Contract compiler, which hold the leaf as a Contract value keyed by an
- * untrusted or mid-compilation string. Descriptor *shape* is not judged here: a
- * present leaf is an available variant, and validating what the descriptor says
- * belongs to whoever owns the descriptor's own invariants.
- */
 export function isOperationVariantAvailable(availability) {
     return (availability === true ||
         (typeof availability === "object" &&
             availability !== null &&
             !Array.isArray(availability)));
 }
-/**
- * The projection position one advertised variant's projection arguments sit in.
- *
- * `"record"` — the unrestricted position — is the answer for `true`, for an absent
- * leaf and for a descriptor that qualifies only its write argument, because the
- * unqualified arm means *nothing is narrowed here*. A Contract written before the
- * axis existed therefore keeps validating exactly as it did, which is what makes
- * the widening in {@link OperationAvailability} non-breaking for a producer that
- * has not measured it.
- *
- * The map from variant to scope is **not** here and must never be: `update.first`'s
- * projection position is the single-record one only because an adapter chose to
- * route that variant to a single-record provider call, and an adapter that routes it
- * to a bulk one moves the answer. Core reads what the advertised variant carries
- * (D-802, §4 Q2) rather than tabulating one scope per variant name.
- *
- * `unknown` for the same reason {@link isOperationVariantAvailable} takes it: the
- * caller holds the leaf keyed by an untrusted request string.
- */
 export function projectionScopeOf(availability) {
     if (!isOperationVariantAvailable(availability) || availability === true) {
         return "record";
     }
-    // The scope the descriptor STATES, never a scope matched against a list of
-    // known ones: the axis is closed in `capability.ts` and a second enumeration
-    // here would be a copy to keep in sync, and would answer `"record"` — the
-    // permissive arm — for the member it had not heard of yet.
     return availability.projection ?? "record";
 }
-/**
- * The write position one advertised variant's data argument sits in, and the write
- * mirror of {@link projectionScopeOf}.
- *
- * `"nested"` — the unrestricted position — is the answer for `true`, for an absent
- * leaf and for a descriptor that qualifies only its projection argument, for the
- * same reason `"record"` is on the projection axis: the unqualified arm means
- * *nothing is narrowed here*, so a Contract written before the axis existed keeps
- * the write surface it had.
- *
- * The two axes are read by two functions, not one that returns a pair, because they
- * are measured and consulted separately — `WRITE_SCOPES` is a separate array from
- * `PROJECTION_SCOPES` for that reason — and a caller that needs only one position
- * should not be handed the other to discard.
- *
- * The mirror exists so that *"what does this descriptor mean?"* has one answer per
- * axis rather than one answer and one convention. The canonicalizer's collapse of a
- * redundant descriptor is keyed on these two functions' answer for `true`: a
- * descriptor says nothing beyond `true` exactly when every reader answers for it
- * what it answers for `true` (C-843), and that test is only as honest as the readers
- * being the single statement of each axis's unqualified scope.
- */
 export function writeScopeOf(availability) {
     if (!isOperationVariantAvailable(availability) || availability === true) {
         return "nested";
     }
-    // The scope the descriptor STATES, for the reason given in `projectionScopeOf`.
     return availability.write ?? "nested";
 }

package/dist/contracts/scalar-value-type.d.ts

@@ -4,24 +4,16 @@ import type { Contract } from "./contract.js";
 import type { ScalarField } from "./field.js";
 import type { BuiltInScalar } from "./scalar.js";
 /**
- * A scalar-form map: the TypeScript type each built-in scalar takes on one side
- * of a boundary. Every built-in must be answered, so a map that forgets one fails
- * to compile where it is passed rather than typing that scalar as `unknown`.
+ * A scalar-form map: the TypeScript type each built-in scalar takes on one side of
+ * a boundary. Every built-in must be answered, so a map that forgets one fails to
+ * compile where it is passed rather than typing that scalar as `unknown`.
  *
  * It is a parameter rather than a fixed table because one derivation serves more
- * than one side (Q3 = 3a): the application forms below for an in-process caller,
- * and the wire forms for a transport or a generated client. Two derivations of one
- * rule is the drift F-701 exists to forbid.
+ * than one side: the application forms below for an in-process caller, and the
+ * wire forms for a transport or a generated client.
  *
- * **Naming.** The architect named the two maps below `ApplicationScalarForms` and
- * `WireScalarForms` (2026-10-04), and `@aventara/core` exports both. This
- * constraint is not exported: a map is checked for completeness where it is
- * passed, so a consumer never has to name it. A consumer substitutes one form by
- * replacing that key — a generated client, whose codec revives every scalar into
- * its §6.2 *generated runtime value* and which carries its own emitted `Decimal`,
- * passes `Omit<ApplicationScalarForms, "decimal"> & { readonly decimal:
- * EmittedDecimal }` (Phase 12-rest Q3, architect 2026-10-05): it reads and writes
- * `bigint`, `Date` and `Uint8Array`, never their wire strings.
+ * This constraint is not exported: a map is checked for completeness where it is
+ * passed, so a consumer never has to name it.
  */
 export type ScalarForms = {
     readonly [Scalar in BuiltInScalar]: unknown;
@@ -48,19 +40,17 @@ export type ApplicationScalarForms = {
     readonly datetime: Date;
     readonly bytes: Uint8Array;
     /**
-     * U7, answered 2026-10-04: a {@link JsonValue} — without its top-level
-     * `null`. `normalizeScalarFieldValue` refuses a field-level `null` on a
-     * required field and on a list entry, and reads it as the field's absence
-     * where `nullable: true`, so the `| null` comes from the Contract's
-     * `nullable` like every other scalar's. A `null` INSIDE the value is JSON's.
+     * `normalizeScalarFieldValue` refuses a field-level `null` on a required field and
+     * on a list entry, and reads it as the field's absence where `nullable: true`, so
+     * the `| null` comes from the Contract's `nullable` like every other scalar's. A
+     * `null` INSIDE the value is JSON's.
      */
     readonly json: Exclude<JsonValue, null>;
 };
 /**
  * The encoded forms the client-scope input branch of `normalizeScalarAtom`
  * accepts: base-10 bigint strings, decimal strings, canonical ISO-8601 UTC
- * datetimes and RFC 4648 base64 bytes. It is the second map Q3 = 3a names, for
- * a transport or a generated client to pass as `Forms`.
+ * datetimes and RFC 4648 base64 bytes.
  */
 export type WireScalarForms = {
     readonly string: string;

package/dist/contracts/scalar.js

@@ -1,4 +1,3 @@
-/** Scalar identities owned by the Aventara v1 protocol. */
 export const BUILT_IN_SCALARS = [
     "string",
     "boolean",

package/dist/contracts/wire-scalar-format.d.ts

@@ -1,30 +1,30 @@
 import type { BuiltInScalar } from "./scalar.js";
 import type { ApplicationScalarForms, WireScalarForms } from "./scalar-value-type.js";
 /**
- * The built-in scalars whose wire form is not their runtime form — the ones a
- * JSON wire carries as a string with a grammar of its own (§6.2). Derived from
- * the two form maps rather than listed, so a built-in scalar added with a
- * string wire form fails to compile below until its grammar is written.
+ * The built-in scalars whose wire form is not their runtime form — the ones a JSON
+ * wire carries as a string with a grammar of its own. Derived from the two form
+ * maps rather than listed, so a built-in scalar added with a string wire form
+ * fails to compile below until its grammar is written.
  */
 type WireEncodedScalar = {
     readonly [S in BuiltInScalar]: WireScalarForms[S] extends ApplicationScalarForms[S] ? never : S;
 }[BuiltInScalar];
 /**
- * `AvProtocol.scalarFormats` — the wire grammars of protocol version 1 (§6.2;
- * C2, R7), as passive data: one anchored pattern SOURCE string per wire-encoded
- * scalar, in `BUILT_IN_SCALARS` order.
+ * `AvProtocol.scalarFormats` — the wire grammars of protocol version 1, as passive
+ * data: one anchored pattern SOURCE string per wire-encoded scalar, in
+ * `BUILT_IN_SCALARS` order.
  *
- * The one source (§Q1): execution decodes client-scope arguments with these
+ * The one source: execution decodes client-scope arguments with these
  * (`runtime/scalar-runtime.ts`, `runtime/decimal.ts`), `@aventara/core/protocol`
- * re-exports this object, and the client generator emits each source by value
- * into the generated runtime as a regular-expression literal. Strings, not
- * `RegExp`s, so it survives JSON and can be emitted (P5); frozen, so no
- * consumer can rewrite a grammar in place.
+ * re-exports this object, and the client generator emits each source by value into
+ * the generated runtime as a regular-expression literal. Strings, not `RegExp`s,
+ * so it survives JSON and can be emitted; frozen, so no consumer can rewrite a
+ * grammar in place.
  *
- * A grammar is the SHAPE only. Two scalars carry one more rule each, applied
- * where they decode: a `datetime` must also round-trip `toISOString()` exactly,
- * and a `bytes` string's padded group must leave its unused bits zero
- * ({@link decodeBase64}).
+ * A grammar is the SHAPE only. Two scalars carry one more rule each, applied where
+ * they decode: a `datetime` must also round-trip `toISOString()` exactly, and a
+ * `bytes` string's padded group must leave its unused bits zero ({@link
+ * decodeBase64}).
  */
 export declare const scalarFormats: Readonly<{
     readonly bigint: "^-?(?:0|[1-9]\\d*)$";
@@ -40,10 +40,10 @@ export declare const WIRE_SCALAR_PATTERNS: {
 export declare function encodeBase64(bytes: Uint8Array): string;
 /**
  * The bytes of a CANONICAL RFC 4648 base64 string; `undefined` for any other
- * string (C1, R6). Canonical means the grammar plus one rule the grammar cannot
- * state: the bits a padded final group does not carry must be zero, or two wire
- * strings would name one byte sequence (`"AB=="` and `"AA=="` both `[0]`). The
- * generated client's decoder applies the same rule.
+ * string. Canonical means the grammar plus one rule the grammar cannot state: the
+ * bits a padded final group does not carry must be zero, or two wire strings would
+ * name one byte sequence (`"AB=="` and `"AA=="` both `[0]`). The generated
+ * client's decoder applies the same rule.
  */
 export declare function decodeBase64(wire: string): Uint8Array | undefined;
 export {};

package/dist/contracts/wire-scalar-format.js

@@ -1,27 +1,9 @@
-/**
- * `AvProtocol.scalarFormats` — the wire grammars of protocol version 1 (§6.2;
- * C2, R7), as passive data: one anchored pattern SOURCE string per wire-encoded
- * scalar, in `BUILT_IN_SCALARS` order.
- *
- * The one source (§Q1): execution decodes client-scope arguments with these
- * (`runtime/scalar-runtime.ts`, `runtime/decimal.ts`), `@aventara/core/protocol`
- * re-exports this object, and the client generator emits each source by value
- * into the generated runtime as a regular-expression literal. Strings, not
- * `RegExp`s, so it survives JSON and can be emitted (P5); frozen, so no
- * consumer can rewrite a grammar in place.
- *
- * A grammar is the SHAPE only. Two scalars carry one more rule each, applied
- * where they decode: a `datetime` must also round-trip `toISOString()` exactly,
- * and a `bytes` string's padded group must leave its unused bits zero
- * ({@link decodeBase64}).
- */
 export const scalarFormats = Object.freeze({
     bigint: "^-?(?:0|[1-9]\\d*)$",
     decimal: "^-?(?:0|[1-9]\\d*)(?:\\.\\d+)?(?:[eE][+-]?\\d+)?$",
     datetime: "^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}\\.\\d{3}Z$",
     bytes: "^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$",
 });
-/** {@link scalarFormats}, compiled once for execution's own decoding. */
 export const WIRE_SCALAR_PATTERNS = Object.freeze({
     bigint: new RegExp(scalarFormats.bigint),
     decimal: new RegExp(scalarFormats.decimal),
@@ -29,7 +11,6 @@ export const WIRE_SCALAR_PATTERNS = Object.freeze({
     bytes: new RegExp(scalarFormats.bytes),
 });
 const BASE64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-/** RFC 4648 base64, standard alphabet, padded: the canonical spelling of `bytes`. */
 export function encodeBase64(bytes) {
     let text = "";
     for (let index = 0; index < bytes.length; index += 3) {
@@ -44,13 +25,6 @@ export function encodeBase64(bytes) {
     }
     return text;
 }
-/**
- * The bytes of a CANONICAL RFC 4648 base64 string; `undefined` for any other
- * string (C1, R6). Canonical means the grammar plus one rule the grammar cannot
- * state: the bits a padded final group does not carry must be zero, or two wire
- * strings would name one byte sequence (`"AB=="` and `"AA=="` both `[0]`). The
- * generated client's decoder applies the same rule.
- */
 export function decodeBase64(wire) {
     if (!WIRE_SCALAR_PATTERNS.bytes.test(wire)) {
         return undefined;

package/dist/framework/contract-view.d.ts

@@ -200,17 +200,17 @@ type DerivedContractView<M extends AdapterModel, FieldsBlock, Restrictions> = {
 };
 /**
  * The Application Contract's type, derived from the adapter model and the
- * configuration literal by rules 1–4 above (Q1 = 1a).
+ * configuration literal by rules 1–4 above.
  *
  * It is fed to the same `OperationArgumentsFor` and `OperationResultFor` a
  * generated client feeds its ClientContract literal to: one derivation, two
  * sources of a Contract type. `limits` is the type every Contract carries; its
  * values are resolved at construction and no derivation reads them.
  *
- * The conditional is always true. It is there so that the view this resolves to
- * is `DerivedContractView` keyed on its blocks: a conditional's resolved branch
- * is the branch's own type, while a plain alias over `Cfg` would key the
- * instantiated view on the whole configuration (see `DerivedContractView`).
+ * The conditional is always true. It is there so that the view this resolves to is
+ * `DerivedContractView` keyed on its blocks: a conditional's resolved branch is
+ * the branch's own type, while a plain alias over `Cfg` would key the instantiated
+ * view on the whole configuration (see `DerivedContractView`).
  */
 export type ApplicationContractView<M extends AdapterModel, Cfg = AnyFrameworkConfig> = [Cfg] extends [unknown] ? DerivedContractView<M, LayerBlock<Cfg, "application", "fields">, never> : never;
 /**
@@ -219,9 +219,8 @@ export type ApplicationContractView<M extends AdapterModel, Cfg = AnyFrameworkCo
  * for the in-process client-origin surfaces (`framework.client`,
  * `framework.clientTx`).
  *
- * Not exported from the package (architect, 2026-10-04: the new public names are
- * the members, not this view); a generated client reads the deployed ClientContract
- * literal itself. Resolved through a conditional for the reason
+ * Not exported from the package; a generated client reads the deployed
+ * ClientContract literal itself. Resolved through a conditional for the reason
  * {@link ApplicationContractView} gives.
  */
 export type ClientContractView<M extends AdapterModel, Cfg = AnyFrameworkConfig> = [Cfg] extends [unknown] ? DerivedContractView<M, LayerBlock<Cfg, "client", "fields">, LayerBlock<Cfg, "client", "restrictions">> : never;

package/dist/framework/framework-construction.error.js

@@ -3,7 +3,6 @@ const FRAMEWORK_CONSTRUCTION_MESSAGES = {
     discovery: "Aventara adapter discovery validation failed",
     "contract-compilation": "Aventara contract compilation failed",
 };
-/** Startup failure with deterministic diagnostics from the earliest failed construction stage. */
 export class FrameworkConstructionError extends Error {
     stage;
     diagnostics;