@aventara/client 0.0.0-stage → 0.1.0-pilot.1

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

@@ -0,0 +1,63 @@
+import { AvProtocol } from "@aventara/core/protocol";
+import type { EmittedModule } from "./emitted-tree.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.
+ *
+ * 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.
+ *
+ * # 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).
+ * - `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
+ *   `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).
+ */
+/**
+ * The regular-expression literal of one of core's wire grammars, as emitted
+ * source: `/<source>/`, the grammar's own text. The sources are anchored,
+ * flagless and carry a `/` only inside a character class, which core's
+ * `av-protocol.spec.ts` pins, so the literal is the grammar itself.
+ */
+export declare function wireGrammarLiteral(scalar: keyof typeof AvProtocol.scalarFormats): string;
+/**
+ * `runtime/codec.ts`: the `BuiltInScalar` union and the codec table in core's
+ * `BUILT_IN_SCALARS` order, the helpers the codecs share, and the three
+ * 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;

package/dist/emit/scalar.codec.js

@@ -0,0 +1,498 @@
+import { BUILT_IN_SCALARS } from "@aventara/core";
+import { AvProtocol } from "@aventara/core/protocol";
+/**
+ * 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.
+ *
+ * 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.
+ *
+ * # 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).
+ * - `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
+ *   `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).
+ */
+/**
+ * The regular-expression literal of one of core's wire grammars, as emitted
+ * source: `/<source>/`, the grammar's own text. The sources are anchored,
+ * flagless and carry a `/` only inside a character class, which core's
+ * `av-protocol.spec.ts` pins, so the literal is the grammar itself.
+ */
+export function wireGrammarLiteral(scalar) {
+    return `/${AvProtocol.scalarFormats[scalar]}/`;
+}
+const SCALAR_CODEC_SOURCES = {
+    string: {
+        encode: `(value) => (typeof value === "string" ? value : refuse("string", "runtime", "a string"))`,
+        decode: `(wire) => (typeof wire === "string" ? wire : refuse("string", "wire", "a string"))`,
+    },
+    boolean: {
+        encode: `(value) => (typeof value === "boolean" ? value : refuse("boolean", "runtime", "a boolean"))`,
+        decode: `(wire) => (typeof wire === "boolean" ? wire : refuse("boolean", "wire", "a boolean"))`,
+    },
+    int: {
+        encode: `(value) => (isInt32(value) ? value : refuse("int", "runtime", "a 32-bit integer"))`,
+        decode: `(wire) => (isInt32(wire) ? wire : refuse("int", "wire", "a 32-bit integer"))`,
+    },
+    float: {
+        encode: `(value) => (isFiniteNumber(value) ? value : refuse("float", "runtime", "a finite number"))`,
+        decode: `(wire) => (isFiniteNumber(wire) ? wire : refuse("float", "wire", "a finite number"))`,
+    },
+    bigint: {
+        encode: `(value) => (typeof value === "bigint" ? value.toString(10) : refuse("bigint", "runtime", "a bigint"))`,
+        decode: `(wire) =>
+			typeof wire === "string" && BIGINT_WIRE.test(wire)
+				? BigInt(wire)
+				: refuse("bigint", "wire", "a base-10 integer string")`,
+    },
+    decimal: {
+        encode: `(value) => (value instanceof Decimal ? value.toString() : refuse("decimal", "runtime", "a Decimal"))`,
+        decode: "decodeDecimal",
+    },
+    datetime: {
+        encode: "encodeDatetime",
+        decode: "decodeDatetime",
+    },
+    bytes: {
+        encode: `(value) => (value instanceof Uint8Array ? encodeBase64(value) : refuse("bytes", "runtime", "a Uint8Array"))`,
+        decode: `(wire) =>
+			(typeof wire === "string" ? decodeBase64(wire) : undefined) ??
+			refuse("bytes", "wire", "an RFC 4648 base64 string")`,
+    },
+    json: {
+        encode: `(value) => copyJson("runtime", value, [], new Set())`,
+        decode: `(wire) => copyJson("wire", wire, [], new Set())`,
+    },
+};
+const CODEC_MODULE_HEAD = `import { Decimal } from "./decimal.js";
+import type { FieldDecoding } from "./descriptor.js";
+
+/**
+ * The scalar codecs of Aventara protocol version 1 (§6.2): one per built-in
+ * scalar, converting between the generated runtime value and the JSON wire value.
+ * A value is never wrapped per field — the Contract names the scalar, so the
+ * caller says which scalar a value is.
+ *
+ * null is explicit in both directions and passes through; whether a field admits
+ * it is the field's nullability. undefined is never a value: an optional
+ * property is omitted (serializeWireBody). Anything outside a scalar's runtime or
+ * wire form is refused with a TypeError, never coerced.
+ */
+`;
+const CODEC_MODULE_BODY = `
+interface ScalarCodec {
+	/** The generated runtime value to its JSON wire value. */
+	readonly encode: (value: unknown) => unknown;
+	/** The JSON wire value to the generated runtime value. */
+	readonly decode: (wire: unknown) => unknown;
+}
+
+type Side = "runtime" | "wire";
+type Path = readonly (string | number)[];
+
+const INT32_MIN = -(2 ** 31);
+const INT32_MAX = 2 ** 31 - 1;
+const BIGINT_WIRE = ${wireGrammarLiteral("bigint")};
+const DATETIME_WIRE = ${wireGrammarLiteral("datetime")};
+const BASE64_WIRE = ${wireGrammarLiteral("bytes")};
+const BASE64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+function refuse(scalar: BuiltInScalar, side: Side, expected: string): never {
+	throw new TypeError('A "' + scalar + '" ' + side + " value must be " + expected + ".");
+}
+
+function isInt32(value: unknown): value is number {
+	return typeof value === "number" && Number.isInteger(value) && value >= INT32_MIN && value <= INT32_MAX;
+}
+
+function isFiniteNumber(value: unknown): value is number {
+	return typeof value === "number" && Number.isFinite(value);
+}
+
+function decodeDecimal(wire: unknown): Decimal {
+	if (typeof wire === "string") {
+		try {
+			return new Decimal(wire);
+		} catch {
+			// Refused below, naming the scalar.
+		}
+	}
+	return refuse("decimal", "wire", "a decimal string");
+}
+
+function encodeDatetime(value: unknown): string {
+	if (!(value instanceof Date) || Number.isNaN(value.getTime())) {
+		return refuse("datetime", "runtime", "a valid Date");
+	}
+	const wire = value.toISOString();
+	return DATETIME_WIRE.test(wire) ? wire : refuse("datetime", "runtime", "a Date in the years 0000 to 9999");
+}
+
+function decodeDatetime(wire: unknown): Date {
+	if (typeof wire === "string" && DATETIME_WIRE.test(wire)) {
+		const date = new Date(wire);
+		if (!Number.isNaN(date.getTime()) && date.toISOString() === wire) {
+			return date;
+		}
+	}
+	return refuse("datetime", "wire", "a canonical ISO-8601 UTC string");
+}
+
+function encodeBase64(bytes: Uint8Array): string {
+	let text = "";
+	for (let index = 0; index < bytes.length; index += 3) {
+		const remaining = bytes.length - index;
+		const group = ((bytes[index] ?? 0) << 16) | ((bytes[index + 1] ?? 0) << 8) | (bytes[index + 2] ?? 0);
+		text += sextet(group, 18) + sextet(group, 12);
+		text += remaining > 1 ? sextet(group, 6) : "=";
+		text += remaining > 2 ? sextet(group, 0) : "=";
+	}
+	return text;
+}
+
+function sextet(group: number, shift: number): string {
+	return BASE64_ALPHABET.charAt((group >> shift) & 63);
+}
+
+/** The bytes of a canonical RFC 4648 base64 string; undefined for any other string. */
+function decodeBase64(wire: string): Uint8Array | undefined {
+	if (!BASE64_WIRE.test(wire)) {
+		return undefined;
+	}
+	const padding = wire.endsWith("==") ? 2 : wire.endsWith("=") ? 1 : 0;
+	const bytes = new Uint8Array((wire.length / 4) * 3 - padding);
+	let written = 0;
+	for (let index = 0; index < wire.length; index += 4) {
+		let group = 0;
+		for (let offset = 0; offset < 4; offset += 1) {
+			const symbol = wire.charAt(index + offset);
+			group = (group << 6) | (symbol === "=" ? 0 : BASE64_ALPHABET.indexOf(symbol));
+		}
+		const count = index + 4 === wire.length ? 3 - padding : 3;
+		// Bits a padded group does not carry must be zero, or two strings would
+		// name one byte sequence.
+		if ((group & ((1 << (8 * (3 - count))) - 1)) !== 0) {
+			return undefined;
+		}
+		for (let byte = 0; byte < count; byte += 1) {
+			bytes[written] = (group >> (16 - 8 * byte)) & 255;
+			written += 1;
+		}
+	}
+	return bytes;
+}
+
+function isPlainRecord(value: object): boolean {
+	const prototype: unknown = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+}
+
+/** What a value that is not JSON-safe is, for a refusal. */
+function kindOf(value: unknown): string {
+	if (value === undefined) {
+		return "undefined";
+	}
+	if (typeof value === "bigint") {
+		return "a bigint";
+	}
+	if (typeof value === "number") {
+		return "a non-finite number";
+	}
+	if (typeof value === "function") {
+		return "a function";
+	}
+	if (typeof value === "symbol") {
+		return "a symbol";
+	}
+	if (value instanceof Date) {
+		return "a Date";
+	}
+	if (value instanceof Uint8Array) {
+		return "a Uint8Array";
+	}
+	if (value instanceof Decimal) {
+		return "a Decimal";
+	}
+	if (typeof value === "object" && value !== null && isPlainRecord(value)) {
+		return "a symbol-keyed property";
+	}
+	return "a non-plain object";
+}
+
+/** A JSON Pointer (RFC 6901) to a member, or "the root". */
+function pointerOf(path: Path): string {
+	return path.length === 0
+		? "the root"
+		: path.map((segment) => "/" + String(segment).replaceAll("~", "~0").replaceAll("/", "~1")).join("");
+}
+
+function isJsonContainer(value: object): boolean {
+	return Array.isArray(value) || (isPlainRecord(value) && Object.getOwnPropertySymbols(value).length === 0);
+}
+
+/** A copy of a JSON-safe value, or a refusal naming the first member that is not. */
+function copyJson(side: Side, value: unknown, path: Path, ancestors: Set<object>): unknown {
+	if (value === null || typeof value === "string" || typeof value === "boolean" || isFiniteNumber(value)) {
+		return value;
+	}
+	if (typeof value !== "object" || !isJsonContainer(value)) {
+		return refuse("json", side, "JSON-safe, and " + kindOf(value) + " at " + pointerOf(path) + " is not");
+	}
+	if (ancestors.has(value)) {
+		return refuse("json", side, "acyclic, and " + pointerOf(path) + " repeats an ancestor");
+	}
+	ancestors.add(value);
+	let copy: unknown;
+	if (Array.isArray(value)) {
+		const items: unknown[] = [];
+		for (let index = 0; index < value.length; index += 1) {
+			items.push(copyJson(side, value[index], [...path, index], ancestors));
+		}
+		copy = items;
+	} else {
+		// fromEntries defines each key, so "__proto__" stays an own key.
+		copy = Object.fromEntries(
+			Object.entries(value).map(([key, member]) => [key, copyJson(side, member, [...path, key], ancestors)]),
+		);
+	}
+	ancestors.delete(value);
+	return copy;
+}
+
+function refuseBody(path: Path, what: string): never {
+	throw new TypeError(
+		"A request body must be JSON-safe once its scalars are encoded, and " + what + " at " + pointerOf(path) + " is not.",
+	);
+}
+
+function writeWireJson(value: unknown, path: Path, ancestors: Set<object>): string {
+	if (value === null) {
+		return "null";
+	}
+	if (typeof value === "string" || isFiniteNumber(value)) {
+		return JSON.stringify(value);
+	}
+	if (typeof value === "boolean") {
+		return value ? "true" : "false";
+	}
+	if (typeof value !== "object" || !isJsonContainer(value)) {
+		return refuseBody(path, kindOf(value));
+	}
+	if (ancestors.has(value)) {
+		return refuseBody(path, "a cycle");
+	}
+	ancestors.add(value);
+	let text: string;
+	if (Array.isArray(value)) {
+		const items: string[] = [];
+		for (let index = 0; index < value.length; index += 1) {
+			// An undefined element is refused, not stripped: JSON would make it null.
+			items.push(writeWireJson(value[index], [...path, index], ancestors));
+		}
+		text = "[" + items.join(",") + "]";
+	} else {
+		const members: string[] = [];
+		for (const [key, member] of Object.entries(value)) {
+			if (member !== undefined) {
+				members.push(JSON.stringify(key) + ":" + writeWireJson(member, [...path, key], ancestors));
+			}
+		}
+		text = "{" + members.join(",") + "}";
+	}
+	ancestors.delete(value);
+	return text;
+}
+
+function codecOf(scalar: BuiltInScalar): ScalarCodec {
+	if (!Object.hasOwn(SCALAR_CODECS, scalar)) {
+		throw new TypeError('"' + String(scalar) + '" is not a built-in scalar of this protocol version.');
+	}
+	return SCALAR_CODECS[scalar];
+}
+
+/** The JSON wire value of a scalar's runtime value; null passes through. */
+export function encodeScalar(scalar: BuiltInScalar, value: unknown): unknown {
+	const codec = codecOf(scalar);
+	return value === null ? null : codec.encode(value);
+}
+
+/** The runtime value of a scalar's JSON wire value; null passes through. */
+export function decodeScalar(scalar: BuiltInScalar, wire: unknown): unknown {
+	const codec = codecOf(scalar);
+	return wire === null ? null : codec.decode(wire);
+}
+
+/**
+ * The JSON text of a request body whose scalars are already encoded. Every
+ * undefined property is stripped, at every depth — an optional property is
+ * omitted, never sent — and null is kept as the explicit value it is (§6.2).
+ * Anything else that is not JSON-safe is refused rather than coerced: it means a
+ * value escaped its scalar codec.
+ */
+export function serializeWireBody(body: unknown): string {
+	return writeWireJson(body, [], new Set());
+}
+
+/**
+ * An operation's arguments with every scalar in its wire form, read off each
+ * value's runtime class (Phase 12-rest Q15 = a, the server's encode mirrored): a
+ * bigint, a Date, a Decimal or a Uint8Array is encoded wherever it stands — a
+ * filter operand, a data value, a cursor — and plain objects and arrays are
+ * walked. Every other value is left for serializeWireBody, which refuses what is
+ * not JSON-safe. A json value cannot hold one of the four classes (the types
+ * exclude them), so nothing inside one is ever re-read as a scalar.
+ */
+export function encodeArguments(value: unknown): unknown {
+	return encodeValue(value, [], new Set());
+}
+
+function encodeValue(value: unknown, path: Path, ancestors: Set<object>): unknown {
+	if (typeof value === "bigint") {
+		return encodeScalar("bigint", value);
+	}
+	if (value instanceof Date) {
+		return encodeScalar("datetime", value);
+	}
+	if (value instanceof Decimal) {
+		return encodeScalar("decimal", value);
+	}
+	if (value instanceof Uint8Array) {
+		return encodeScalar("bytes", value);
+	}
+	if (typeof value !== "object" || value === null || !isJsonContainer(value)) {
+		return value;
+	}
+	if (ancestors.has(value)) {
+		return refuseBody(path, "a cycle");
+	}
+	ancestors.add(value);
+	const copy = Array.isArray(value)
+		? value.map((item, index) => encodeValue(item, [...path, index], ancestors))
+		: Object.fromEntries(
+				Object.entries(value).map(([key, member]) => [key, encodeValue(member, [...path, key], ancestors)]),
+			);
+	ancestors.delete(value);
+	return copy;
+}
+
+/** Which result fields of each Resource decode, and how (generated/runtime/descriptor.ts). */
+export type DecodeTable = {
+	readonly [resource: string]: { readonly [field: string]: FieldDecoding };
+};
+
+/**
+ * An operation's result with every scalar in its runtime form, read off the decode
+ * table (P1): a number (a count), null, and the data of a Resource the table
+ * does not name pass through; a list is a list of
+ * records, anything else is one record of \`resource\`. In a record, a field the
+ * table names is revived — each item of a list field — a relation recurses with
+ * its target, and every other key passes through untouched: json is never
+ * revived. A to-many relation's value is a list, \`{ data, count }\` or
+ * \`{ count }\` — the three shapes the derivation gives it.
+ *
+ * @throws TypeError when a value is not the wire form its field's scalar takes —
+ *   which the transport answers as a TransportError (architect, 2026-10-04).
+ */
+export function decodeResult(table: DecodeTable, resource: string, value: unknown): unknown {
+	// A Resource the table does not name has nothing to revive: its data passes.
+	if (value === null || typeof value === "number" || !Object.hasOwn(table, resource)) {
+		return value;
+	}
+	return Array.isArray(value)
+		? value.map((record) => decodeRecord(table, resource, record))
+		: decodeRecord(table, resource, value);
+}
+
+function decodeRecord(table: DecodeTable, resource: string, record: unknown): unknown {
+	if (record === null) {
+		return null;
+	}
+	if (typeof record !== "object" || Array.isArray(record)) {
+		throw new TypeError('A "' + resource + '" record must be an object.');
+	}
+	const fields = Object.hasOwn(table, resource) ? table[resource] : undefined;
+	return Object.fromEntries(
+		Object.entries(record).map(([key, member]) => {
+			const decoding = fields !== undefined && Object.hasOwn(fields, key) ? fields[key] : undefined;
+			return [key, decoding === undefined ? member : decodeField(table, decoding, member)];
+		}),
+	);
+}
+
+function decodeField(table: DecodeTable, decoding: FieldDecoding, value: unknown): unknown {
+	if (typeof decoding === "string") {
+		return Array.isArray(value) ? value.map((item) => decodeScalar(decoding, item)) : decodeScalar(decoding, value);
+	}
+	if (value === null || !decoding.many) {
+		return decodeRecord(table, decoding.relation, value);
+	}
+	if (Array.isArray(value)) {
+		return value.map((record) => decodeRecord(table, decoding.relation, record));
+	}
+	if (typeof value === "object" && Object.hasOwn(value, "data")) {
+		const envelope = value as { readonly data: unknown };
+		if (!Array.isArray(envelope.data)) {
+			throw new TypeError('A "' + decoding.relation + '" list must be an array.');
+		}
+		return { ...value, data: envelope.data.map((record) => decodeRecord(table, decoding.relation, record)) };
+	}
+	return value;
+}
+`;
+/**
+ * `runtime/codec.ts`: the `BuiltInScalar` union and the codec table in core's
+ * `BUILT_IN_SCALARS` order, the helpers the codecs share, and the three
+ * 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 function emitScalarCodecModule() {
+    const union = BUILT_IN_SCALARS.map((scalar) => `\t| ${JSON.stringify(scalar)}`).join("\n");
+    const table = BUILT_IN_SCALARS.map((scalar) => {
+        const { encode, decode } = SCALAR_CODEC_SOURCES[scalar];
+        return `\t${scalar}: {\n\t\tencode: ${encode},\n\t\tdecode: ${decode},\n\t},`;
+    }).join("\n");
+    return {
+        path: "runtime/codec.ts",
+        source: CODEC_MODULE_HEAD +
+            "\n/** The built-in scalars of the protocol (§6.1). */\n" +
+            `export type BuiltInScalar =\n${union};\n` +
+            CODEC_MODULE_BODY +
+            "\nconst SCALAR_CODECS: { readonly [S in BuiltInScalar]: ScalarCodec } = {\n" +
+            `${table}\n};\n`,
+    };
+}

package/dist/emit/transaction.emitter.d.ts

@@ -0,0 +1,17 @@
+import type { EmittedModule } from "./emitted-tree.interface.js";
+/**
+ * The transaction builder and runner (§14; Phase 12-rest S6, Q13, Q14, P3):
+ * `runtime/fingerprint.ts` and `runtime/transaction.ts`, emitted iff the
+ * ClientContract advertises `interactive` transactions (P3) — `client.ts` wires
+ * them to `avClient.tx` and `avClient.transaction`.
+ *
+ * Both are fixed by protocol version, not by the Contract, and mirror core's own
+ * seams: the plan is assembled as `transactions/transaction-plan-assembler.ts`
+ * assembles it — handles as pure data, a `$ref` bound lazily to its source
+ * handle's position in the list it runs with, the two refusals core answers in
+ * process (Q13) — and each node's fingerprint is core's
+ * `computeOperationFingerprint` over the node's WIRE arguments (§14.4), computed
+ * here by an emitted JCS and SHA-256 (Q14: `crypto.subtle` is absent from a
+ * browser page served over plain http from a non-localhost host).
+ */
+export declare function emitTransactionModules(): readonly EmittedModule[];