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

package/dist/emit/field-check.emitter.js

@@ -0,0 +1,592 @@
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { canonicalizeJson } from "@aventara/core/internal";
+import { scanModuleSpecifiers } from "./module-specifier.scanner.js";
+import { moduleSpecifierWriter, } from "./module-style.interface.js";
+import { ownPropertyKey } from "./name.deriver.js";
+export const EVALUATOR_SOURCE = "src/runtime/field-check.evaluator.ts";
+const EVALUATOR_MODULE = "runtime/field-check.evaluator";
+export function publishedCoreEvaluator() {
+    const root = path.dirname(path.dirname(fileURLToPath(import.meta.resolve("@aventara/core"))));
+    return () => {
+        try {
+            return readFileSync(path.join(root, EVALUATOR_SOURCE), "utf8");
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                return undefined;
+            }
+            throw error;
+        }
+    };
+}
+function schemaHasChecks(schema) {
+    if (Array.isArray(schema)) {
+        return schema.some(schemaHasChecks);
+    }
+    if (typeof schema !== "object" || schema === null) {
+        return false;
+    }
+    const record = schema;
+    return ((Array.isArray(record.checks) && record.checks.length > 0) ||
+        Object.values(record).some(schemaHasChecks));
+}
+function fieldHasChecks(field) {
+    return (field?.kind === "scalar" &&
+        ((field.validators?.length ?? 0) > 0 ||
+            (field.json !== undefined && schemaHasChecks(field.json))));
+}
+export function contractHasFieldChecks(contract) {
+    return Object.values(contract.resources).some((resource) => Object.values(resource.fields).some(fieldHasChecks));
+}
+function codeUnitOrder(values) {
+    return [...values].sort((left, right) => left < right ? -1 : left > right ? 1 : 0);
+}
+export function emitFieldCheckModules(contract, style, derivation, read = publishedCoreEvaluator()) {
+    if (!contractHasFieldChecks(contract)) {
+        return [];
+    }
+    const from = moduleSpecifierWriter(style);
+    return [
+        {
+            path: "runtime/field-check.evaluator.ts",
+            source: copiedEvaluator(read, derivation, from),
+        },
+        {
+            path: "runtime/field-validators.ts",
+            source: fieldValidatorsSource(contract, from),
+        },
+    ];
+}
+function uncopiable(reason) {
+    return new Error(`@aventara/core's field check evaluator cannot be copied into the generated client: ${reason}.`);
+}
+const TYPE_IMPORT = /^import type \{[^}]*\} from (\S+);$/gm;
+function copiedEvaluator(read, derivation, from) {
+    const text = read();
+    if (text === undefined) {
+        throw uncopiable(`it does not publish ${EVALUATOR_SOURCE}`);
+    }
+    const scanned = scanModuleSpecifiers(text);
+    if (scanned.references) {
+        throw uncopiable("it carries a triple-slash reference");
+    }
+    const rewritten = [];
+    const copy = text.replace(TYPE_IMPORT, (statement, quoted) => {
+        let specifier;
+        try {
+            specifier = JSON.parse(quoted);
+        }
+        catch {
+            specifier = undefined;
+        }
+        if (typeof specifier !== "string") {
+            throw uncopiable(`it imports ${quoted}`);
+        }
+        rewritten.push(specifier);
+        const target = derivationTarget(specifier, derivation);
+        return statement.replace(quoted, from(target));
+    });
+    const expected = [...scanned.specifiers].sort();
+    if (rewritten.sort().join("\n") !== expected.join("\n")) {
+        throw uncopiable("it names a module other than through a type-only import, which the copy cannot carry");
+    }
+    return copy;
+}
+function derivationTarget(specifier, derivation) {
+    if (!(specifier.startsWith("./") || specifier.startsWith("../")) ||
+        !specifier.endsWith(".js")) {
+        throw uncopiable(`it imports ${JSON.stringify(specifier)}`);
+    }
+    const target = path.posix
+        .normalize(path.posix.join(path.posix.dirname(EVALUATOR_MODULE), specifier))
+        .replace(/\.js$/, "");
+    if (target.startsWith("../") ||
+        !derivation.has(`derivation/${target}.d.ts`)) {
+        throw uncopiable(`it imports ${JSON.stringify(specifier)}, whose declaration the generated client does not copy`);
+    }
+    return `../derivation/${target}`;
+}
+function fieldRulesSource(field) {
+    const members = [];
+    if ("scalar" in field.type) {
+        members.push(`scalar: ${JSON.stringify(field.type.scalar)}`);
+    }
+    members.push(`list: ${field.list === true}`);
+    if ((field.validators?.length ?? 0) > 0) {
+        members.push(`validators: ${canonicalizeJson(field.validators)}`);
+    }
+    if (field.json !== undefined) {
+        members.push(`json: ${canonicalizeJson(field.json)}`);
+    }
+    return `{ ${members.join(", ")} }`;
+}
+function rulesTableSource(contract) {
+    const rows = codeUnitOrder(Object.keys(contract.resources)).flatMap((resourceName) => {
+        const fields = contract.resources[resourceName]?.fields ?? {};
+        const entries = codeUnitOrder(Object.keys(fields)).flatMap((name) => {
+            const field = fields[name];
+            return field?.kind === "scalar" &&
+                ((field.validators?.length ?? 0) > 0 || field.json !== undefined)
+                ? [`\t\t${ownPropertyKey(name)}: ${fieldRulesSource(field)},\n`]
+                : [];
+        });
+        return entries.length === 0
+            ? []
+            : [`\t${ownPropertyKey(resourceName)}: {\n${entries.join("")}\t},\n`];
+    });
+    return `{${rows.length === 0 ? "" : `\n${rows.join("")}`}}`;
+}
+function fieldValidatorsSource(contract, from) {
+    return `import type { AvFieldCheck } from ${from("../derivation/contracts/field-check")};
+import type { JsonSchema } from ${from("../derivation/contracts/json-shape")};
+import { RECORD_SITES, writeKeysOf } from ${from("./codec")};
+import { DECODE_TABLE } from ${from("./descriptor")};
+import { type AvCause, type AvValidationIssue, frameworkErrorOf } from ${from("./errors")};
+import {
+	entryCheckIssues,
+	FIELD_CHECK_SUBJECTS,
+	type FieldCheckSubject,
+	fieldCheckIssue,
+	fieldCheckIssues,
+	passesFieldCheck,
+} from ${from("./field-check.evaluator")};
+
+/**
+ * The field validators of this client's ClientContract, run before a request is
+ * sent: a field's validators, and the checks of a shaped Json field's shape. A
+ * call whose values break one is refused with the AvValidationError the server
+ * would answer (A2004, with the same issues: each one's code, path, check,
+ * params and message), and nothing is sent. The server checks every value again.
+ *
+ * The client checks a value as the caller wrote it; the server checks it after
+ * its field pipes, so a field pipe that normalizes a value (trims it,
+ * lower-cases it) must not turn a value this client accepted into one the server
+ * refuses. A $ref value in a transaction is the server's to check, when it is
+ * resolved at its step. A value that does not match its Json Shape is left to the
+ * server too, which answers it with issues of its own.
+ */
+
+/** One field's rules: its validators and, for a shaped Json field, its shape. */
+interface FieldRules {
+	/** The field's scalar type; absent for an enum. */
+	readonly scalar?: string;
+	readonly list: boolean;
+	readonly validators?: readonly AvFieldCheck[];
+	readonly json?: JsonSchema;
+}
+
+/** Per Resource, the fields with validators or a Json Shape. */
+const FIELD_RULES: {
+	readonly [resource: string]: { readonly [field: string]: FieldRules };
+} = ${rulesTableSource(contract)};
+${FIELD_VALIDATORS_RUNTIME}`;
+}
+const FIELD_VALIDATORS_RUNTIME = `
+type Path = readonly (string | number)[];
+
+/** What a refusal of an operation's arguments says. */
+const REFUSAL_MESSAGE = "Operation arguments failed framework validation.";
+
+/** Thrown inside a walk when the server would answer with issues this client does not compute. */
+const UNDECIDED: object = Object.freeze({});
+
+/** One step of a transaction plan, as the plan's checks read it. */
+export interface CheckedStep {
+	readonly resource: string;
+	readonly family: string;
+	readonly args: unknown;
+}
+
+/**
+ * Refuses an operation whose arguments break the Contract's field checks, with
+ * the AvValidationError (A2004) the server would answer; returns when they
+ * break none, or when the server is the one to judge them.
+ */
+export function checkOperation(resource: string, family: string, args: unknown): void {
+	const issues = decided(() => validatorIssues(resource, family, args, ["arguments"]));
+	if (issues !== undefined && issues.length > 0) {
+		throw frameworkErrorOf("A2004", refusal(issues));
+	}
+}
+
+/**
+ * Refuses a transaction plan one of whose steps breaks the Contract's field
+ * checks, as the server would before the transaction opens: step by step, the
+ * first failing step named.
+ */
+export function checkPlan(steps: readonly CheckedStep[]): void {
+	const failed = decided(() => {
+		for (const [index, step] of steps.entries()) {
+			const issues = validatorIssues(step.resource, step.family, step.args, ["operations", index, "args"]);
+			if (issues.length > 0) {
+				return { operation: index, issues };
+			}
+		}
+		return undefined;
+	});
+	if (failed !== undefined) {
+		throw frameworkErrorOf("A2004", refusal(failed.issues, failed.operation));
+	}
+}
+
+/** The walk's verdict, or undefined when it cannot decide or cannot read the arguments. */
+function decided<T>(walk: () => T): T | undefined {
+	try {
+		return walk();
+	} catch {
+		return undefined;
+	}
+}
+
+function refusal(issues: readonly AvValidationIssue[], operation?: number): AvCause {
+	const frozen = Object.freeze(issues.map(frozenIssue));
+	return Object.freeze(
+		operation === undefined
+			? { message: REFUSAL_MESSAGE, issues: frozen }
+			: { message: REFUSAL_MESSAGE, issues: frozen, operation },
+	);
+}
+
+function frozenIssue(issue: AvValidationIssue): AvValidationIssue {
+	return deepFreeze({ ...issue, path: [...(issue.path ?? [])] });
+}
+
+function deepFreeze<T>(value: T): T {
+	if (typeof value === "object" && value !== null) {
+		for (const member of Object.values(value)) {
+			deepFreeze(member);
+		}
+		Object.freeze(value);
+	}
+	return value;
+}
+
+function isPlainRecord(value: unknown): value is Readonly<Record<string, unknown>> {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) {
+		return false;
+	}
+	const prototype: unknown = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+}
+
+function own<T>(record: { readonly [key: string]: T } | undefined, key: string): T | undefined {
+	return record !== undefined && Object.hasOwn(record, key) ? record[key] : undefined;
+}
+
+/** A mutation directive ({ $increment: 1 }), or a transaction reference ({ $ref: … }). */
+function isDirective(value: unknown): value is Readonly<Record<string, unknown>> {
+	return isPlainRecord(value) && Object.keys(value).some((key) => key.startsWith("$"));
+}
+
+/** What a relation field of a Resource reaches: its target, and whether it is to-many. */
+function relationOf(resource: string, field: string): { readonly target: string; readonly many: boolean } | undefined {
+	const decoding = own(own(DECODE_TABLE, resource), field);
+	return typeof decoding === "object" ? { target: decoding.relation, many: decoding.many } : undefined;
+}
+
+function valueAt(args: unknown, path: Path): unknown {
+	let current = args;
+	for (const key of path) {
+		if (Array.isArray(current) && typeof key === "number") {
+			current = current[key];
+		} else if (isPlainRecord(current) && typeof key === "string" && Object.hasOwn(current, key)) {
+			current = current[key];
+		} else {
+			return undefined;
+		}
+	}
+	return current;
+}
+
+// ---- Json Shapes: a shaped field's shape is one of its validators ----
+
+/**
+ * One value against a shape: aborted (the server reports a type, value or
+ * missing key there), soft (a key the shape does not hold, or an integer outside
+ * the safe range: reported, but the value's checks still run), or ok; with the
+ * failed checks' issues, at paths inside the value.
+ */
+interface Judged {
+	readonly state: "aborted" | "soft" | "ok";
+	readonly issues: readonly AvValidationIssue[];
+}
+
+const ABORTED: Judged = { state: "aborted", issues: [] };
+const PASSED: Judged = { state: "ok", issues: [] };
+
+function combined(results: readonly Judged[]): Judged {
+	const state = results.some((result) => result.state === "aborted")
+		? "aborted"
+		: results.some((result) => result.state === "soft")
+			? "soft"
+			: "ok";
+	return { state, issues: results.flatMap((result) => result.issues) };
+}
+
+function checked(
+	judged: Judged,
+	checks: readonly AvFieldCheck[] | undefined,
+	value: unknown,
+	subject: FieldCheckSubject,
+	path: Path,
+): Judged {
+	if (judged.state === "aborted" || checks === undefined) {
+		return judged;
+	}
+	const issues = checks
+		.filter((check) => !passesFieldCheck(check, value, subject))
+		.map((check) => fieldCheckIssue(check, subject, path));
+	return { state: judged.state, issues: [...judged.issues, ...issues] };
+}
+
+function judge(schema: JsonSchema, value: unknown, path: Path): Judged {
+	if ("const" in schema) {
+		return value === schema.const ? PASSED : ABORTED;
+	}
+	if ("enum" in schema) {
+		return typeof value === "string" && schema.enum.some((member) => member === value) ? PASSED : ABORTED;
+	}
+	if ("anyOf" in schema) {
+		return union(schema.anyOf, value, path);
+	}
+	if ("oneOf" in schema) {
+		return union(schema.oneOf, value, path);
+	}
+	switch (schema.type) {
+		case "null":
+			return value === null ? PASSED : ABORTED;
+		case "boolean":
+			return typeof value === "boolean" ? PASSED : ABORTED;
+		case "string":
+			return typeof value === "string" ? checked(PASSED, schema.checks, value, "string", path) : ABORTED;
+		case "number":
+			return typeof value === "number" && Number.isFinite(value)
+				? checked(PASSED, schema.checks, value, "number", path)
+				: ABORTED;
+		case "integer":
+			if (typeof value !== "number" || !Number.isInteger(value)) {
+				return ABORTED;
+			}
+			return checked(
+				Number.isSafeInteger(value) ? PASSED : { state: "soft", issues: [] },
+				schema.checks,
+				value,
+				"number",
+				path,
+			);
+		case "array": {
+			if (!Array.isArray(value)) {
+				return ABORTED;
+			}
+			const list: readonly unknown[] = value;
+			if ("prefixItems" in schema) {
+				const items = schema.prefixItems;
+				return list.length === items.length
+					? combined(items.map((item, index) => judge(item, list[index], [...path, index])))
+					: ABORTED;
+			}
+			const item = schema.items;
+			const entries = combined(list.map((entry, index) => judge(item, entry, [...path, index])));
+			return checked(entries, schema.checks, list, "number", path);
+		}
+	}
+	if (!isPlainRecord(value)) {
+		return ABORTED;
+	}
+	const record = value;
+	const present = (key: string): boolean => Object.hasOwn(record, key) && record[key] !== undefined;
+	if (!("properties" in schema)) {
+		const member = schema.additionalProperties;
+		return combined(
+			Object.keys(record)
+				.filter(present)
+				.map((key) => judge(member, record[key], [...path, key])),
+		);
+	}
+	const properties = schema.properties;
+	const required: readonly string[] = schema.required ?? [];
+	const results = Object.keys(properties).map((key): Judged => {
+		const property = properties[key];
+		if (property === undefined) {
+			return PASSED;
+		}
+		if (!present(key)) {
+			return required.includes(key) ? ABORTED : PASSED;
+		}
+		return judge(property, record[key], [...path, key]);
+	});
+	const unknown = Object.keys(record).some((key) => present(key) && !Object.hasOwn(properties, key));
+	return combined(unknown ? [...results, { state: "soft", issues: [] }] : results);
+}
+
+/** A union, as Zod settles one: the option that passes, else the one option not aborted. */
+function union(options: readonly JsonSchema[], value: unknown, path: Path): Judged {
+	const results = options.map((option) => judge(option, value, path));
+	if (results.some((result) => result.state === "ok" && result.issues.length === 0)) {
+		return PASSED;
+	}
+	const live = results.filter((result) => result.state !== "aborted");
+	return live.length === 1 ? (live[0] as Judged) : ABORTED;
+}
+
+/** One written value's shape issues; undecided when the server would report others. */
+function valueShapeIssues(schema: JsonSchema, value: unknown, path: Path, issues: AvValidationIssue[]): void {
+	if (value === null || value === undefined) {
+		return;
+	}
+	const judged = judge(schema, value, path);
+	if (judged.state !== "ok") {
+		throw UNDECIDED;
+	}
+	issues.push(...judged.issues);
+}
+
+/** A shaped field's whole value: each entry of a list field, else the value. */
+function shapedValueIssues(schema: JsonSchema, list: boolean, value: unknown, path: Path, issues: AvValidationIssue[]): void {
+	if (list && value !== null && value !== undefined) {
+		if (!Array.isArray(value)) {
+			throw UNDECIDED;
+		}
+		value.forEach((entry: unknown, index) => valueShapeIssues(schema, entry, [...path, index], issues));
+		return;
+	}
+	valueShapeIssues(schema, value, path, issues);
+}
+
+// ---- field validators, judged as the server judges them after its field pipes ----
+
+/** The top-level data records of a create, update or upsert. */
+function writeRecordPaths(family: string, args: unknown): Path[] {
+	const keys = writeKeysOf(family);
+	const records: Path[] = [];
+	if (!isPlainRecord(args)) {
+		return records;
+	}
+	for (const key of keys) {
+		if (!Object.hasOwn(args, key)) {
+			continue;
+		}
+		const value = args[key];
+		if (Array.isArray(value)) {
+			value.forEach((entry: unknown, index) => {
+				if (isPlainRecord(entry)) {
+					records.push([key, index]);
+				}
+			});
+		} else if (isPlainRecord(value)) {
+			records.push([key]);
+		}
+	}
+	return records;
+}
+
+/** Each nested write's target and its records, depth first in data order. */
+function nestedTargets(
+	args: unknown,
+	resource: string,
+	path: Path,
+	targets: { readonly resource: string; readonly records: readonly Path[] }[],
+): void {
+	const record = valueAt(args, path);
+	if (!isPlainRecord(record)) {
+		return;
+	}
+	for (const [key, value] of Object.entries(record)) {
+		const relation = relationOf(resource, key);
+		if (relation === undefined || !isPlainRecord(value)) {
+			continue;
+		}
+		for (const [directive, operand] of Object.entries(value)) {
+			const sites = own(RECORD_SITES, directive);
+			if (sites === undefined) {
+				continue;
+			}
+			const entries: readonly Path[] =
+				directive !== "$set" && Array.isArray(operand) ? operand.map((_entry: unknown, index) => [index]) : [[]];
+			for (const entry of entries) {
+				const entryPath = [...path, key, directive, ...entry];
+				const records = sites
+					.map((site) => (site === undefined ? entryPath : [...entryPath, site]))
+					.filter((site) => isPlainRecord(valueAt(args, site)));
+				targets.push({ resource: relation.target, records });
+				for (const site of records) {
+					nestedTargets(args, relation.target, site, targets);
+				}
+			}
+		}
+	}
+}
+
+function recordValidatorIssues(
+	resource: string,
+	records: readonly Path[],
+	args: unknown,
+	at: Path,
+	issues: AvValidationIssue[],
+): void {
+	const fields = own(FIELD_RULES, resource);
+	for (const path of records) {
+		const record = valueAt(args, path);
+		if (!isPlainRecord(record)) {
+			continue;
+		}
+		for (const name of Object.keys(record)) {
+			const rules = own(fields, name);
+			const json = rules?.json;
+			const validators = rules?.validators;
+			if (rules === undefined || (json === undefined && validators === undefined)) {
+				continue;
+			}
+			const value = record[name];
+			const fieldPath = [...at, ...path, name];
+			const subject = own(FIELD_CHECK_SUBJECTS, rules.scalar ?? "") ?? "string";
+			if (!isDirective(value)) {
+				if (json !== undefined) {
+					shapedValueIssues(json, rules.list, value, fieldPath, issues);
+				} else if (validators !== undefined) {
+					issues.push(...fieldCheckIssues(validators, value, subject, fieldPath, rules.list));
+				}
+				continue;
+			}
+			if (!rules.list || !Object.hasOwn(value, "$push")) {
+				continue;
+			}
+			const operand = value["$push"];
+			const pushed: readonly { readonly entry: unknown; readonly path: Path }[] = Array.isArray(operand)
+				? operand.map((entry: unknown, index) => ({ entry, path: [...fieldPath, "$push", index] }))
+				: [{ entry: operand, path: [...fieldPath, "$push"] }];
+			for (const { entry, path: entryPath } of pushed) {
+				if (isDirective(entry)) {
+					continue;
+				}
+				if (json !== undefined) {
+					valueShapeIssues(json, entry, entryPath, issues);
+				} else if (validators !== undefined) {
+					issues.push(...entryCheckIssues(validators, entry, subject, entryPath));
+				}
+			}
+		}
+	}
+}
+
+/**
+ * Every validator issue in an operation's write data, a shaped Json field's
+ * shape among them, in the order the call wrote each record's fields: its own
+ * records first, then each nested target's.
+ */
+function validatorIssues(resource: string, family: string, args: unknown, at: Path): AvValidationIssue[] {
+	const issues: AvValidationIssue[] = [];
+	const records = writeRecordPaths(family, args);
+	recordValidatorIssues(resource, records, args, at, issues);
+	const targets: { readonly resource: string; readonly records: readonly Path[] }[] = [];
+	for (const path of records) {
+		nestedTargets(args, resource, path, targets);
+	}
+	for (const target of targets) {
+		recordValidatorIssues(target.resource, target.records, args, at, issues);
+	}
+	return issues;
+}
+`;

package/dist/emit/json-shape.emitter.d.ts

@@ -1,4 +1,4 @@
-import type { ClientContract } from "@aventara/core";
+import type { AvContractClient } from "@aventara/core";
 type Schema = Readonly<Record<string, unknown>>;
 /**
  * The TypeScript type a Json Shape schema describes, as source text.
@@ -12,5 +12,5 @@ export declare function jsonSchemaType(schema: Schema): string;
  * contract shapes a Json field — the carrier with each shaped field's type — or
  * `undefined` when it shapes none.
  */
-export declare function shapedContractType(contract: ClientContract): string | undefined;
+export declare function shapedContractType(contract: AvContractClient): string | undefined;
 export {};

package/dist/emit/name.deriver.d.ts

@@ -1,11 +1,11 @@
-import type { ClientContract, OperationFamily } from "@aventara/core";
+import type { AvContractClient, AvOperationFamily } from "@aventara/core";
 /**
  * Name derivation and the rename ladder for the emitted tree.
  */
 export declare const RESERVED_EMITTED_NAMES: readonly string[];
 export interface ResourceNamedType {
     readonly suffix: string;
-    readonly family: OperationFamily;
+    readonly family: AvOperationFamily;
     readonly variant: string;
     /** The argument it names; absent for `X`, the default record. */
     readonly argument?: "where" | "orderBy" | "data" | "select" | "include";
@@ -43,12 +43,12 @@ export declare function isIdentifierName(text: string): boolean;
  * The emitted names of a Contract's enums and Resources, renamed where a name
  * cannot be declared as-is.
  *
- * @throws GeneratedNameError naming every name no rung of its ladder can repair.
+ * @throws AvGeneratedNameError naming every name no rung of its ladder can repair.
  */
-export declare function deriveEmittedNames(contract: Pick<ClientContract, "enums" | "resources">): EmittedNames;
+export declare function deriveEmittedNames(contract: Pick<AvContractClient, "enums" | "resources">): EmittedNames;
 /** The refusal that stops generation over names no rename can repair. */
-export declare class GeneratedNameError extends Error {
-    readonly name = "GeneratedNameError";
+export declare class AvGeneratedNameError extends Error {
+    readonly name = "AvGeneratedNameError";
     constructor(problems: readonly string[]);
 }
 export declare function ownPropertyKey(value: string): string;

package/dist/emit/name.deriver.js

@@ -4,19 +4,19 @@ export const RESERVED_EMITTED_NAMES = [
     ...new Set([
         "AvClient",
         "AvClientOptions",
-        "CallOptions",
-        "Cause",
-        "Decimal",
-        "Fetch",
-        "FrameworkError",
-        "NotFoundError",
-        "Operation",
-        "OperationCode",
+        "AvCallOptions",
+        "AvCause",
+        "AvDecimal",
+        "AvFetch",
+        "AvError",
+        "AvNotFoundError",
+        "AvOperation",
+        "AvOperationCode",
         "ResourceArgument",
         "ResourceRecord",
-        "TransportError",
-        "ValidationCode",
-        "ValidationIssue",
+        "AvTransportError",
+        "AvValidationCode",
+        "AvValidationIssue",
         "avClient",
         ...FRAMEWORK_ERROR_CLASS_NAMES,
     ]),
@@ -214,7 +214,7 @@ export function deriveEmittedNames(contract) {
     const enums = enumNames.map((name) => resolve("enum", name));
     const properties = resourceProperties(resourceNames, warnings, refusals);
     if (refusals.length > 0) {
-        throw new GeneratedNameError(byName(refusals));
+        throw new AvGeneratedNameError(byName(refusals));
     }
     return { enums, resources, properties, warnings: byName(warnings) };
 }
@@ -262,8 +262,8 @@ function byName(lines) {
 function compareCodeUnits(left, right) {
     return left < right ? -1 : left > right ? 1 : 0;
 }
-export class GeneratedNameError extends Error {
-    name = "GeneratedNameError";
+export class AvGeneratedNameError extends Error {
+    name = "AvGeneratedNameError";
     constructor(problems) {
         super(`the ClientContract's names cannot all be emitted: ${problems.join("; ")}. ` +
             `Rename ${problems.length === 1 ? "it" : "them"} on the server, then generate again.`);

package/dist/emit/named-type.emitter.d.ts

@@ -1,5 +1,5 @@
-import type { ClientContract } from "@aventara/core";
+import type { AvContractClient } from "@aventara/core";
 import type { EmittedModule } from "./emitted-tree.interface.js";
 import { type ClientModuleStyle } from "./module-style.interface.js";
 import { type EmittedNames } from "./name.deriver.js";
-export declare function emitNamedTypesModule(contract: ClientContract, names: EmittedNames, style: ClientModuleStyle): EmittedModule;
+export declare function emitNamedTypesModule(contract: AvContractClient, names: EmittedNames, style: ClientModuleStyle): EmittedModule;