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

package/dist/emit/runtime.emitter.js

@@ -1,41 +1,15 @@
 import { OPERATION_CODES, VALIDATION_CODES, } from "@aventara/core";
 import { AvProtocol } from "@aventara/core/protocol";
 import { entrypointHref } from "../config/config.resolver.js";
+import { moduleSpecifierWriter, } from "./module-style.interface.js";
 import { wireGrammarLiteral } from "./scalar.codec.js";
-/**
- * The runtime modules the generated client carries: `metadata.ts`, the
- * framework `Decimal`, the outcome codes and error classes, and the transport
- * here; the scalar codec in `scalar.codec.ts`.
- */
-/**
- * `runtime/decimal.ts` — the framework-owned `Decimal` of §6.2, the generated
- * runtime value of the `decimal` scalar. Bundled with the client and imported
- * from nothing: its public type is its own, never an ORM's (§6.2, C-801).
- *
- * It holds the decimal string it was made from, digit for digit, and does no
- * arithmetic — the surface is core's `Decimal` (a string constructor and
- * `toString`) plus `toJSON`, so a value means the same on both sides of the wire.
- * A proven decimal library may later sit behind it (§6.2); none is needed to
- * carry digits.
- *
- * `toJSON` is the architect's (2026-10-04, S6 answers): it returns the decimal
- * string, so a Decimal in a consumer's own JSON — a log line, a cache entry — is
- * its digits rather than `{}`. No `equals`, no arithmetic. The request body never
- * relies on it: `serializeWireBody` refuses an unencoded Decimal regardless, so a
- * value the codec did not encode cannot slip onto the wire through `toJSON`.
- *
- * The grammar is core's `Decimal` grammar, read from `AvProtocol.scalarFormats`
- * and emitted by value (C2, R7; `protocol-parity.spec.ts`). Unlike
- * core's, the constructor refuses a non-string outright: a pattern test coerces
- * its argument, so `5` would otherwise pass as `"5"` and be kept as a number.
- */
 export function emitDecimalModule() {
     return {
         path: "runtime/decimal.ts",
         source: `const DECIMAL_STRING = ${wireGrammarLiteral("decimal")};
 
 /**
- * An exact decimal: the runtime value of the "decimal" scalar (§6.2).
+ * An exact decimal: the runtime value of the "decimal" scalar.
  *
  * It holds the decimal string it was made from, digit for digit, and is sent as
  * that string. It does no arithmetic.
@@ -64,55 +38,28 @@ export class Decimal {
 `,
     };
 }
-/**
- * `metadata.ts` — what this client was generated against: the ClientContract
- * hash and the protocol version (Phase 12-partial Q4 = A), and the resolved
- * entrypoint as the client's default (§15.2; Phase 12-rest Q5 = A). Nothing else:
- * no driver, no timestamp, no generator version, no host path — anything a re-run
- * over the same inputs could change breaks byte-equality (§19.3's spirit). The
- * entrypoint is an input like the contract: changing it regenerates different
- * bytes and leaves the hash alone (§15.2), and it never carries credentials
- * (refused at resolution, Q5).
- *
- * The hash and the version are what every operation request sends (§12.4), from
- * `runtime/transport.ts`; all three are internal — `AvClient.ts` exports none.
- */
 export function emitMetadataModule(protocol, entrypoint) {
     return {
         path: "metadata.ts",
-        source: "/** The hash of the ClientContract this client was generated against (§19.2). */\n" +
+        source: "/** The hash of the ClientContract this client was generated against. */\n" +
             `export const CLIENT_CONTRACT_HASH = ${JSON.stringify(protocol.hash)};\n` +
             "\n" +
-            "/** The Aventara protocol version that ClientContract speaks (§19.1). */\n" +
+            "/** The Aventara protocol version that ClientContract speaks. */\n" +
             `export const PROTOCOL_VERSION = ${JSON.stringify(protocol.version)};\n` +
             "\n" +
-            "/** The entrypoint the client was generated from: its default deployment (§15.2). */\n" +
+            "/** The entrypoint the client was generated from: its default deployment. */\n" +
             `export const DEFAULT_ENTRYPOINT = ${JSON.stringify(entrypointHref(entrypoint))};\n`,
     };
 }
-/**
- * # The FrameworkError subclass set (Q2 = B)
- *
- * One subclass per code CLASS, plus the two the specification names by
- * behaviour: `NotFoundError` (§13.4, A2003) and the contract-mismatch error
- * (invariant 15, A2005). Each class's doc line is emitted above it.
- *
- * The keys are the emitted class names, in UTF-16 code-unit order.
- */
 const FRAMEWORK_ERROR_CLASSES = {
     AuthError: "The caller is not authenticated, or is not permitted to run the operation.",
-    ConflictError: "The operation conflicted with stored state, and nothing was written. A2008 fails the same way if sent again; A2013 and A2014 may succeed if sent again, and no retry is automatic (§13.5).",
+    ConflictError: "The operation conflicted with stored state, and nothing was written. A2008 fails the same way if sent again; A2013 and A2014 may succeed if sent again, and no retry is automatic.",
     ContractMismatchError: "This client was generated against a ClientContract other than the one the server serves (invariant 15). Regenerate it with `avclient generate`.",
-    InternalError: "The server failed. Nothing in its cause is actionable; the diagnostics are in the server's logs (§13.5).",
-    NotFoundError: "A strict unique target does not exist (§13.4).",
+    InternalError: "The server failed. Nothing in its cause is actionable; the diagnostics are in the server's logs.",
+    NotFoundError: "A strict unique target does not exist.",
     ProtocolError: "The request was not one the server could route or interpret: an unknown Resource or operation, a protocol version it does not speak, or a body, media type, size or method it refuses.",
     ValidationError: "The request broke a Contract rule: a field, type, capability, projection, reference or limit. The cause's issues say which, by code and path.",
 };
-/**
- * The class every error code throws. A mapped type over core's
- * `OperationErrorCode`, so a code core adds is a compile error here until it is
- * classified — the classification is total by construction, never by care.
- */
 const FRAMEWORK_ERROR_CLASS_OF = {
     A2000: "ProtocolError",
     A2001: "ProtocolError",
@@ -133,23 +80,13 @@ const FRAMEWORK_ERROR_CLASS_OF = {
     A3001: "InternalError",
     A3002: "InternalError",
     A3003: "InternalError",
+    A3004: "InternalError",
     A4000: "AuthError",
     A4001: "AuthError",
     A4002: "AuthError",
 };
-/**
- * The `FrameworkError` subclasses the generated runtime declares, in UTF-16
- * code-unit order — names the root namespace reserves (`name.deriver.ts`).
- */
 export const FRAMEWORK_ERROR_CLASS_NAMES = Object.keys(FRAMEWORK_ERROR_CLASSES);
-/** The error codes, in core's allocation order. */
 const ERROR_CODES = OPERATION_CODES.filter((code) => !code.startsWith("A1"));
-/**
- * The names `AvClient.ts` re-exports from `generated/runtime/errors.ts`: the classes and the
- * two code unions §15.4 requires, and `Cause` and `ValidationIssue` — the types a
- * thrown FrameworkError carries, public by the architect's decision of
- * 2026-10-04 — in UTF-16 code-unit order.
- */
 export function errorsModuleExports() {
     return [
         ...FRAMEWORK_ERROR_CLASS_NAMES,
@@ -165,20 +102,19 @@ export function errorsModuleExports() {
         return a < b ? -1 : a > b ? 1 : 0;
     });
 }
-/** One code array as emitted source: a `const` tuple, one code per line. */
 function codeArray(codes) {
     return `[\n${codes.map((code) => `\t${JSON.stringify(code)},\n`).join("")}] as const`;
 }
 const ERRORS_MODULE_HEAD = `/**
- * The outcome codes and error classes of Aventara protocol version 1 (§13).
+ * The outcome codes and error classes of Aventara protocol version 1.
  *
  * A1xxx resolves; every other code throws the FrameworkError subclass of its
- * class (§13.5); a response that is not a framework envelope throws
+ * class; a response that is not a framework envelope throws
  * TransportError. Branch on the class or on \`code\`, never on the message.
  */
 `;
 const ERRORS_MODULE_TYPES = `
-/** One actionable validation issue (§13.1); \`path\` locates it in the request. */
+/** One actionable validation issue; \`path\` locates it in the request. */
 export interface ValidationIssue {
 	readonly path?: readonly (string | number)[];
 	readonly code: ValidationCode;
@@ -186,9 +122,9 @@ export interface ValidationIssue {
 }
 
 /**
- * Why an operation failed (§13.1). Rebuilt member by member from the envelope:
+ * Why an operation failed. Rebuilt member by member from the envelope:
  * a member the protocol does not define is never carried, so no stack, SQL or
- * server path the server should not have sent reaches it (§13.5).
+ * server path the server should not have sent reaches it.
  */
 export interface Cause {
 	readonly message: string;
@@ -198,7 +134,7 @@ export interface Cause {
 }
 
 /**
- * A framework outcome that throws (§13.5): every code outside A1xxx. It is
+ * A framework outcome that throws: every code outside A1xxx. It is
  * always thrown as the subclass of its code's class; catch FrameworkError to
  * catch them all.
  */
@@ -218,7 +154,7 @@ export class FrameworkError<C extends OperationErrorCode = OperationErrorCode> e
 `;
 const ERRORS_MODULE_TAIL = `
 /**
- * A failure that never produced a framework envelope (§13.5): no response
+ * A failure that never produced a framework envelope: no response
  * arrived, or the one that did is not an Aventara response envelope — a proxy's
  * HTML error page, a truncated body, JSON of another shape. It carries no
  * cause: nothing in such a response is the framework's to report.
@@ -234,16 +170,6 @@ export class TransportError extends Error {
 	}
 }
 `;
-/**
- * `runtime/errors.ts` — §13's vocabulary as the generated client carries it.
- *
- * Both code unions are emitted from core's exported arrays (Q3), so the emitted
- * tree states each code exactly once and core stays their one source; the
- * subclass set and the code each one throws are Q2's (above), accepted as-is by
- * the architect on 2026-10-04. Exported beyond what `AvClient.ts` re-exports: the
- * two arrays, `OperationErrorCode` and `frameworkErrorOf`, which
- * `runtime/transport.ts` reads.
- */
 export function emitErrorsModule() {
     const classes = Object.entries(FRAMEWORK_ERROR_CLASSES).map(([name, summary]) => {
         const codes = ERROR_CODES.filter((code) => FRAMEWORK_ERROR_CLASS_OF[code] === name);
@@ -255,15 +181,15 @@ export function emitErrorsModule() {
     return {
         path: "runtime/errors.ts",
         source: ERRORS_MODULE_HEAD +
-            "\n/** The outcome codes of the protocol, in allocation order (§13.2). */\n" +
+            "\n/** The outcome codes of the protocol, in allocation order. */\n" +
             `export const OPERATION_CODES = ${codeArray(OPERATION_CODES)};\n` +
-            "\n/** An outcome code (§13.2). */\n" +
+            "\n/** An outcome code. */\n" +
             "export type OperationCode = (typeof OPERATION_CODES)[number];\n" +
-            "\n/** An outcome code that throws: every code outside A1xxx (§13.5). */\n" +
+            "\n/** An outcome code that throws: every code outside A1xxx. */\n" +
             `export type OperationErrorCode = Exclude<OperationCode, \`A1\${string}\`>;\n` +
-            "\n/** The validation codes of the protocol, in allocation order (§13.3). */\n" +
+            "\n/** The validation codes of the protocol, in allocation order. */\n" +
             `export const VALIDATION_CODES = ${codeArray(VALIDATION_CODES)};\n` +
-            "\n/** A validation code (§13.3): what one issue in a cause is about. */\n" +
+            "\n/** A validation code: what one issue in a cause is about. */\n" +
             "export type ValidationCode = (typeof VALIDATION_CODES)[number];\n" +
             ERRORS_MODULE_TYPES +
             classes.join("") +
@@ -278,36 +204,12 @@ export function emitErrorsModule() {
             "}\n",
     };
 }
-/**
- * `runtime/transport.ts` — the happy path of §12 and §13.5, above Phase
- * 12-partial's boundary: one POST per operation to
- * `<entrypoint>/_resources/<resource>/<family>/<variant>` (§12.1–§12.3), the
- * identity headers on every request (§12.4), per-request options that are never
- * serialized (§15.7), and the envelope read back by §13.5's rule.
- *
- * `execute` is Q1 = B's primitive: exported from this module for the
- * per-variant methods to wrap, and re-exported from nowhere — it is not public
- * surface. It reads no capability and no operation descriptor; the caller names
- * the operation.
- *
- * Fetch and AbortSignal are the platform's, reached through the structural types
- * below so the module compiles with neither DOM nor Node types (§15.7, U5).
- *
- * Stale-route recovery is not here: it is F-716, Phase 10's, and the emitted
- * module documents it as a hole in its own doc comment (S9).
- */
-export function emitTransportModule() {
-    return { path: "runtime/transport.ts", source: TRANSPORT_MODULE };
+export function emitTransportModule(style) {
+    return {
+        path: "runtime/transport.ts",
+        source: transportModuleSource(moduleSpecifierWriter(style)),
+    };
 }
-/**
- * Core's identity header names (`AvProtocol.headers`, §12.4), split back into
- * the one wire prefix and each header's own part, so the emitted transport
- * spells both from one constant — its freeze stays a one-line change in the
- * generated code — and from core's values rather than restated text.
- *
- * @throws Error at load when core's names stop sharing one `<prefix>-` head:
- *   the emitted spelling could no longer be the names core sends.
- */
 const IDENTITY_HEADERS = (() => {
     const { protocolVersion, contractHash, requestId } = AvProtocol.headers;
     const prefix = protocolVersion.slice(0, protocolVersion.indexOf("-"));
@@ -323,9 +225,10 @@ const IDENTITY_HEADERS = (() => {
         requestId: requestId.slice(prefix.length),
     };
 })();
-const TRANSPORT_MODULE = `import { CLIENT_CONTRACT_HASH, PROTOCOL_VERSION } from "../metadata.js";
-import { decodeResult, encodeArguments, serializeWireBody } from "./codec.js";
-import { DECODE_TABLE } from "./descriptor.js";
+function transportModuleSource(from) {
+    return `import { CLIENT_CONTRACT_HASH, PROTOCOL_VERSION } from ${from("../metadata")};
+import { decodeResult, encodeArguments, serializeWireBody } from ${from("./codec")};
+import { DECODE_TABLE } from ${from("./descriptor")};
 import {
 	type Cause,
 	frameworkErrorOf,
@@ -336,20 +239,20 @@ import {
 	VALIDATION_CODES,
 	type ValidationCode,
 	type ValidationIssue,
-} from "./errors.js";
+} from ${from("./errors")};
 
 /**
- * The transport of Aventara protocol version 1: one POST per operation (§12.2),
- * sent with the protocol version and ClientContract hash (§12.4), its response
- * read by §13.5's rule — A1xxx resolves with the envelope's data, every other
+ * The transport of Aventara protocol version 1: one POST per operation,
+ * sent with the protocol version and ClientContract hash, its response
+ * read by the protocol's rule — A1xxx resolves with the envelope's data, every other
  * code throws its FrameworkError subclass, and anything that is not a framework
- * envelope throws TransportError. No request is ever retried (§13.5).
+ * envelope throws TransportError. No request is ever retried.
  *
- * # A stale client (F-716)
+ * # A stale client
  *
  * A client generated against an older ClientContract must fail hard and say to
  * regenerate (cross-phase invariant 15). The server is what knows: it checks the
- * identity this transport sends BEFORE it routes (Phase 10, Q3), so a request
+ * identity this transport sends BEFORE it routes, so a request
  * under a stale hash — to an operation the deployment still advertises, or to
  * one it no longer does — is answered 409 A2005, which throws
  * ContractMismatchError naming the remedy. Nothing here guesses: a response that
@@ -358,17 +261,17 @@ import {
  * client is stale.
  */
 
-/** The wire prefix of the identity headers, in one place: its freeze (§12.4) is a one-line change. */
+/** The wire prefix of the identity headers, in one place: its freeze is a one-line change. */
 const WIRE_PREFIX = ${JSON.stringify(IDENTITY_HEADERS.prefix)};
 
-/** The headers the framework owns on every operation request (§12.3, §12.4). */
+/** The headers the framework owns on every operation request. */
 const FRAMEWORK_HEADERS: Readonly<Record<string, string>> = {
 	"Content-Type": "application/json",
 	[WIRE_PREFIX + ${JSON.stringify(IDENTITY_HEADERS.protocolVersion)}]: String(PROTOCOL_VERSION),
 	[WIRE_PREFIX + ${JSON.stringify(IDENTITY_HEADERS.contractHash)}]: CLIENT_CONTRACT_HASH,
 };
 
-/** The request id header (§12.4, Phase 10 Q13): CallOptions.requestId sends it. */
+/** The request id header: CallOptions.requestId sends it. */
 const REQUEST_ID_HEADER = WIRE_PREFIX + ${JSON.stringify(IDENTITY_HEADERS.requestId)};
 
 /** What the transport reads of an AbortSignal, where the consumer's lib declares none. */
@@ -394,7 +297,7 @@ export interface FetchResponse {
 export type StructuralFetch = (url: string, init: FetchInit) => Promise<FetchResponse>;
 
 /**
- * The fetch this client calls (§15.7): the consumer's own platform fetch type when
+ * The fetch this client calls: the consumer's own platform fetch type when
  * their lib declares one — DOM's, Node's — so the platform fetch is accepted
  * without a cast, and the structural fetch above where it declares none. Read
  * through typeof globalThis, so this module names neither lib.
@@ -410,12 +313,12 @@ export type PlatformSignal = typeof globalThis extends {
 
 /** Where operations go: the framework entrypoint, and the fetch that reaches it. */
 export interface TransportConnection {
-	/** The framework entrypoint, an absolute URL without a trailing slash (§12.1). */
+	/** The framework entrypoint, an absolute URL without a trailing slash. */
 	readonly entrypoint: string;
 	readonly fetch: Fetch;
 }
 
-/** Per-call options (§15.7). Never serialized into the operation body. */
+/** Per-call options. Never serialized into the operation body. */
 export interface CallOptions {
 	/** Aborts the request; the call rejects with what fetch rejected with. */
 	readonly signal?: PlatformSignal;
@@ -430,10 +333,15 @@ export interface CallOptions {
 
 type SuccessCode = Exclude<OperationCode, OperationErrorCode>;
 
-/** A framework envelope (§13.1), read and checked. */
+/**
+ * A framework envelope, read and checked — told apart by \`outcome\`, a string
+ * discriminant, rather than by \`cause\` being null: without \`strictNullChecks\`
+ * (\`strict: false\`, which Next.js writes into a tsconfig it creates) null
+ * narrows nothing, and the client must type-check under the consumer's settings.
+ */
 type Envelope =
-	| { readonly code: SuccessCode; readonly data: unknown; readonly cause: null }
-	| { readonly code: OperationErrorCode; readonly data: null; readonly cause: Cause };
+	| { readonly outcome: "data"; readonly code: SuccessCode; readonly data: unknown }
+	| { readonly outcome: "failure"; readonly code: OperationErrorCode; readonly cause: Cause };
 
 /**
  * Runs one operation: POSTs its arguments and settles its envelope.
@@ -461,7 +369,7 @@ export async function execute(
 }
 
 /**
- * Runs one transaction plan (§14.2): POSTs it to \`/_transactions\` and settles
+ * Runs one transaction plan: POSTs it to \`/_transactions\` and settles
  * its envelope; a committed plan's data is one result per operation, each decoded
  * by its own operation's Resource (\`resources\`, in plan order).
  *
@@ -529,7 +437,7 @@ async function post(
 
 /**
  * The decoded data, or — a scalar in \`data\` that does not decode, inside an
- * otherwise valid envelope — a TransportError (architect, 2026-10-04).
+ * otherwise valid envelope — a TransportError.
  */
 function decoded<T>(operation: string, status: number, decode: () => T): T {
 	try {
@@ -544,9 +452,9 @@ function decoded<T>(operation: string, status: number, decode: () => T): T {
 }
 
 /**
- * Settles one response by §13.5's rule: the envelope's data, still in wire form,
- * which the caller decodes by the decode table (P1). A decode failure's mode is
- * decided (architect, 2026-10-04):
+ * Settles one response by the protocol's rule: the envelope's data, still in wire form,
+ * which the caller decodes by the decode table. A decode failure's mode is
+ * decided:
  * A scalar in \`data\` that fails to decode, inside an otherwise valid envelope, throws TransportError
  * — not a FrameworkError, because the server reported no failure; the response is
  * one this client cannot read, which is what TransportError means.
@@ -559,10 +467,10 @@ function settle(operation: string, status: number, text: string): unknown {
 			status,
 		);
 	}
-	if (envelope.cause === null) {
-		return envelope.data;
+	if (envelope.outcome === "failure") {
+		throw frameworkErrorOf(envelope.code, envelope.cause);
 	}
-	throw frameworkErrorOf(envelope.code, envelope.cause);
+	return envelope.data;
 }
 
 /** The parsed body, or undefined — which no envelope is — when it is not JSON. */
@@ -590,7 +498,7 @@ function isSuccessCode(code: OperationCode): code is SuccessCode {
 	return code.startsWith("A1");
 }
 
-/** The envelope in a parsed body, or undefined when the body is not one (§13.1). */
+/** The envelope in a parsed body, or undefined when the body is not one. */
 function envelopeOf(body: unknown): Envelope | undefined {
 	if (!isRecord(body) || !Object.hasOwn(body, "data")) {
 		return undefined;
@@ -601,14 +509,14 @@ function envelopeOf(body: unknown): Envelope | undefined {
 		return undefined;
 	}
 	if (isSuccessCode(code)) {
-		return body["cause"] === null && (code !== "A1001" || data === null) ? { code, data, cause: null } : undefined;
+		return body["cause"] === null && (code !== "A1001" || data === null) ? { outcome: "data", code, data } : undefined;
 	}
 	const cause = causeOf(body["cause"]);
-	return data === null && cause !== undefined ? { code, data, cause } : undefined;
+	return data === null && cause !== undefined ? { outcome: "failure", code, cause } : undefined;
 }
 
 /**
- * The cause rebuilt from the members §13.1 defines, or undefined when one of them
+ * The cause rebuilt from the members the protocol defines, or undefined when one of them
  * is malformed. Every other member is dropped, so whatever else a server put in
  * its cause — a stack, SQL, a file path — is never carried into a thrown error.
  */
@@ -672,10 +580,10 @@ function issueOf(value: unknown): ValidationIssue | undefined {
 	return Object.freeze({ path: Object.freeze(segments), code, message });
 }
 
-/** The arguments, refused unless they are an object: the body is always one (§12.6). */
+/** The arguments, refused unless they are an object: the body is always one. */
 function argumentObject(args: unknown): unknown {
 	if (!isRecord(args)) {
-		throw new TypeError("An operation's arguments must be an object; send {} when there are none (§12.3).");
+		throw new TypeError("An operation's arguments must be an object; send {} when there are none.");
 	}
 	return args;
 }
@@ -683,14 +591,14 @@ function argumentObject(args: unknown): unknown {
 /**
  * The framework's headers plus the caller's, refusing a caller's that names one of
  * the framework's; then requestId, which overwrites any request id header the
- * caller set (architect, 2026-10-05).
+ * caller set.
  */
 function requestHeaders(options: CallOptions): Record<string, string> {
 	const headers: Record<string, string> = { ...FRAMEWORK_HEADERS };
 	const owned = new Set(Object.keys(FRAMEWORK_HEADERS).map((name) => name.toLowerCase()));
 	for (const [name, value] of Object.entries(options.headers ?? {})) {
 		if (owned.has(name.toLowerCase())) {
-			throw new TypeError('The "' + name + '" header is the framework\\'s own; a request cannot set it (§12.4).');
+			throw new TypeError('The "' + name + '" header is the framework\\'s own; a request cannot set it.');
 		}
 		headers[name] = value;
 	}
@@ -705,3 +613,4 @@ function requestHeaders(options: CallOptions): Record<string, string> {
 	return headers;
 }
 `;
+}

package/dist/emit/scalar.codec.d.ts

@@ -1,51 +1,38 @@
 import { AvProtocol } from "@aventara/core/protocol";
 import type { EmittedModule } from "./emitted-tree.interface.js";
+import { type ClientModuleStyle } from "./module-style.interface.js";
 /**
- * The scalar codecs of §6.2, as the generated client carries them in
- * `runtime/codec.ts`.
- *
  * # Keyed on `BuiltInScalar` alone
  *
- * §6.2's table is fixed by PROTOCOL VERSION, not carried in the Contract: the
- * scalar registry is a key registry (`{ builtin: true }`) and scalars carry no
- * position qualifier [M10]. So the codec reads no field, no capability and no
- * operation descriptor — the caller names the scalar, and the codec converts one
- * value. Walking a Resource's fields to find which scalar a value is belongs to
- * the method surface, below Phase 12-partial's boundary.
+ * So the codec reads no field, no capability and no operation descriptor — the
+ * caller names the scalar, and the codec converts one value.
  *
- * One source for the scalar set: the emitted `BuiltInScalar` union and the
- * emitted table both come from core's `BUILT_IN_SCALARS`, in its order, and
- * {@link SCALAR_CODEC_SOURCES} is a mapped type over core's `BuiltInScalar` — a
- * scalar the protocol adds is a compile error here until its codec is written.
+ * One source for the scalar set: the emitted `BuiltInScalar` union and the emitted
+ * table both come from core's `BUILT_IN_SCALARS`, in its order, and {@link
+ * SCALAR_CODEC_SOURCES} is a mapped type over core's `BuiltInScalar` — a scalar
+ * the protocol adds is a compile error here until its codec is written.
  *
  * # Untyped on purpose
  *
- * Every codec is `unknown → unknown`, checked at runtime. The TYPE of a scalar's
- * application form and wire form is Phase 9's `ScalarValueType` and its `Forms`
- * maps (architect decision Q3 = 3a); declaring a second scalar→type map here
- * would be a parallel source of that fact. When the boundary lifts, the methods
- * that call these codecs carry the types.
+ * Every codec is `unknown → unknown`, checked at runtime. When the boundary lifts,
+ * the methods that call these codecs carry the types.
  *
  * # What the emitted codec promises
  *
- * - `encodeScalar`/`decodeScalar` convert between the generated runtime value
- *   and the JSON wire value of §6.2, and `decodeScalar(s, encodeScalar(s, v))`
- *   equals `v` for every scalar.
  * - `null` passes through both: it is explicit, and whether a field admits it is
- *   the field's nullability, which the server validates (§6.2).
+ *   the field's nullability, which the server validates.
  * - `undefined` is never a value: an optional property is omitted, and
  *   `serializeWireBody` strips every `undefined` property before transport.
- * - A value outside a scalar's runtime or wire form is refused with a
- *   `TypeError` naming the scalar — never coerced. A `json` value carrying a
- *   `BigInt`, `Date`, `Uint8Array`, `Decimal`, function, symbol or `undefined`
- *   is refused (§6.2), with the path to the offending member.
- * - Wire grammars are the server's, read from core — `AvProtocol.scalarFormats`
- *   (C2, R7) — and emitted by value as regular-expression literals
- *   ({@link wireGrammarLiteral}): bigint `-?(0|[1-9]\d*)`, datetime exactly
+ * - A value outside a scalar's runtime or wire form is refused with a `TypeError`
+ *   naming the scalar — never coerced. A `json` value carrying a `BigInt`, `Date`,
+ *   `Uint8Array`, `Decimal`, function, symbol or `undefined` is refused, with the
+ *   path to the offending member.
+ * - Wire grammars are the server's, read from core — `AvProtocol.scalarFormats` —
+ *   and emitted by value as regular-expression literals ({@link
+ *   wireGrammarLiteral}): bigint `-?(0|[1-9]\d*)`, datetime exactly
  *   `toISOString()`'s form, bytes RFC 4648 base64 with the standard alphabet and
- *   padding, canonical (zero pad bits, like the server's — C1). Base64 is written
- *   out rather than delegated to `atob`/`btoa`, so the module needs neither a DOM
- *   nor a Node global (§15.7, U5).
+ *   padding, canonical. Base64 is written out rather than delegated to
+ *   `atob`/`btoa`, so the module needs neither a DOM nor a Node global.
  */
 /**
  * The regular-expression literal of one of core's wire grammars, as emitted
@@ -60,4 +47,4 @@ export declare function wireGrammarLiteral(scalar: keyof typeof AvProtocol.scala
  * functions the generated transport calls. Nothing here is re-exported from the
  * tree's `AvClient.ts`: the codec is the runtime's, not the consumer's.
  */
-export declare function emitScalarCodecModule(): EmittedModule;
+export declare function emitScalarCodecModule(style: ClientModuleStyle): EmittedModule;