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

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";
@@ -288,7 +288,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 +296,21 @@ 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), 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 +321,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 +333,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 {
@@ -352,7 +352,7 @@ function objectKind(value: object): "datetime" | "decimal" | "bytes" | "containe
 	if (value instanceof Date) {
 		return "datetime";
 	}
-	if (value instanceof Decimal) {
+	if (value instanceof AvDecimal) {
 		return "decimal";
 	}
 	if (value instanceof Uint8Array) {
@@ -413,13 +413,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 +477,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, 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,29 @@ 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); 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", {
@@ -423,9 +433,11 @@ export async function runTransaction(
 		}
 	}
 
+	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

@@ -73,8 +73,8 @@ 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.
  */

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 {
@@ -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/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";
 }

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

@@ -4,9 +4,9 @@ import { GENERATION_STEPS, runGenerate, } from "../cli/generate.command.js";
 import { createStepReporter } from "../cli/step.reporter.js";
 import { CLIENT_CONFIG_FILE } from "../config/config.loader.js";
 import { resolveModuleStyle } from "../config/module-style.resolver.js";
-import { ContractTransportError } from "../contract/contract.fetcher.js";
+import { AvContractTransportError } from "../contract/contract.fetcher.js";
 import { CLIENT_ENTRY_FILE } from "../emit/emitted-tree.interface.js";
-import { ClientInitNotConfirmedError, ClientInitStepError, } from "./client-init.errors.js";
+import { AvClientInitNotConfirmedError, AvClientInitStepError, } from "./client-init.errors.js";
 import { GENERATE_SCRIPT, planClientInit } from "./client-init.planner.js";
 import { resolveClientInitAnswers } from "./client-init.questions.js";
 import { inspectClientProject } from "./client-project.inspector.js";
@@ -40,11 +40,11 @@ export async function runClientInit(command, io) {
         const them = plan.conflicts.length === 1 ? "it" : "them";
         const has = plan.conflicts.length === 1 ? "has" : "have";
         if (!io.interactive) {
-            throw new ClientInitNotConfirmedError(`not initializing, and nothing was touched: ${plan.conflicts.join(", ")} already ${has} other content and nobody can be asked (stdin is not a terminal); run \`avclient init --yes\` to replace ${them}.`);
+            throw new AvClientInitNotConfirmedError(`not initializing, and nothing was touched: ${plan.conflicts.join(", ")} already ${has} other content and nobody can be asked (stdin is not a terminal); run \`avclient init --yes\` to replace ${them}.`);
         }
         io.stderr(`avclient: warning: ${plan.conflicts.join(", ")} already ${has} other content, and initializing will replace ${them}.\n`);
         if (!(await io.confirm("avclient: replace them and initialize? [y/N] "))) {
-            throw new ClientInitNotConfirmedError(`cancelled, and nothing was touched; run again and answer yes to replace ${them}.`);
+            throw new AvClientInitNotConfirmedError(`cancelled, and nothing was touched; run again and answer yes to replace ${them}.`);
         }
     }
     const writes = plan.conflicts.length === 0 ? plan.keeping : plan.replacing;
@@ -80,7 +80,7 @@ export async function runClientInit(command, io) {
             onOutput: progress.output,
         });
         if (installed.code !== 0) {
-            throw new ClientInitStepError(`\`${install}\` exited with code ${installed.code} after ${project.configFile ?? CLIENT_CONFIG_FILE} was written; fix what it reports and run \`${install}\` again:\n${installed.stderr.trimEnd()}`);
+            throw new AvClientInitStepError(`\`${install}\` exited with code ${installed.code} after ${project.configFile ?? CLIENT_CONFIG_FILE} was written; fix what it reports and run \`${install}\` again:\n${installed.stderr.trimEnd()}`);
         }
     });
     if (command.skipGenerate) {
@@ -92,8 +92,8 @@ export async function runClientInit(command, io) {
         return await runGenerate(io, command.yes, progress);
     }
     catch (error) {
-        if (error instanceof ContractTransportError) {
-            throw new ClientInitStepError(`the project is set up, but the server did not answer (${error.message.replace(/\.$/, "")}); once it is running, run \`avclient generate\`.`);
+        if (error instanceof AvContractTransportError) {
+            throw new AvClientInitStepError(`the project is set up, but the server did not answer (${error.message.replace(/\.$/, "")}); once it is running, run \`avclient generate\`.`);
         }
         throw error;
     }

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

@@ -8,12 +8,12 @@ export type ClientInitAnswers = {
 };
 type QuestionId = "entrypoint" | "envVar" | "generateAt" | "packageManager";
 /** An answer the question cannot take. A refusal: one sentence. */
-export declare class ClientInitAnswerError extends Error {
-    readonly name = "ClientInitAnswerError";
+export declare class AvClientInitAnswerError extends Error {
+    readonly name = "AvClientInitAnswerError";
 }
 /** Nobody can answer and some questions are unanswered. A refusal: one sentence. */
-export declare class ClientInitUnansweredError extends Error {
-    readonly name = "ClientInitUnansweredError";
+export declare class AvClientInitUnansweredError extends Error {
+    readonly name = "AvClientInitUnansweredError";
 }
 export type ClientInitQuestion = {
     readonly id: QuestionId;
@@ -21,7 +21,7 @@ export type ClientInitQuestion = {
     readonly placeholder: string;
     readonly label: string;
     readonly defaultFor: (detectedPackageManager: PackageManager) => string;
-    /** @throws ClientInitAnswerError */
+    /** @throws AvClientInitAnswerError */
     readonly parse: (raw: string) => string;
 };
 export declare const DEFAULT_ENV_VAR = "AVENTARA_API_URL";

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

@@ -1,10 +1,10 @@
 import { resolveEntrypoint } from "../config/config.resolver.js";
 export const PACKAGE_MANAGERS = ["npm", "pnpm"];
-export class ClientInitAnswerError extends Error {
-    name = "ClientInitAnswerError";
+export class AvClientInitAnswerError extends Error {
+    name = "AvClientInitAnswerError";
 }
-export class ClientInitUnansweredError extends Error {
-    name = "ClientInitUnansweredError";
+export class AvClientInitUnansweredError extends Error {
+    name = "AvClientInitUnansweredError";
 }
 export const DEFAULT_ENV_VAR = "AVENTARA_API_URL";
 export const CLIENT_INIT_QUESTIONS = [
@@ -19,7 +19,7 @@ export const CLIENT_INIT_QUESTIONS = [
                 resolveEntrypoint(raw.trim());
             }
             catch (error) {
-                throw new ClientInitAnswerError(error.message.replace(/\.$/, ""));
+                throw new AvClientInitAnswerError(error.message.replace(/\.$/, ""));
             }
             return raw.trim();
         },
@@ -33,7 +33,7 @@ export const CLIENT_INIT_QUESTIONS = [
         parse: (raw) => {
             const name = raw.trim();
             if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(name)) {
-                throw new ClientInitAnswerError(`${JSON.stringify(raw)} is not an environment variable name.`);
+                throw new AvClientInitAnswerError(`${JSON.stringify(raw)} is not an environment variable name.`);
             }
             return name;
         },
@@ -47,7 +47,7 @@ export const CLIENT_INIT_QUESTIONS = [
         parse: (raw) => {
             const directory = raw.trim();
             if (directory === "") {
-                throw new ClientInitAnswerError("--generate-at takes a directory.");
+                throw new AvClientInitAnswerError("--generate-at takes a directory.");
             }
             return directory;
         },
@@ -61,7 +61,7 @@ export const CLIENT_INIT_QUESTIONS = [
         parse: (raw) => {
             const manager = PACKAGE_MANAGERS.find((candidate) => candidate === raw.trim());
             if (manager === undefined) {
-                throw new ClientInitAnswerError(`${JSON.stringify(raw)} is not a supported package manager; choose ${PACKAGE_MANAGERS.join(" or ")}.`);
+                throw new AvClientInitAnswerError(`${JSON.stringify(raw)} is not a supported package manager; choose ${PACKAGE_MANAGERS.join(" or ")}.`);
             }
             return manager;
         },
@@ -90,7 +90,7 @@ export async function resolveClientInitAnswers(sources) {
                     break;
                 }
                 catch (error) {
-                    if (!(error instanceof ClientInitAnswerError)) {
+                    if (!(error instanceof AvClientInitAnswerError)) {
                         throw error;
                     }
                     sources.say(error.message);
@@ -102,7 +102,7 @@ export async function resolveClientInitAnswers(sources) {
         }
     }
     if (missing.length > 0) {
-        throw new ClientInitUnansweredError(`stdin is not a terminal, so nothing can be asked: pass ${missing.join(", ")}, or pass --yes to accept their defaults.`);
+        throw new AvClientInitUnansweredError(`stdin is not a terminal, so nothing can be asked: pass ${missing.join(", ")}, or pass --yes to accept their defaults.`);
     }
     return {
         entrypoint: answered.entrypoint,

package/dist/init/client-project.inspector.d.ts

@@ -1,8 +1,8 @@
 import type { PackageManager } from "./client-init.questions.js";
 /** The frontend `avclient init` serves, read before anything is asked or written. */
 /** The directory is not a project `avclient init` can set up. A refusal: nothing written. */
-export declare class ClientProjectRefusedError extends Error {
-    readonly name = "ClientProjectRefusedError";
+export declare class AvClientProjectRefusedError extends Error {
+    readonly name = "AvClientProjectRefusedError";
 }
 export type ClientProject = {
     readonly directory: string;

package/dist/init/client-project.inspector.js

@@ -1,13 +1,13 @@
 import { existsSync, readFileSync } from "node:fs";
 import path from "node:path";
 import { findClientConfigFile } from "../config/config.loader.js";
-export class ClientProjectRefusedError extends Error {
-    name = "ClientProjectRefusedError";
+export class AvClientProjectRefusedError extends Error {
+    name = "AvClientProjectRefusedError";
 }
 export function inspectClientProject(directory) {
     const manifest = path.join(directory, "package.json");
     if (!existsSync(manifest)) {
-        throw new ClientProjectRefusedError("avclient init runs in a frontend project: no package.json here; create one first.");
+        throw new AvClientProjectRefusedError("avclient init runs in a frontend project: no package.json here; create one first.");
     }
     const lockfiles = [
         ["package-lock.json", "npm"],

package/dist/output/output.writer.d.ts

@@ -5,9 +5,9 @@ import { type OutputCheck, type TypeScriptResolver } from "./output.validator.js
 /** The four stages a write passes through, in order. */
 export type OutputWriteStage = "prepare" | "temp" | "validate" | "replace";
 /** A write that stopped; the previous output is intact unless it says otherwise. */
-export declare class OutputWriteError extends Error {
+export declare class AvOutputWriteError extends Error {
     readonly stage: OutputWriteStage;
-    readonly name = "OutputWriteError";
+    readonly name = "AvOutputWriteError";
     /**
      * What the run said before it stopped, in the order a success returns its
      * warnings: the emission's, the validator's, the writer's. Printed before the
@@ -19,7 +19,7 @@ export declare class OutputWriteError extends Error {
         readonly warnings?: readonly string[];
     });
     /** The same refusal, with `earlier` said before the warnings it already carries. */
-    precededBy(earlier: readonly string[]): OutputWriteError;
+    precededBy(earlier: readonly string[]): AvOutputWriteError;
 }
 /**
  * Records `earlier` as said before `defect`, ahead of anything already recorded,
@@ -49,11 +49,11 @@ export interface ClientOutputWritten {
  * Writes `emission.tree` as `<generateAt>/AvClient.ts` and
  * `<generateAt>/generated/`.
  *
- * @throws OutputWriteError when the write stops; the previous output is intact.
+ * @throws AvOutputWriteError when the write stops; the previous output is intact.
  */
 export declare function writeClientOutput(input: ClientOutputWriteInput): Promise<ClientOutputWritten>;
 /**
- * @throws OutputWriteError when `generateAt` is not a directory, `generated` is
+ * @throws AvOutputWriteError when `generateAt` is not a directory, `generated` is
  *   not a directory or an entry file is not a file: no confirmation repairs that.
  */
 export declare function findForeignOutputContent(generateAt: AbsolutePath, fileSystem?: OutputFileSystem): Promise<readonly string[]>;

package/dist/output/output.writer.js

@@ -4,9 +4,9 @@ import path from "node:path";
 import { carriesGeneratedOwnership, GENERATED_OWNERSHIP_HEAD_BYTES, } from "../emit/banner.emitter.js";
 import { CLIENT_ENTRY_FILES, GENERATED_DIRECTORY, LEGACY_CLIENT_ENTRY_FILES, } from "../emit/emitted-tree.interface.js";
 import { projectTypeScriptResolver, validateOutputTree, } from "./output.validator.js";
-export class OutputWriteError extends Error {
+export class AvOutputWriteError extends Error {
     stage;
-    name = "OutputWriteError";
+    name = "AvOutputWriteError";
     warnings;
     constructor(stage, message, options) {
         super(message, options);
@@ -14,7 +14,7 @@ export class OutputWriteError extends Error {
         this.warnings = options?.warnings ?? [];
     }
     precededBy(earlier) {
-        return new OutputWriteError(this.stage, this.message, {
+        return new AvOutputWriteError(this.stage, this.message, {
             cause: this.cause,
             warnings: [...earlier, ...this.warnings],
         });
@@ -65,7 +65,7 @@ export async function writeClientOutput(input) {
             ...validationWarnings,
             ...writerWarnings,
         ];
-        throw error instanceof OutputWriteError
+        throw error instanceof AvOutputWriteError
             ? error.precededBy(said)
             : precedeDefect(error, said);
     }
@@ -99,7 +99,7 @@ export async function writeClientOutput(input) {
                 validationWarnings = validation.warnings;
             }
             else {
-                throw new OutputWriteError("validate", `the generated output failed its ${validation.checked} check, so ${LEFT_AS_THEY_WERE(paths)} ` +
+                throw new AvOutputWriteError("validate", `the generated output failed its ${validation.checked} check, so ${LEFT_AS_THEY_WERE(paths)} ` +
                     "This is a defect in @aventara/client; please report it with these findings:\n" +
                     validation.findings.map((finding) => `  ${finding}`).join("\n"));
             }
@@ -267,7 +267,7 @@ async function inspectOwnedEntries(fs, paths, generatedSource = paths.generated)
     const generatedStats = await lstatOrUndefined(fs, generatedSource);
     if (generatedStats !== undefined) {
         if (!generatedStats.isDirectory()) {
-            throw new OutputWriteError("prepare", `refusing to replace ${generatedSource}: it is not a directory, and the generator owns ` +
+            throw new AvOutputWriteError("prepare", `refusing to replace ${generatedSource}: it is not a directory, and the generator owns ` +
                 `${GENERATED_DIRECTORY}/ as one; move it, or choose another \`generateAt\`. Nothing was written.`);
         }
         const entries = await fs.readdir(generatedSource, {
@@ -292,7 +292,7 @@ async function inspectOwnedEntries(fs, paths, generatedSource = paths.generated)
             continue;
         }
         if (!stats.isFile()) {
-            throw new OutputWriteError("prepare", `refusing to replace ${file}: it is not a file, and the generator owns ${name} ` +
+            throw new AvOutputWriteError("prepare", `refusing to replace ${file}: it is not a file, and the generator owns ${name} ` +
                 "as one; move it, or choose another `generateAt`. Nothing was written.");
         }
         entries.push(name);
@@ -317,12 +317,12 @@ async function inspectOwnedEntries(fs, paths, generatedSource = paths.generated)
 }
 function foreignContentRefusal(paths, foreign) {
     const them = foreign.length === 1 ? "it" : "them";
-    return new OutputWriteError("prepare", `refusing to generate into ${paths.generateAt}: ${foreign.join(", ")} ${foreign.length === 1 ? "was" : "were"} ` +
+    return new AvOutputWriteError("prepare", `refusing to generate into ${paths.generateAt}: ${foreign.join(", ")} ${foreign.length === 1 ? "was" : "were"} ` +
         `not generated by @aventara/client, and generating would overwrite or remove ${them}; confirm the ` +
         `override, move ${them} out, or choose another \`generateAt\`. Nothing was written.`);
 }
 function notADirectory(generateAt) {
-    return new OutputWriteError("prepare", `refusing to generate into ${generateAt}: it is not a directory. ` +
+    return new AvOutputWriteError("prepare", `refusing to generate into ${generateAt}: it is not a directory. ` +
         "`generateAt` must name a directory; choose another `generateAt`. Nothing was written.");
 }
 async function carriesOwnershipLine(fs, file) {
@@ -341,7 +341,7 @@ async function rollBack(paths, cause, undo) {
         await undo();
     }
     catch (rollbackError) {
-        throw new OutputWriteError("replace", `the generated output could not be moved into ${paths.generateAt} (${describe(cause)}), and the ` +
+        throw new AvOutputWriteError("replace", `the generated output could not be moved into ${paths.generateAt} (${describe(cause)}), and the ` +
             `previous output could not be restored (${describe(rollbackError)}). The previous ` +
             `${GENERATED_DIRECTORY}/ is intact at ${paths.previous}; the next run puts it back.`, { cause });
     }
@@ -351,10 +351,10 @@ async function stage(name, paths, run) {
         return await run();
     }
     catch (error) {
-        if (error instanceof OutputWriteError || !isSystemError(error)) {
+        if (error instanceof AvOutputWriteError || !isSystemError(error)) {
             throw error;
         }
-        throw new OutputWriteError(name, `could not ${STAGE_ACTIONS[name]} (${describe(error)}); ${LEFT_AS_THEY_WERE(paths)}`, { cause: error });
+        throw new AvOutputWriteError(name, `could not ${STAGE_ACTIONS[name]} (${describe(error)}); ${LEFT_AS_THEY_WERE(paths)}`, { cause: error });
     }
 }
 const STAGE_ACTIONS = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aventara/client",
-  "version": "1.0.0-rc.0",
+  "version": "1.0.0-rc.1",
   "license": "SEE LICENSE IN LICENSE",
   "description": "Development-time generator for Aventara typed remote clients.",
   "type": "module",
@@ -24,7 +24,7 @@
     "CHANGELOG.md"
   ],
   "dependencies": {
-    "@aventara/core": "1.0.0-rc.0",
+    "@aventara/core": "1.0.0-rc.1",
     "c12": "3.3.4",
     "get-tsconfig": "4.10.0"
   },
@@ -40,7 +40,7 @@
     "access": "public"
   },
   "devDependencies": {
-    "@aventara/testing": "1.0.0-rc.0",
+    "@aventara/testing": "1.0.0-rc.1",
     "@types/node": "24.10.1",
     "typescript": "^5.9.2"
   },