@aventara/client 1.0.0-rc.0 → 1.0.0-rc.10

package/dist/emit/scalar.codec.js

@@ -29,7 +29,7 @@ const SCALAR_CODEC_SOURCES = {
 				: refuse("bigint", "wire", "a base-10 integer string")`,
     },
     decimal: {
-        encode: `(value) => (value instanceof Decimal ? value.toString() : refuse("decimal", "runtime", "a Decimal"))`,
+        encode: `(value) => (value instanceof AvDecimal ? value.toString() : refuse("decimal", "runtime", "an AvDecimal"))`,
         decode: "decodeDecimal",
     },
     datetime: {
@@ -48,13 +48,13 @@ const SCALAR_CODEC_SOURCES = {
     },
 };
 function codecModuleHead(from) {
-    return `import { Decimal } from ${from("./decimal")};
+    return `import { AvDecimal } from ${from("./decimal")};
 import type { FieldDecoding } from ${from("./descriptor")};
 
 /**
  * The scalar codecs of Aventara protocol version 1: 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
+ * 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
@@ -82,7 +82,7 @@ const DATETIME_WIRE = ${wireGrammarLiteral("datetime")};
 const BASE64_WIRE = ${wireGrammarLiteral("bytes")};
 const BASE64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 
-function refuse(scalar: BuiltInScalar, side: Side, expected: string): never {
+function refuse(scalar: AvBuiltInScalar, side: Side, expected: string): never {
 	throw new TypeError('A "' + scalar + '" ' + side + " value must be " + expected + ".");
 }
 
@@ -94,10 +94,10 @@ function isFiniteNumber(value: unknown): value is number {
 	return typeof value === "number" && Number.isFinite(value);
 }
 
-function decodeDecimal(wire: unknown): Decimal {
+function decodeDecimal(wire: unknown): AvDecimal {
 	if (typeof wire === "string") {
 		try {
-			return new Decimal(wire);
+			return new AvDecimal(wire);
 		} catch {
 			// Refused below, naming the scalar.
 		}
@@ -195,8 +195,8 @@ function kindOf(value: unknown): string {
 	if (value instanceof Uint8Array) {
 		return "a Uint8Array";
 	}
-	if (value instanceof Decimal) {
-		return "a Decimal";
+	if (value instanceof AvDecimal) {
+		return "an AvDecimal";
 	}
 	if (typeof value === "object" && value !== null && isPlainRecord(value)) {
 		return "a symbol-keyed property";
@@ -231,13 +231,18 @@ function copyJson(side: Side, value: unknown, path: Path, ancestors: Set<object>
 	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));
+			// An undefined element (or a hole) is null, as JSON writes it (rc.2).
+			const item = value[index];
+			items.push(item === undefined ? null : copyJson(side, item, [...path, index], ancestors));
 		}
 		copy = items;
 	} else {
-		// fromEntries defines each key, so "__proto__" stays an own key.
+		// fromEntries defines each key, so "__proto__" stays an own key. A key holding
+		// undefined is left out, as JSON leaves it out (rc.2).
 		copy = Object.fromEntries(
-			Object.entries(value).map(([key, member]) => [key, copyJson(side, member, [...path, key], ancestors)]),
+			Object.entries(value)
+				.filter(([, member]) => member !== undefined)
+				.map(([key, member]) => [key, copyJson(side, member, [...path, key], ancestors)]),
 		);
 	}
 	ancestors.delete(value);
@@ -271,8 +276,10 @@ function writeWireJson(value: unknown, path: Path, ancestors: Set<object>): stri
 	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));
+			// An undefined element (or a hole) is null, as JSON writes it (rc.2): the
+			// server reads the same value from an in-process caller.
+			const item = value[index];
+			items.push(item === undefined ? "null" : writeWireJson(item, [...path, index], ancestors));
 		}
 		text = "[" + items.join(",") + "]";
 	} else {
@@ -288,7 +295,7 @@ function writeWireJson(value: unknown, path: Path, ancestors: Set<object>): stri
 	return text;
 }
 
-function codecOf(scalar: BuiltInScalar): ScalarCodec {
+function codecOf(scalar: AvBuiltInScalar): ScalarCodec {
 	if (!Object.hasOwn(SCALAR_CODECS, scalar)) {
 		throw new TypeError('"' + String(scalar) + '" is not a built-in scalar of this protocol version.');
 	}
@@ -296,21 +303,22 @@ function codecOf(scalar: BuiltInScalar): ScalarCodec {
 }
 
 /** The JSON wire value of a scalar's runtime value; null passes through. */
-export function encodeScalar(scalar: BuiltInScalar, value: unknown): unknown {
+export function encodeScalar(scalar: AvBuiltInScalar, 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 {
+export function decodeScalar(scalar: AvBuiltInScalar, 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.
+ * undefined property is stripped, at every depth (an optional property is
+ * omitted, never sent), an undefined array element is null, as JSON.stringify
+ * writes both, and null is kept as the explicit value it is.
  * Anything else that is not JSON-safe is refused rather than coerced: it means a
  * value escaped its scalar codec.
  */
@@ -321,8 +329,8 @@ export function serializeWireBody(body: unknown): string {
 /**
  * An operation's arguments with every scalar in its wire form, read off each
  * value's runtime class: 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
+ * bigint, a Date, an AvDecimal 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.
@@ -333,8 +341,8 @@ export function encodeArguments(value: unknown): unknown {
 
 /**
  * One read of a caller's arguments. Every native read on them happens through it,
- * here and in the transaction builder, so a value that cannot be read — a revoked
- * Proxy (an Immer draft after produce), a throwing getter or trap — is refused at its
+ * here and in the transaction builder, so a value that cannot be read (a revoked
+ * Proxy such as an Immer draft after produce, a throwing getter or trap) is refused at its
  * path with a TypeError before anything is sent, never with the engine's own error.
  */
 export function readArgument<T>(path: Path, read: () => T): T {
@@ -347,12 +355,221 @@ export function readArgument<T>(path: Path, read: () => T): T {
 	}
 }
 
+/** Where each relation directive holds the records its target writes; its other members select. */
+export const RECORD_SITES: { readonly [directive: string]: readonly (string | undefined)[] } = {
+	$create: [undefined],
+	$connect: [],
+	$connectOrCreate: ["create"],
+	$disconnect: [],
+	$set: [],
+	$update: ["data"],
+	$delete: [],
+	$upsert: ["create", "update"],
+};
+
+/** The members of an operation's arguments that hold its write records. */
+export function writeKeysOf(family: string): readonly string[] {
+	return family === "create" || family === "update" ? ["data"] : family === "upsert" ? ["create", "update"] : [];
+}
+
+/** The code an unsent value is refused with: the server's for that place. */
+export type UnsentCode = "V1001" | "V1007" | "V1009";
+
+/** One value a request would leave out: where it is, and the server's code for it. */
+export interface UnsentValue {
+	readonly path: Path;
+	readonly code: UnsentCode;
+}
+
+/**
+ * Every undefined value an operation's arguments hold where leaving it out would
+ * reach more rows than the caller wrote, in argument order, each with the code the
+ * server answers it with:
+ *
+ * - inside a filter, a unique selector or a cursor, at any depth: a where (AND, OR,
+ *   NOT, a relation filter, an operator object, an in list), a cursor, the where and
+ *   cursor of a relation that select or include reads, and a nested write's
+ *   selectors (what $connect, $disconnect, $set and $delete name, and the where of
+ *   $update, $upsert and $connectOrCreate) (V1001);
+ * - a where, cursor, limit or offset that is itself undefined, as a call's or a
+ *   relation's argument (V1001; a unique variant's where V1007, a cursor V1009),
+ *   and the where of $update (V1001), $upsert or $connectOrCreate (V1007).
+ *
+ * JSON drops an undefined value, so such a value is never sent. An undefined field
+ * of a write record is not sent, which is what leaving it out means; a projection,
+ * an order or a directive left undefined is left out as well.
+ */
+export function unsentValues(
+	table: DecodeTable,
+	resource: string,
+	family: string,
+	variant: string,
+	args: unknown,
+): UnsentValue[] {
+	const found: UnsentValue[] = [];
+	const ancestors = new Set<object>();
+
+	const listAt = (value: unknown, path: Path): readonly unknown[] | undefined =>
+		typeof value === "object" && value !== null && readArgument(path, () => Array.isArray(value))
+			? (value as readonly unknown[])
+			: undefined;
+	const recordAt = (value: unknown, path: Path): Readonly<Record<string, unknown>> | undefined =>
+		typeof value === "object" && value !== null && readArgument(path, () => !Array.isArray(value) && isPlainRecord(value))
+			? (value as Readonly<Record<string, unknown>>)
+			: undefined;
+
+	// Visits each member of a container in order (each entry of a list, each key of a
+	// record), undefined ones only when asked; a container met again on its own
+	// ancestry is not walked again, and the encoder refuses it.
+	const each = (
+		container: readonly unknown[] | Readonly<Record<string, unknown>>,
+		path: Path,
+		withUndefined: boolean,
+		visit: (key: string | number, value: unknown, at: Path) => void,
+	): void => {
+		if (ancestors.has(container)) {
+			return;
+		}
+		ancestors.add(container);
+		const keys: readonly (string | number)[] = Array.isArray(container)
+			? Array.from({ length: readArgument(path, () => container.length) }, (_, index) => index)
+			: readArgument(path, () => Object.keys(container));
+		for (const key of keys) {
+			const at = [...path, key];
+			const value = readArgument(at, () => (container as Readonly<Record<string | number, unknown>>)[key]);
+			if (withUndefined || value !== undefined) {
+				visit(key, value, at);
+			}
+		}
+		ancestors.delete(container);
+	};
+	// One entry, or each entry of a list.
+	const entries = (value: unknown, path: Path, visit: (entry: unknown, at: Path) => void): void => {
+		const list = listAt(value, path);
+		if (list === undefined) {
+			visit(value, path);
+		} else {
+			each(list, path, true, (_index, entry, at) => visit(entry, at));
+		}
+	};
+
+	const filter = (value: unknown, path: Path): void => {
+		if (value === undefined) {
+			found.push({ path, code: "V1001" });
+			return;
+		}
+		const container = listAt(value, path) ?? recordAt(value, path);
+		if (container !== undefined) {
+			each(container, path, true, (_key, member, at) => filter(member, at));
+		}
+	};
+	// A read's own arguments (a call's, or a relation's under select or include):
+	// its where and cursor are filters, its limit and offset bound what it returns.
+	const read = (key: string | number, value: unknown, at: Path, whereCode: UnsentCode, cursorCode: UnsentCode): void => {
+		if (key === "where" || key === "cursor") {
+			if (value === undefined) {
+				found.push({ path: at, code: key === "where" ? whereCode : cursorCode });
+			} else {
+				filter(value, at);
+			}
+		} else if (key === "limit" || key === "offset") {
+			if (value === undefined) {
+				found.push({ path: at, code: "V1001" });
+			}
+		} else if ((key === "select" || key === "include") && value !== undefined) {
+			projection(value, at);
+		}
+	};
+	const projection = (value: unknown, path: Path): void => {
+		const list = listAt(value, path);
+		if (list === undefined) {
+			return;
+		}
+		each(list, path, false, (_index, entry, at) => {
+			const relations = recordAt(entry, at);
+			if (relations === undefined) {
+				return;
+			}
+			each(relations, at, false, (_relation, nested, nestedAt) => {
+				const args = recordAt(nested, nestedAt);
+				if (args !== undefined) {
+					each(args, nestedAt, true, (key, member, memberAt) => read(key, member, memberAt, "V1001", "V1009"));
+				}
+			});
+		});
+	};
+	const writeRecord = (target: string, value: unknown, path: Path): void => {
+		const record = recordAt(value, path);
+		if (record === undefined) {
+			return;
+		}
+		const fields = Object.hasOwn(table, target) ? table[target] : undefined;
+		each(record, path, false, (key, member, at) => {
+			const decoding = fields !== undefined && Object.hasOwn(fields, key) ? fields[key as string] : undefined;
+			if (typeof decoding === "object") {
+				relationWrite(decoding.relation, member, at);
+			}
+		});
+	};
+	const relationWrite = (target: string, value: unknown, path: Path): void => {
+		const directives = recordAt(value, path);
+		if (directives === undefined) {
+			return;
+		}
+		each(directives, path, false, (directive, operand, at) => {
+			const sites = Object.hasOwn(RECORD_SITES, directive) ? RECORD_SITES[directive as string] : undefined;
+			if (sites === undefined) {
+				return;
+			}
+			if (sites.length === 0) {
+				filter(operand, at);
+				return;
+			}
+			entries(operand, at, (entry, entryAt) => {
+				if (sites.includes(undefined)) {
+					writeRecord(target, entry, entryAt);
+					return;
+				}
+				const parts = recordAt(entry, entryAt);
+				if (parts !== undefined) {
+					each(parts, entryAt, true, (key, member, memberAt) => {
+						if (sites.includes(key as string)) {
+							writeRecord(target, member, memberAt);
+						} else if (member !== undefined) {
+							filter(member, memberAt);
+						} else if (key === "where") {
+							found.push({ path: memberAt, code: directive === "$update" ? "V1001" : "V1007" });
+						}
+					});
+				}
+			});
+		});
+	};
+
+	const root = recordAt(args, []);
+	if (root !== undefined) {
+		const writeKeys = writeKeysOf(family);
+		const whereCode: UnsentCode = variant === "unique" ? "V1007" : "V1001";
+		const cursorCode: UnsentCode = family === "find" && variant === "many" ? "V1009" : "V1001";
+		each(root, [], true, (key, value, at) => {
+			if (writeKeys.includes(key as string)) {
+				if (value !== undefined) {
+					entries(value, at, (entry, entryAt) => writeRecord(resource, entry, entryAt));
+				}
+			} else {
+				read(key, value, at, whereCode, cursorCode);
+			}
+		});
+	}
+	return found;
+}
+
 /** How encodeValue treats an object: a scalar's runtime class, a container, or neither. */
 function objectKind(value: object): "datetime" | "decimal" | "bytes" | "container" | "other" {
 	if (value instanceof Date) {
 		return "datetime";
 	}
-	if (value instanceof Decimal) {
+	if (value instanceof AvDecimal) {
 		return "decimal";
 	}
 	if (value instanceof Uint8Array) {
@@ -413,13 +630,13 @@ export type DecodeTable = {
  * table: 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
+ * 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.
+ * \`{ 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.
+ * @throws TypeError when a value is not the wire form its field's scalar takes,
+ *   which the transport answers as an AvTransportError.
  */
 export function decodeResult(table: DecodeTable, resource: string, value: unknown): unknown {
 	// A Resource the table does not name has nothing to revive: its data passes.
@@ -477,9 +694,9 @@ export function emitScalarCodecModule(style) {
         path: "runtime/codec.ts",
         source: codecModuleHead(moduleSpecifierWriter(style)) +
             "\n/** The built-in scalars of the protocol. */\n" +
-            `export type BuiltInScalar =\n${union};\n` +
+            `export type AvBuiltInScalar =\n${union};\n` +
             CODEC_MODULE_BODY +
-            "\nconst SCALAR_CODECS: { readonly [S in BuiltInScalar]: ScalarCodec } = {\n" +
+            "\nconst SCALAR_CODECS: { readonly [S in AvBuiltInScalar]: ScalarCodec } = {\n" +
             `${table}\n};\n`,
     };
 }

package/dist/emit/transaction.emitter.js

@@ -24,8 +24,8 @@ export interface FingerprintNode {
 }
 
 /**
- * The node's fingerprint, or null when its arguments are not canonical JSON — a
- * lone surrogate, a non-finite number — exactly when core cannot compute one
+ * The node's fingerprint, or null when its arguments are not canonical JSON (a
+ * lone surrogate, a non-finite number), exactly when core cannot compute one
  * either; the server then answers the operation itself.
  */
 export function fingerprintOf(node: FingerprintNode): string | null {
@@ -210,20 +210,20 @@ function base64Url(bytes: Uint8Array): string {
 `;
 function transactionModuleSource(from) {
     return `import { encodeArguments, readArgument, serializeWireBody } from ${from("./codec")};
-import { type Cause, type FrameworkError, frameworkErrorOf } from ${from("./errors")};
+import { type AvCause, type AvError, frameworkErrorOf } from ${from("./errors")};
 import { fingerprintOf } from ${from("./fingerprint")};
-import { type CallOptions, executePlan, type TransportConnection } from ${from("./transport")};
+import { type AvCallOptions, executePlan, refuseUnsentValues, type TransportConnection } from ${from("./transport")};
 
 /**
  * The deferred transaction builder and runner: \`avClient.tx\` defers an operation
- * into a handle — pure data, no request — and \`avClient.transaction\` binds a
+ * into a handle (pure data, no request), and \`avClient.transaction\` binds a
  * list of handles into one transaction plan, sends it once, and resolves one
  * result per handle in list order. A handle has no connection, so any client of
  * this generated tree may run it.
  */
 
 /**
- * What a handle defers — or why its arguments could not be read: the builder
+ * What a handle defers, or why its arguments could not be read: the builder
  * never throws into app code, and running the handle refuses it instead.
  */
 interface DeferredRecord {
@@ -331,7 +331,7 @@ function placeholderSites(args: unknown): readonly PlaceholderSite[] {
 /**
  * Defers one operation into a handle: nothing is sent, and nothing is thrown.
  * Its arguments are copied now, so a later change to the caller's data cannot
- * move a reference — and a handle can reference only handles built before it.
+ * move a reference, and a handle can reference only handles built before it.
  * Arguments that cannot be read are kept as their refusal, which running the
  * handle rejects with.
  */
@@ -360,8 +360,8 @@ export function deferOperation(resource: string, family: string, variant: string
 }
 
 /** What core answers in process for a plan entry it cannot run (A2004 / V1001). */
-function entryRefusal(operation: number, message: string): FrameworkError {
-	const cause: Cause = {
+function entryRefusal(operation: number, message: string): AvError {
+	const cause: AvCause = {
 		message: "Transaction plan failed framework validation.",
 		issues: [{ path: ["operations", operation], code: "V1001", message }],
 		operation,
@@ -369,19 +369,32 @@ function entryRefusal(operation: number, message: string): FrameworkError {
 	return frameworkErrorOf("A2004", cause);
 }
 
+/**
+ * The checks a plan's steps run before it is sent (the ClientContract's field
+ * validators, when it has any). Throws the AvError the server would answer.
+ */
+export type PlanCheck = (
+	steps: readonly { readonly resource: string; readonly family: string; readonly args: unknown }[],
+) => void;
+
 /**
  * Binds \`steps\` into the plan, sends it once, and resolves one decoded result per
  * step. Refused before anything is sent, with what core answers in
  * process: a list that is not one, an entry that is not a handle of this
- * generated client, one handle twice (ValidationError A2004 / V1001 at
- * ["operations", i]: the entry itself); a reference to a handle not in the list (ValidationError A2007 /
+ * generated client, one handle twice (AvValidationError A2004 / V1001 at
+ * ["operations", i]: the entry itself); a reference to a handle not in the list (AvValidationError A2007 /
  * V1010 at its \`$ref\`); a handle whose arguments could not be read when it was
- * built (the TypeError naming where).
+ * built (the TypeError naming where); a step holding an undefined value JSON would
+ * leave out to widen it (AvValidationError A2004, as refuseUnsentValues states it,
+ * the step named);
+ * and, when \`check\` is given, a step whose values break a field check
+ * (AvValidationError A2004, as the server answers it).
  */
 export async function runTransaction(
 	connection: TransportConnection,
 	steps: unknown,
-	options: CallOptions = {},
+	options: AvCallOptions = {},
+	check?: PlanCheck,
 ): Promise<unknown[]> {
 	if (!Array.isArray(steps)) {
 		throw frameworkErrorOf("A2004", {
@@ -421,11 +434,14 @@ export async function runTransaction(
 				});
 			}
 		}
+		refuseUnsentValues(record.resource, record.family, record.variant, record.args, ["operations", index, "args"], index);
 	}
 
+	check?.(records);
+
 	// Bound lazily: a node's references need their source's
 	// fingerprint, so each node is built once, on first need, wherever its source
-	// stands in the list — the server, not this client, refuses a later one.
+	// stands in the list. The server, not this client, refuses a later one.
 	const nodes = new Map<number, PlanNode>();
 	const nodeAt = (index: number): PlanNode => {
 		const built = nodes.get(index);

package/dist/generate.d.ts

@@ -3,7 +3,7 @@ import { type ProcessEnvInput } from "./config/env.cascade.js";
 import { type ContractFetch } from "./contract/contract.fetcher.js";
 import { type EmittedFilePath } from "./emit/emitted-tree.interface.js";
 import type { OutputCheck, TypeScriptResolver } from "./output/output.validator.js";
-export interface ClientGenerationInput {
+interface ClientGenerationInput {
     /** The project directory: where `framework.client.ts` and the `.env` files are. */
     readonly directory: string;
     /** A snapshot of the process environment. Never mutated. */
@@ -25,7 +25,7 @@ export interface ClientGenerationInput {
     readonly step?: GenerationStep;
 }
 /** Runs one phase of a generation under its title, resolving to what it returns. */
-export type GenerationStep = <T>(title: string, body: () => Promise<T> | T) => Promise<T>;
+type GenerationStep = <T>(title: string, body: () => Promise<T> | T) => Promise<T>;
 export interface ClientGenerated {
     readonly kind: "generated";
     /** The shared directory the client was generated into. */
@@ -73,9 +73,10 @@ export type ClientGenerationOutcome = ClientGenerated | ClientUpToDate | Foreign
  * generator did not produce stands in its way and `overrideForeign` is not set,
  * says what it is and writes nothing.
  *
- * @throws a refusal (`EnvFileError`, `ClientConfigError`, `ContractTransportError`,
- *   `ContractProtocolError`, `GeneratedNameError`, `OutputWriteError`) whose
+ * @throws a refusal (`AvEnvFileError`, `AvClientConfigError`, `AvContractTransportError`,
+ *   `AvContractProtocolError`, `AvGeneratedNameError`, `AvOutputWriteError`) whose
  *   message is the whole diagnosis; the previous output is intact. Anything else
  *   is a defect.
  */
 export declare function generateClient(input: ClientGenerationInput): Promise<ClientGenerationOutcome>;
+export {};

package/dist/generate.js

@@ -9,7 +9,7 @@ import { loadClientContractSince } from "./contract/contract.loader.js";
 import { emitClientTree } from "./emit/client-tree.emitter.js";
 import { parseContractCarrier } from "./emit/contract-carrier.emitter.js";
 import { CLIENT_ENTRY_FILE, CONTRACT_CARRIER_MODULE, GENERATED_DIRECTORY, } from "./emit/emitted-tree.interface.js";
-import { findForeignOutputContent, OutputWriteError, ownedOutputMatches, precedeDefect, writeClientOutput, } from "./output/output.writer.js";
+import { AvOutputWriteError, findForeignOutputContent, ownedOutputMatches, precedeDefect, writeClientOutput, } from "./output/output.writer.js";
 const runPhase = async (_title, body) => await body();
 async function storedContract(generateAt) {
     try {
@@ -51,7 +51,7 @@ export async function generateClient(input) {
         const emission = emitClientTree(contract, config.entrypoint, {
             importFileExtension: style.importFileExtension,
             moduleFormat: style.moduleFormat,
-        });
+        }, undefined, config.accessOrigins);
         return {
             emission,
             upToDate: notModified &&
@@ -87,7 +87,7 @@ export async function generateClient(input) {
     const into = path.relative(input.directory, config.generateAt) || ".";
     const write = (overrideForeign) => step(`Checking and writing the client into ${into}`, () => writeInto(overrideForeign));
     const foreign = await findForeignOutputContent(config.generateAt).catch((error) => {
-        throw error instanceof OutputWriteError
+        throw error instanceof AvOutputWriteError
             ? error.precededBy(emission.warnings)
             : precedeDefect(error, emission.warnings);
     });

package/dist/hydration/hydration-tag.format.d.ts

@@ -0,0 +1,11 @@
+/** The tagged form a dehydrated value takes: `{ [tagKey]: <tag>, [valueKey]: <wire form> }`. */
+export declare const HYDRATION_FORMAT: {
+    /** The key a tag is under. */
+    readonly tagKey: "$av";
+    /** The key the tagged value's wire form is under. */
+    readonly valueKey: "v";
+    /** The tag of a plain object that holds `tagKey` as data. */
+    readonly objectTag: "object";
+    /** The scalars a value is tagged as: those whose runtime values JSON does not carry. */
+    readonly scalarTags: readonly ["bigint", "bytes", "datetime", "decimal"];
+};

package/dist/hydration/hydration-tag.format.js

@@ -0,0 +1,6 @@
+export const HYDRATION_FORMAT = {
+    tagKey: "$av",
+    valueKey: "v",
+    objectTag: "object",
+    scalarTags: ["bigint", "bytes", "datetime", "decimal"],
+};

package/dist/index.d.ts

@@ -1,4 +1,4 @@
 /** The version of `@aventara/client`. */
 export declare const AVENTARA_CLIENT_GENERATOR_VERSION: string;
-export type { ClientConfigInput, ConfigValue, EnvReference, } from "./config/client-config.interface.js";
+export type { AvClientConfigInput, AvClientConfigValue, AvEnvReference, } from "./config/client-config.interface.js";
 export { defineClientConfig, env } from "./config/config.resolver.js";

package/dist/init/client-init.errors.d.ts

@@ -1,9 +1,9 @@
 /** `avclient init`'s refusals after the questions: each one sentence, exit 1. */
 /** Nobody confirmed replacing existing content. A refusal: nothing was touched. */
-export declare class ClientInitNotConfirmedError extends Error {
-    readonly name = "ClientInitNotConfirmedError";
+export declare class AvClientInitNotConfirmedError extends Error {
+    readonly name = "AvClientInitNotConfirmedError";
 }
 /** A step after the write failed. Reported with what to run; the files are kept. */
-export declare class ClientInitStepError extends Error {
-    readonly name = "ClientInitStepError";
+export declare class AvClientInitStepError extends Error {
+    readonly name = "AvClientInitStepError";
 }

package/dist/init/client-init.errors.js

@@ -1,6 +1,6 @@
-export class ClientInitNotConfirmedError extends Error {
-    name = "ClientInitNotConfirmedError";
+export class AvClientInitNotConfirmedError extends Error {
+    name = "AvClientInitNotConfirmedError";
 }
-export class ClientInitStepError extends Error {
-    name = "ClientInitStepError";
+export class AvClientInitStepError extends Error {
+    name = "AvClientInitStepError";
 }