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

package/dist/cli/generation-failure.renderer.js

@@ -1,33 +1,33 @@
-import { ClientConfigError } from "../config/config.resolver.js";
-import { EnvFileError } from "../config/env.cascade.js";
-import { ContractProtocolError } from "../contract/contract.acceptance.js";
-import { ContractTransportError } from "../contract/contract.fetcher.js";
-import { GeneratedNameError } from "../emit/name.deriver.js";
-import { ClientInitNotConfirmedError, ClientInitStepError, } from "../init/client-init.errors.js";
-import { ClientInitAnswerError, ClientInitUnansweredError, } from "../init/client-init.questions.js";
-import { ClientProjectRefusedError } from "../init/client-project.inspector.js";
-import { OutputWriteError, warningsRaisedBeforeDefect, } from "../output/output.writer.js";
-import { CliCommandError } from "./command.parser.js";
+import { AvClientConfigError } from "../config/config.resolver.js";
+import { AvEnvFileError } from "../config/env.cascade.js";
+import { AvContractProtocolError } from "../contract/contract.acceptance.js";
+import { AvContractTransportError } from "../contract/contract.fetcher.js";
+import { AvGeneratedNameError } from "../emit/name.deriver.js";
+import { AvClientInitNotConfirmedError, AvClientInitStepError, } from "../init/client-init.errors.js";
+import { AvClientInitAnswerError, AvClientInitUnansweredError, } from "../init/client-init.questions.js";
+import { AvClientProjectRefusedError } from "../init/client-project.inspector.js";
+import { AvOutputWriteError, warningsRaisedBeforeDefect, } from "../output/output.writer.js";
+import { AvCliCommandError } from "./command.parser.js";
 import { renderWarningLines } from "./warning.renderer.js";
 const REFUSALS = [
-    CliCommandError,
-    ClientConfigError,
-    EnvFileError,
-    ContractTransportError,
-    ContractProtocolError,
-    GeneratedNameError,
-    OutputWriteError,
-    ClientInitAnswerError,
-    ClientInitUnansweredError,
-    ClientProjectRefusedError,
-    ClientInitNotConfirmedError,
-    ClientInitStepError,
+    AvCliCommandError,
+    AvClientConfigError,
+    AvEnvFileError,
+    AvContractTransportError,
+    AvContractProtocolError,
+    AvGeneratedNameError,
+    AvOutputWriteError,
+    AvClientInitAnswerError,
+    AvClientInitUnansweredError,
+    AvClientProjectRefusedError,
+    AvClientInitNotConfirmedError,
+    AvClientInitStepError,
 ];
 export function renderGenerationFailure(error) {
     if (REFUSALS.some((refusal) => error instanceof refusal)) {
-        const carried = error instanceof OutputWriteError ? error.warnings : [];
+        const carried = error instanceof AvOutputWriteError ? error.warnings : [];
         return {
-            exitCode: error instanceof ContractProtocolError ? error.exitCode : 1,
+            exitCode: error instanceof AvContractProtocolError ? error.exitCode : 1,
             text: `${renderWarningLines(carried)}avclient: ${error.message}\n`,
         };
     }

package/dist/config/client-config.interface.d.ts

@@ -1,29 +1,29 @@
 /** A deferred read of one environment variable from the resolved cascade. */
-export interface EnvReference {
+export interface AvEnvReference {
     /** Always `"env"`. */
     readonly kind: "env";
     /** The environment variable's name. */
     readonly name: string;
 }
 /** A value written literally, or read from the resolved environment. */
-export type ConfigValue = string | EnvReference;
+export type AvClientConfigValue = string | AvEnvReference;
 /**
  * What a `framework.client.ts` default-exports through `defineClientConfig`.
- * Plain data: an environment variable appears as an `EnvReference` (`env("NAME")`),
+ * Plain data: an environment variable appears as an `AvEnvReference` (`env("NAME")`),
  * a name to look up, so the file can be evaluated before the environment is loaded.
  */
-export interface ClientConfigInput {
+export interface AvClientConfigInput {
     /** The full deployed framework entrypoint: origin plus mount path. */
-    readonly entrypoint: ConfigValue;
+    readonly entrypoint: AvClientConfigValue;
     /**
      * The directory the client is generated into, relative to the config file's
      * directory. It is shared: the generator writes only `AvClient.ts` and
      * `generated/` in it, and never touches anything else there.
      */
-    readonly generateAt: ConfigValue;
+    readonly generateAt: AvClientConfigValue;
     /**
      * The `tsconfig.json` the generated client is written for, relative to the
-     * config file's directory — only for a layout the discovery gets wrong (a
+     * config file's directory. Set it only for a layout the discovery gets wrong (a
      * monorepo, a non-standard name). Absent, the nearest `tsconfig.json` above
      * `generateAt` is used.
      */

package/dist/config/config.loader.d.ts

@@ -1,6 +1,12 @@
-import type { ClientConfigInput } from "./client-config.interface.js";
+import type { AvClientConfigInput } from "./client-config.interface.js";
 /** Prisma's `SUPPORTED_EXTENSIONS`, in its order. */
 export declare const CLIENT_CONFIG_FILE_EXTENSIONS: readonly [".js", ".ts", ".mjs", ".cjs", ".mts", ".cts"];
+/**
+ * The same extensions as the docs and `avclient --help` list them, TypeScript
+ * first: the order a sentence to the developer names them in. Lookup keeps
+ * {@link CLIENT_CONFIG_FILE_EXTENSIONS}' order, Prisma's.
+ */
+export declare const CLIENT_CONFIG_FILE_EXTENSIONS_AS_LISTED: readonly [".ts", ".mts", ".cts", ".js", ".mjs", ".cjs"];
 /** The config's name, before its extension. */
 export declare const CLIENT_CONFIG_BASENAME = "framework.client";
 /** The config file `avclient init` writes when the project has none. */
@@ -8,7 +14,7 @@ export declare const CLIENT_CONFIG_FILE = "framework.client.ts";
 export interface LoadedClientConfig {
     /** The config file's absolute path; `generateAt` resolves against its directory. */
     readonly file: string;
-    readonly config: ClientConfigInput;
+    readonly config: AvClientConfigInput;
 }
 /**
  * The config files present in `directory`, by name, in
@@ -20,13 +26,13 @@ export declare function clientConfigFilesIn(directory: string): readonly string[
  * The one config file in `directory`, by name, or `undefined` when there is
  * none.
  *
- * @throws ClientConfigError when there is more than one, naming each.
+ * @throws AvClientConfigError when there is more than one, naming each.
  */
 export declare function findClientConfigFile(directory: string): string | undefined;
 /**
  * Evaluates the one `framework.client.<ext>` in `directory`.
  *
- * @throws ClientConfigError, in one line, when there is none or more than one,
+ * @throws AvClientConfigError, in one line, when there is none or more than one,
  *   or the file does not evaluate, or does not default-export a client config.
  */
 export declare function loadClientConfigFile(directory: string): Promise<LoadedClientConfig>;

package/dist/config/config.loader.js

@@ -1,6 +1,6 @@
 import { statSync } from "node:fs";
 import path from "node:path";
-import { ClientConfigError } from "./config.resolver.js";
+import { AvClientConfigError } from "./config.resolver.js";
 export const CLIENT_CONFIG_FILE_EXTENSIONS = [
     ".js",
     ".ts",
@@ -9,6 +9,14 @@ export const CLIENT_CONFIG_FILE_EXTENSIONS = [
     ".mts",
     ".cts",
 ];
+export const CLIENT_CONFIG_FILE_EXTENSIONS_AS_LISTED = [
+    ".ts",
+    ".mts",
+    ".cts",
+    ".js",
+    ".mjs",
+    ".cjs",
+];
 export const CLIENT_CONFIG_BASENAME = "framework.client";
 export const CLIENT_CONFIG_FILE = `${CLIENT_CONFIG_BASENAME}.ts`;
 export function clientConfigFilesIn(directory) {
@@ -20,14 +28,15 @@ export function findClientConfigFile(directory) {
     const present = clientConfigFilesIn(directory);
     if (present.length > 1) {
         const named = `${present.slice(0, -1).join(", ")} and ${present.at(-1)}`;
-        throw new ClientConfigError(`${named} are ${present.length === 2 ? "both" : "all"} in ${path.resolve(directory)}, and only one may configure the generator; keep one and delete the other${present.length > 2 ? "s" : ""}.`);
+        throw new AvClientConfigError(`${named} are ${present.length === 2 ? "both" : "all"} in ${path.resolve(directory)}, and only one may configure the generator; keep one and delete the other${present.length > 2 ? "s" : ""}.`);
     }
     return present[0];
 }
 export async function loadClientConfigFile(directory) {
     const name = findClientConfigFile(directory);
     if (name === undefined) {
-        throw new ClientConfigError(`no ${CLIENT_CONFIG_BASENAME}.{${CLIENT_CONFIG_FILE_EXTENSIONS.map((extension) => extension.slice(1)).join(",")}} in ${path.resolve(directory)}; create ${CLIENT_CONFIG_FILE} with ` +
+        const [first, ...others] = CLIENT_CONFIG_FILE_EXTENSIONS_AS_LISTED;
+        throw new AvClientConfigError(`no ${CLIENT_CONFIG_BASENAME}${first}, ${others.slice(0, -1).join(", ")} or ${others.at(-1)} in ${path.resolve(directory)}; create ${CLIENT_CONFIG_FILE} with ` +
             "`export default defineClientConfig({ entrypoint, generateAt })` (or run `avclient init`) and run the generator from its directory.");
     }
     const file = path.resolve(directory, name);
@@ -52,19 +61,19 @@ export async function loadClientConfigFile(directory) {
         evaluated = loaded.layers?.find((layer) => layer.configFile === file)?.config;
     }
     catch (error) {
-        throw new ClientConfigError(`${file} could not be evaluated: ${firstLineOf(error)}`, { cause: error });
+        throw new AvClientConfigError(`${file} could not be evaluated: ${firstLineOf(error)}`, { cause: error });
     }
     return { file, config: clientConfigOf(file, evaluated) };
 }
 function clientConfigOf(file, config) {
     const shape = "`export default defineClientConfig({ entrypoint, generateAt })`";
     if (typeof config !== "object" || config === null || Array.isArray(config)) {
-        throw new ClientConfigError(`${file}'s default export is not an object; it must be ${shape}.`);
+        throw new AvClientConfigError(`${file}'s default export is not an object; it must be ${shape}.`);
     }
     const members = config;
     const tsconfigFile = members.tsconfigFile;
     if (tsconfigFile !== undefined && typeof tsconfigFile !== "string") {
-        throw new ClientConfigError(`${file}'s tsconfigFile must be a string, a path relative to ${path.dirname(file)}.`);
+        throw new AvClientConfigError(`${file}'s tsconfigFile must be a string, a path relative to ${path.dirname(file)}.`);
     }
     return {
         entrypoint: configValueOf(file, "entrypoint", members.entrypoint),
@@ -84,7 +93,7 @@ function configValueOf(file, member, value) {
             return { kind: "env", name };
         }
     }
-    throw new ClientConfigError(`${file}'s ${member} must be a string or env("NAME"), and it is ${value === undefined ? "missing" : "neither"}.`);
+    throw new AvClientConfigError(`${file}'s ${member} must be a string or env("NAME"), and it is ${value === undefined ? "missing" : "neither"}.`);
 }
 function firstLineOf(error) {
     const message = error instanceof Error ? error.message : String(error);

package/dist/config/config.resolver.d.ts

@@ -1,18 +1,18 @@
-import type { ClientConfigInput, ClientEntrypoint, EnvReference, ResolvedClientConfig } from "./client-config.interface.js";
+import type { AvClientConfigInput, AvEnvReference, ClientEntrypoint, ResolvedClientConfig } from "./client-config.interface.js";
 import type { EnvCascadeResolution } from "./env.cascade.js";
 /** Gives a `framework.client.ts` its type: returns `config` unchanged. */
-export declare function defineClientConfig(config: ClientConfigInput): ClientConfigInput;
+export declare function defineClientConfig(config: AvClientConfigInput): AvClientConfigInput;
 /** Names an environment variable to be read from the resolved environment. */
-export declare function env(name: string): EnvReference;
+export declare function env(name: string): AvEnvReference;
 /**
  * The configuration cannot be resolved. The message is the whole diagnosis — the
  * CLI prints it and exits non-zero; no stack is owed for a user's mistake.
  */
-export declare class ClientConfigError extends Error {
-    readonly name = "ClientConfigError";
+export declare class AvClientConfigError extends Error {
+    readonly name = "AvClientConfigError";
 }
 export interface ClientConfigResolutionInput {
-    readonly config: ClientConfigInput;
+    readonly config: AvClientConfigInput;
     readonly cascade: EnvCascadeResolution;
     /** The directory holding the config file; `generateAt` resolves against it. */
     readonly configDirectory: string;
@@ -23,7 +23,7 @@ export interface ClientConfigResolutionInput {
  */
 export declare function resolveClientConfig(input: ClientConfigResolutionInput): ResolvedClientConfig;
 /**
- * @throws ClientConfigError in one sentence that does not echo the value.
+ * @throws AvClientConfigError in one sentence that does not echo the value.
  */
 export declare function resolveEntrypoint(value: string): ClientEntrypoint;
 export declare function entrypointHref(entrypoint: ClientEntrypoint): string;

package/dist/config/config.resolver.js

@@ -6,15 +6,15 @@ export function defineClientConfig(config) {
 export function env(name) {
     return { kind: "env", name };
 }
-export class ClientConfigError extends Error {
-    name = "ClientConfigError";
+export class AvClientConfigError extends Error {
+    name = "AvClientConfigError";
 }
 export function resolveClientConfig(input) {
     const entrypoint = resolveValue("entrypoint", input.config.entrypoint, input.cascade);
     const generateAt = resolveValue("generateAt", input.config.generateAt, input.cascade);
     const tsconfigFile = input.config.tsconfigFile;
     if (tsconfigFile === "") {
-        throw new ClientConfigError("tsconfigFile is empty.");
+        throw new AvClientConfigError("tsconfigFile is empty.");
     }
     return {
         entrypoint: resolveEntrypoint(entrypoint),
@@ -30,12 +30,12 @@ export function resolveClientConfig(input) {
 function resolveValue(field, value, cascade) {
     if (typeof value === "string") {
         if (value === "")
-            throw new ClientConfigError(`${field} is empty.`);
+            throw new AvClientConfigError(`${field} is empty.`);
         return value;
     }
     const resolved = cascade.env[value.name];
     if (resolved === undefined || resolved === "") {
-        throw new ClientConfigError(`${field} reads ${value.name}, which is not set in the process environment ` +
+        throw new AvClientConfigError(`${field} reads ${value.name}, which is not set in the process environment ` +
             `or in any of ${cascade.candidates.join(", ")} (mode "${cascade.mode}").`);
     }
     return resolved;
@@ -43,32 +43,32 @@ function resolveValue(field, value, cascade) {
 const ENTRYPOINT_IS = "it must be the origin plus a mount path";
 export function resolveEntrypoint(value) {
     if (/\s/u.test(value)) {
-        throw new ClientConfigError(`entrypoint contains whitespace; ${ENTRYPOINT_IS}, written without spaces, tabs or line breaks.`);
+        throw new AvClientConfigError(`entrypoint contains whitespace; ${ENTRYPOINT_IS}, written without spaces, tabs or line breaks.`);
     }
     let url;
     try {
         url = new URL(value);
     }
     catch {
-        throw new ClientConfigError("entrypoint is not an absolute URL; it must be the deployed origin plus mount path.");
+        throw new AvClientConfigError("entrypoint is not an absolute URL; it must be the deployed origin plus mount path.");
     }
     if (url.protocol !== "http:" && url.protocol !== "https:") {
-        throw new ClientConfigError(`entrypoint must use http: or https:, not ${url.protocol}`);
+        throw new AvClientConfigError(`entrypoint must use http: or https:, not ${url.protocol}`);
     }
     if (url.username !== "" || url.password !== "") {
-        throw new ClientConfigError("entrypoint must not carry credentials: the platform's fetch refuses a URL that " +
+        throw new AvClientConfigError("entrypoint must not carry credentials: the platform's fetch refuses a URL that " +
             "includes them, and the entrypoint is embedded in the generated client, which ships — " +
             "authenticate through a custom fetch instead.");
     }
     if (value.includes("?") || value.includes("#")) {
-        throw new ClientConfigError("entrypoint must not carry a query or fragment; it is the origin plus mount path only.");
+        throw new AvClientConfigError("entrypoint must not carry a query or fragment; it is the origin plus mount path only.");
     }
     if (value.split(/[/\\]/u).some(isDotDotSegment)) {
-        throw new ClientConfigError(`entrypoint's mount path has a .. segment; ${ENTRYPOINT_IS}, with no dot segments.`);
+        throw new AvClientConfigError(`entrypoint's mount path has a .. segment; ${ENTRYPOINT_IS}, with no dot segments.`);
     }
     const normalized = AvProtocol.normalizeEntrypoint(writtenMountPath(value));
     if (!normalized.ok) {
-        throw new ClientConfigError(`entrypoint's mount path ${normalized.message}.`);
+        throw new AvClientConfigError(`entrypoint's mount path ${normalized.message}.`);
     }
     const deployment = new URL(url.href);
     deployment.pathname = "/";

package/dist/config/env.cascade.d.ts

@@ -23,10 +23,10 @@ export interface EnvCascadeResolution {
     readonly loaded: readonly string[];
 }
 /** A candidate exists but could not be read, or contains a discarded line. */
-export declare class EnvFileError extends Error {
+export declare class AvEnvFileError extends Error {
     readonly filePath: string;
     readonly reason: "unreadable" | "malformed";
-    readonly name = "EnvFileError";
+    readonly name = "AvEnvFileError";
     constructor(filePath: string, reason: "unreadable" | "malformed", detail: string);
 }
 /** The four file candidates for a mode, highest precedence first. */

package/dist/config/env.cascade.js

@@ -2,10 +2,10 @@ import { readFileSync } from "node:fs";
 import path from "node:path";
 import { parseEnv } from "node:util";
 export const DEFAULT_ENV_MODE = "development";
-export class EnvFileError extends Error {
+export class AvEnvFileError extends Error {
     filePath;
     reason;
-    name = "EnvFileError";
+    name = "AvEnvFileError";
     constructor(filePath, reason, detail) {
         super(`${filePath}: ${detail}`);
         this.filePath = filePath;
@@ -52,14 +52,14 @@ export function readEnvFileFromDisk(filePath) {
         if (isErrnoException(error) && error.code === "ENOENT")
             return undefined;
         const code = isErrnoException(error) ? error.code : undefined;
-        throw new EnvFileError(filePath, "unreadable", `exists but cannot be read (${code ?? "unknown error"})`);
+        throw new AvEnvFileError(filePath, "unreadable", `exists but cannot be read (${code ?? "unknown error"})`);
     }
 }
 export function parseEnvFile(filePath, content) {
     const source = content.startsWith("") ? content.slice(1) : content;
     const discarded = firstDiscardedLine(source);
     if (discarded !== undefined) {
-        throw new EnvFileError(filePath, "malformed", `line ${discarded} is not a NAME=value assignment and would be ignored`);
+        throw new AvEnvFileError(filePath, "malformed", `line ${discarded} is not a NAME=value assignment and would be ignored`);
     }
     return parseEnv(source);
 }

package/dist/config/module-style.resolver.d.ts

@@ -17,7 +17,7 @@ export interface ModuleStyleInput {
 /**
  * The style the project's tsconfig asks for.
  *
- * @throws ClientConfigError when there is no tsconfig to follow, or the named
+ * @throws AvClientConfigError when there is no tsconfig to follow, or the named
  *   `tsconfigFile` cannot be read.
  */
 export declare function resolveModuleStyle(input: ModuleStyleInput): ResolvedModuleStyle;

package/dist/config/module-style.resolver.js

@@ -1,11 +1,11 @@
 import { readFileSync, statSync } from "node:fs";
 import path from "node:path";
-import { ClientConfigError } from "./config.resolver.js";
+import { AvClientConfigError } from "./config.resolver.js";
 import { locateTsconfig } from "./tsconfig.locator.js";
 export function resolveModuleStyle(input) {
     const located = locateTsconfig(input);
     if (located === undefined) {
-        throw new ClientConfigError(noTsconfigRefusal(input.generateAt));
+        throw new AvClientConfigError(noTsconfigRefusal(input.generateAt));
     }
     return {
         tsconfig: located.path,

package/dist/config/tsconfig.locator.d.ts

@@ -16,6 +16,6 @@ export interface TsconfigLocation {
  * The tsconfig `location` names, or `undefined` when no `tsconfig.json` is in
  * `generateAt` or any directory above it (and none was named).
  *
- * @throws ClientConfigError when the named `tsconfigFile` is missing or unreadable.
+ * @throws AvClientConfigError when the named `tsconfigFile` is missing or unreadable.
  */
 export declare function locateTsconfig(location: TsconfigLocation): LocatedTsconfig | undefined;

package/dist/config/tsconfig.locator.js

@@ -1,7 +1,7 @@
 import { readFileSync } from "node:fs";
 import path from "node:path";
 import { createFilesMatcher, getTsconfig, parseTsconfig, } from "get-tsconfig";
-import { ClientConfigError } from "./config.resolver.js";
+import { AvClientConfigError } from "./config.resolver.js";
 export function locateTsconfig(location) {
     if (location.tsconfigFile !== undefined) {
         return namedTsconfig(location.tsconfigFile);
@@ -34,7 +34,7 @@ function namedTsconfig(file) {
             : error instanceof Error
                 ? error.message
                 : String(error);
-        throw new ClientConfigError(`tsconfigFile names ${file}, which could not be read (${reason}); it must name the tsconfig.json your project compiles the generated client with.`);
+        throw new AvClientConfigError(`tsconfigFile names ${file}, which could not be read (${reason}); it must name the tsconfig.json your project compiles the generated client with.`);
     }
 }
 function referencedTsconfig(from, reference) {

package/dist/contract/contract.acceptance.d.ts

@@ -1,9 +1,9 @@
-import type { ClientContract } from "@aventara/core";
+import type { AvContractClient } from "@aventara/core";
 export declare const SUPPORTED_PROTOCOL_VERSIONS: ReadonlySet<number>;
 export type ContractRejectionReason = "protocol-unsupported" | "hash-mismatch" | "structure-invalid";
 export type ContractAccepted = {
     readonly accepted: true;
-    readonly contract: ClientContract;
+    readonly contract: AvContractClient;
 };
 export type ContractRejected = {
     readonly accepted: false;
@@ -16,8 +16,8 @@ export type ContractRejected = {
 export type ContractAcceptance = ContractAccepted | ContractRejected;
 export declare function acceptClientContract(body: unknown): Promise<ContractAcceptance>;
 /** The refusal that stops generation, carrying the rejection's reason and sentence. */
-export declare class ContractProtocolError extends Error {
-    readonly name = "ContractProtocolError";
+export declare class AvContractProtocolError extends Error {
+    readonly name = "AvContractProtocolError";
     readonly reason: ContractRejectionReason;
     readonly exitCode: number;
     constructor(rejection: ContractRejected, contractUrl: string);

package/dist/contract/contract.acceptance.js

@@ -1,4 +1,4 @@
-import { AVENTARA_PROTOCOL_VERSION, CanonicalJsonError, computeClientContractHash, validateClientContractStructure, } from "@aventara/core/internal";
+import { AVENTARA_PROTOCOL_VERSION, AvCanonicalJsonError, computeClientContractHash, validateClientContractStructure, } from "@aventara/core/internal";
 export const SUPPORTED_PROTOCOL_VERSIONS = new Set([
     AVENTARA_PROTOCOL_VERSION,
 ]);
@@ -22,7 +22,7 @@ export async function acceptClientContract(body) {
         recomputed = await computeClientContractHash(contract);
     }
     catch (error) {
-        if (!(error instanceof CanonicalJsonError)) {
+        if (!(error instanceof AvCanonicalJsonError)) {
             throw error;
         }
         return reject("hash-mismatch", `it holds a value canonical JSON cannot represent (${error.message}), so its ` +
@@ -36,8 +36,8 @@ export async function acceptClientContract(body) {
     }
     return { accepted: true, contract };
 }
-export class ContractProtocolError extends Error {
-    name = "ContractProtocolError";
+export class AvContractProtocolError extends Error {
+    name = "AvContractProtocolError";
     reason;
     exitCode;
     constructor(rejection, contractUrl) {

package/dist/contract/contract.fetcher.d.ts

@@ -16,15 +16,15 @@ export type ContractTransportFailureReason =
  | "body-unreadable"
 /** A body that is not JSON — an HTML page, an empty body, a truncation. */
  | "body-not-json";
-export declare class ContractTransportError extends Error {
+export declare class AvContractTransportError extends Error {
     readonly reason: ContractTransportFailureReason;
-    readonly name = "ContractTransportError";
+    readonly name = "AvContractTransportError";
     constructor(reason: ContractTransportFailureReason, message: string, options?: ErrorOptions);
 }
 export declare function contractUrlOf(entrypoint: ClientEntrypoint): URL;
 /** The URL as it may be printed: credentials in the entrypoint never are. */
 export declare function displayUrl(url: URL): string;
 /**
- * @throws ContractTransportError when no JSON value arrives.
+ * @throws AvContractTransportError when no JSON value arrives.
  */
 export declare function fetchClientContractBody(entrypoint: ClientEntrypoint, fetch?: ContractFetch, ifNoneMatch?: string): Promise<unknown>;

package/dist/contract/contract.fetcher.js

@@ -1,7 +1,7 @@
 export const CONTRACT_NOT_MODIFIED = Symbol("aventara.contract-not-modified");
-export class ContractTransportError extends Error {
+export class AvContractTransportError extends Error {
     reason;
-    name = "ContractTransportError";
+    name = "AvContractTransportError";
     constructor(reason, message, options) {
         super(message, options);
         this.reason = reason;
@@ -29,26 +29,26 @@ export async function fetchClientContractBody(entrypoint, fetch = globalThis.fet
             : { method: "GET", headers: { "If-None-Match": ifNoneMatch } });
     }
     catch (error) {
-        throw new ContractTransportError("request-failed", `Could not fetch the ClientContract from ${shown}: ${describeCause(error)}. ${remedy}`, { cause: error });
+        throw new AvContractTransportError("request-failed", `Could not fetch the ClientContract from ${shown}: ${describeCause(error)}. ${remedy}`, { cause: error });
     }
     if (response.status === 304 && ifNoneMatch !== undefined) {
         return CONTRACT_NOT_MODIFIED;
     }
     if (!response.ok) {
-        throw new ContractTransportError("http-status", `GET ${shown} answered HTTP ${response.status}, not the ClientContract. ${remedy}`);
+        throw new AvContractTransportError("http-status", `GET ${shown} answered HTTP ${response.status}, not the ClientContract. ${remedy}`);
     }
     let text;
     try {
         text = await response.text();
     }
     catch (error) {
-        throw new ContractTransportError("body-unreadable", `The response from ${shown} could not be read: ${describeCause(error)}. ${remedy}`, { cause: error });
+        throw new AvContractTransportError("body-unreadable", `The response from ${shown} could not be read: ${describeCause(error)}. ${remedy}`, { cause: error });
     }
     try {
         return JSON.parse(text);
     }
     catch (error) {
-        throw new ContractTransportError("body-not-json", `The response from ${shown} is not JSON, so it is not a ClientContract. ${remedy}`, { cause: error });
+        throw new AvContractTransportError("body-not-json", `The response from ${shown} is not JSON, so it is not a ClientContract. ${remedy}`, { cause: error });
     }
 }
 function describeCause(error) {

package/dist/contract/contract.loader.d.ts

@@ -1,4 +1,4 @@
-import type { ClientContract } from "@aventara/core";
+import type { AvContractClient } from "@aventara/core";
 import type { ClientEntrypoint } from "../config/client-config.interface.js";
 import { type ContractFetch } from "./contract.fetcher.js";
 export interface ClientContractLoadInput {
@@ -6,12 +6,12 @@ export interface ClientContractLoadInput {
     readonly fetch?: ContractFetch;
 }
 /**
- * @throws ContractTransportError when no JSON value arrives.
- * @throws ContractProtocolError when what arrived is refused.
+ * @throws AvContractTransportError when no JSON value arrives.
+ * @throws AvContractProtocolError when what arrived is refused.
  */
-export declare function loadClientContract(input: ClientContractLoadInput): Promise<ClientContract>;
+export declare function loadClientContract(input: ClientContractLoadInput): Promise<AvContractClient>;
 export interface ClientContractSince {
-    readonly contract: ClientContract;
+    readonly contract: AvContractClient;
     /** The deployment answered `304`: `contract` is the one the caller held. */
     readonly notModified: boolean;
 }
@@ -21,4 +21,4 @@ export interface ClientContractSince {
  * `If-None-Match: "<its hash>"`, and a `304` answers with `stored` itself. Without
  * `stored` the GET is unconditional.
  */
-export declare function loadClientContractSince(input: ClientContractLoadInput, stored: ClientContract | undefined): Promise<ClientContractSince>;
+export declare function loadClientContractSince(input: ClientContractLoadInput, stored: AvContractClient | undefined): Promise<ClientContractSince>;

package/dist/contract/contract.loader.js

@@ -1,4 +1,4 @@
-import { acceptClientContract, ContractProtocolError, } from "./contract.acceptance.js";
+import { AvContractProtocolError, acceptClientContract, } from "./contract.acceptance.js";
 import { CONTRACT_NOT_MODIFIED, contractUrlOf, displayUrl, fetchClientContractBody, } from "./contract.fetcher.js";
 export async function loadClientContract(input) {
     return accepted(await fetchClientContractBody(input.entrypoint, input.fetch), input);
@@ -16,7 +16,7 @@ export async function loadClientContractSince(input, stored) {
 async function accepted(body, input) {
     const acceptance = await acceptClientContract(body);
     if (!acceptance.accepted) {
-        throw new ContractProtocolError(acceptance, displayUrl(contractUrlOf(input.entrypoint)));
+        throw new AvContractProtocolError(acceptance, displayUrl(contractUrlOf(input.entrypoint)));
     }
     return acceptance.contract;
 }

package/dist/emit/client-surface.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 emitClientSurfaceModule(contract: ClientContract, names: EmittedNames, style: ClientModuleStyle): EmittedModule;
+export declare function emitClientSurfaceModule(contract: AvContractClient, names: EmittedNames, style: ClientModuleStyle): EmittedModule;