@aventara/client 0.1.0-pilot.4 → 1.0.0-rc.1

package/dist/cli/generate.command.js

@@ -1,14 +1,24 @@
 import { generateClient } from "../generate.js";
 import { FOREIGN_CONTENT_QUESTION, renderForeignContentCancellation, renderForeignContentWarning, renderGenerationSuccess, renderUpToDate, } from "./generation-success.renderer.js";
-export async function runGenerate(io, yes) {
+import { createStepReporter, } from "./step.reporter.js";
+export const GENERATION_STEPS = 4;
+export async function runGenerate(io, yes, reporter) {
+    const progress = reporter ??
+        createStepReporter({
+            write: io.stderr,
+            mode: io.progress ?? "off",
+            total: GENERATION_STEPS,
+        });
     const outcome = await generateClient({
         directory: io.cwd,
         processEnv: io.env,
         overrideForeign: yes,
+        step: progress.step,
     });
     if (outcome.kind === "up-to-date") {
         const report = renderUpToDate(outcome);
         io.stderr(report.stderr);
+        progress.finish("avclient", "done");
         io.stdout(report.stdout);
         return 0;
     }
@@ -30,6 +40,7 @@ export async function runGenerate(io, yes) {
     }
     const report = renderGenerationSuccess(result);
     io.stderr(report.stderr);
+    progress.finish("avclient", "done");
     io.stdout(report.stdout);
     return 0;
 }

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/cli/step.reporter.d.ts

@@ -0,0 +1,31 @@
+export type ProgressMode = "live" | "plain" | "off";
+/** `live` only on a terminal that is not CI and accepts control sequences. */
+export declare function progressModeOf(isTTY: boolean | undefined, env: Readonly<Record<string, string | undefined>>): Exclude<ProgressMode, "off">;
+export type StepReporterOptions = {
+    /** Where the lines go: the tool's stderr, so its stdout stays its result. */
+    readonly write: (text: string) => void;
+    readonly mode: ProgressMode;
+    /** How many steps this run takes, for `[n/total]`. */
+    readonly total: number;
+    /** Each child's output streams between a step's start and end lines. */
+    readonly verbose?: boolean;
+    /** Milliseconds now; `Date.now` by default. */
+    readonly now?: () => number;
+    /** Redraw interval of the live line, in milliseconds. */
+    readonly interval?: number;
+};
+export type StepReporter = {
+    /**
+     * Runs one step under its numbered line. Its outcome — `done`, or `failed`
+     * when `body` throws — ends the line; the error is rethrown unchanged.
+     */
+    readonly step: <T>(title: string, body: () => Promise<T> | T) => Promise<T>;
+    /** Streams a child's output, in `verbose` mode only. */
+    readonly output: (chunk: string) => void;
+    /** The closing line: `<prefix>: <what> in <time>.` */
+    readonly finish: (prefix: string, what: string) => void;
+    readonly verbose: boolean;
+};
+/** `12.4s`, or `1m 02s` from a minute. */
+export declare function formatElapsed(milliseconds: number): string;
+export declare function createStepReporter(options: StepReporterOptions): StepReporter;

package/dist/cli/step.reporter.js

@@ -0,0 +1,87 @@
+export function progressModeOf(isTTY, env) {
+    const ci = env.CI;
+    if (isTTY !== true ||
+        (ci !== undefined && ci !== "" && ci !== "0" && ci !== "false") ||
+        (env.NO_COLOR !== undefined && env.NO_COLOR !== "") ||
+        env.TERM === "dumb") {
+        return "plain";
+    }
+    return "live";
+}
+const SPINNER = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+const CLEAR_LINE = "\r\u001b[2K";
+const GREEN = (text) => `\u001b[32m${text}\u001b[39m`;
+const RED = (text) => `\u001b[31m${text}\u001b[39m`;
+const DIM = (text) => `\u001b[2m${text}\u001b[22m`;
+export function formatElapsed(milliseconds) {
+    const seconds = milliseconds / 1000;
+    if (seconds < 60) {
+        return `${seconds.toFixed(1)}s`;
+    }
+    const whole = Math.round(seconds);
+    return `${Math.floor(whole / 60)}m ${String(whole % 60).padStart(2, "0")}s`;
+}
+export function createStepReporter(options) {
+    const now = options.now ?? Date.now;
+    const started = now();
+    const verbose = options.verbose === true && options.mode !== "off";
+    const mode = verbose ? "plain" : options.mode;
+    let index = 0;
+    const step = async (title, body) => {
+        index += 1;
+        const label = `[${index}/${options.total}] ${title}`;
+        const at = now();
+        const elapsed = () => formatElapsed(now() - at);
+        if (mode === "off") {
+            return await body();
+        }
+        if (mode === "plain") {
+            options.write(verbose ? `${label}…\n` : `${label}… `);
+            try {
+                const value = await body();
+                options.write(verbose ? `${label}… done (${elapsed()})\n` : `done (${elapsed()})\n`);
+                return value;
+            }
+            catch (error) {
+                options.write(verbose
+                    ? `${label}… failed (${elapsed()})\n`
+                    : `failed (${elapsed()})\n`);
+                throw error;
+            }
+        }
+        let frame = 0;
+        const draw = () => {
+            const seconds = Math.floor((now() - at) / 1000);
+            options.write(`${CLEAR_LINE}${SPINNER[frame % SPINNER.length]} ${label}…${seconds > 0 ? DIM(` ${seconds}s`) : ""}`);
+            frame += 1;
+        };
+        draw();
+        const timer = setInterval(draw, options.interval ?? 80);
+        timer.unref?.();
+        try {
+            const value = await body();
+            clearInterval(timer);
+            options.write(`${CLEAR_LINE}${GREEN("✓")} ${label} ${DIM(elapsed())}\n`);
+            return value;
+        }
+        catch (error) {
+            clearInterval(timer);
+            options.write(`${CLEAR_LINE}${RED("✗")} ${label} ${DIM(elapsed())}\n`);
+            throw error;
+        }
+    };
+    return {
+        step,
+        output: (chunk) => {
+            if (verbose) {
+                options.write(chunk);
+            }
+        },
+        finish: (prefix, what) => {
+            if (mode !== "off") {
+                options.write(`${prefix}: ${what} in ${formatElapsed(now() - started)}.\n`);
+            }
+        },
+        verbose,
+    };
+}

package/dist/cli.js

@@ -1,6 +1,7 @@
 import { GENERATE_USAGE, INIT_USAGE, parseCliCommand, USAGE, } from "./cli/command.parser.js";
 import { runGenerate } from "./cli/generate.command.js";
 import { renderGenerationFailure } from "./cli/generation-failure.renderer.js";
+import { progressModeOf } from "./cli/step.reporter.js";
 import { createTerminalPrompter } from "./cli/terminal.prompter.js";
 import { AVENTARA_CLIENT_GENERATOR_VERSION } from "./index.js";
 import { runClientInit } from "./init/client-init.orchestrator.js";
@@ -47,6 +48,7 @@ export async function runFromProcess() {
             confirm: terminal.confirm,
             ask: terminal.ask,
             run: runCommand,
+            progress: progressModeOf(process.stderr.isTTY, process.env),
         });
     }
     finally {

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,4 +1,4 @@
-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 config's name, before its extension. */
@@ -8,7 +8,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 +20,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",
@@ -20,14 +20,14 @@ 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 ` +
+        throw new AvClientConfigError(`no ${CLIENT_CONFIG_BASENAME}.{${CLIENT_CONFIG_FILE_EXTENSIONS.map((extension) => extension.slice(1)).join(",")}} 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 +52,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 +84,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";
+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>;