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

package/dist/generate.js

@@ -4,11 +4,13 @@ import { loadClientConfigFile } from "./config/config.loader.js";
 import { resolveClientConfig } from "./config/config.resolver.js";
 import { resolveEnvCascade, } from "./config/env.cascade.js";
 import { resolveModuleStyle } from "./config/module-style.resolver.js";
+import { contractUrlOf, displayUrl, } from "./contract/contract.fetcher.js";
 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 {
         if ((await findForeignOutputContent(generateAt)).length > 0) {
@@ -21,32 +23,42 @@ async function storedContract(generateAt) {
     }
 }
 export async function generateClient(input) {
-    const cascade = resolveEnvCascade({
-        directory: input.directory,
-        processEnv: input.processEnv,
-    });
-    const loaded = await loadClientConfigFile(input.directory);
-    const config = resolveClientConfig({
-        config: loaded.config,
-        cascade,
-        configDirectory: path.dirname(loaded.file),
-    });
-    const style = resolveModuleStyle({
-        generateAt: config.generateAt,
-        entryFile: path.join(config.generateAt, CLIENT_ENTRY_FILE),
-        ...(config.tsconfigFile === undefined
-            ? {}
-            : { tsconfigFile: config.tsconfigFile }),
+    const step = input.step ?? runPhase;
+    const { config, style } = await step("Loading the client config", async () => {
+        const cascade = resolveEnvCascade({
+            directory: input.directory,
+            processEnv: input.processEnv,
+        });
+        const loaded = await loadClientConfigFile(input.directory);
+        const config = resolveClientConfig({
+            config: loaded.config,
+            cascade,
+            configDirectory: path.dirname(loaded.file),
+        });
+        const style = resolveModuleStyle({
+            generateAt: config.generateAt,
+            entryFile: path.join(config.generateAt, CLIENT_ENTRY_FILE),
+            ...(config.tsconfigFile === undefined
+                ? {}
+                : { tsconfigFile: config.tsconfigFile }),
+        });
+        return { config, style };
     });
-    const { contract, notModified } = await loadClientContractSince(input.fetch === undefined
+    const { contract, notModified } = await step(`Fetching the ClientContract (${displayUrl(contractUrlOf(config.entrypoint))})`, async () => loadClientContractSince(input.fetch === undefined
         ? { entrypoint: config.entrypoint }
-        : { entrypoint: config.entrypoint, fetch: input.fetch }, await storedContract(config.generateAt));
-    const emission = emitClientTree(contract, config.entrypoint, {
-        importFileExtension: style.importFileExtension,
-        moduleFormat: style.moduleFormat,
+        : { entrypoint: config.entrypoint, fetch: input.fetch }, await storedContract(config.generateAt)));
+    const { emission, upToDate } = await step("Emitting the client", async () => {
+        const emission = emitClientTree(contract, config.entrypoint, {
+            importFileExtension: style.importFileExtension,
+            moduleFormat: style.moduleFormat,
+        });
+        return {
+            emission,
+            upToDate: notModified &&
+                (await ownedOutputMatches(config.generateAt, emission.tree)),
+        };
     });
-    if (notModified &&
-        (await ownedOutputMatches(config.generateAt, emission.tree))) {
+    if (upToDate) {
         return {
             kind: "up-to-date",
             generateAt: config.generateAt,
@@ -54,7 +66,7 @@ export async function generateClient(input) {
             warnings: emission.warnings,
         };
     }
-    const write = async (overrideForeign) => {
+    const writeInto = async (overrideForeign) => {
         const written = await writeClientOutput(input.resolveTypeScript === undefined
             ? { emission, generateAt: config.generateAt, overrideForeign }
             : {
@@ -72,8 +84,10 @@ export async function generateClient(input) {
             warnings: written.warnings,
         };
     };
+    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

@@ -1,11 +1,12 @@
 import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import path from "node:path";
-import { runGenerate } from "../cli/generate.command.js";
+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";
@@ -39,46 +40,60 @@ 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;
-    for (const write of writes) {
-        const target = path.join(io.cwd, write.path);
-        if (write.content === undefined) {
-            rmSync(target, { force: true });
-            continue;
+    const progress = createStepReporter({
+        write: io.stderr,
+        mode: io.progress ?? "off",
+        total: command.skipInstall
+            ? 1
+            : 2 + (command.skipGenerate ? 0 : GENERATION_STEPS),
+        verbose: command.verbose === true,
+    });
+    await progress.step("Writing the client setup", () => {
+        for (const write of writes) {
+            const target = path.join(io.cwd, write.path);
+            if (write.content === undefined) {
+                rmSync(target, { force: true });
+                continue;
+            }
+            mkdirSync(path.dirname(target), { recursive: true });
+            writeFileSync(target, write.content);
         }
-        mkdirSync(path.dirname(target), { recursive: true });
-        writeFileSync(target, write.content);
-    }
+    });
     io.stdout(`avclient: initialized ${io.cwd}: ${writes.map((write) => (write.content === undefined ? `removed ${write.path}` : write.path)).join(", ") || "nothing to change"}.\n`);
     const install = `${answers.packageManager} install`;
     if (command.skipInstall) {
+        progress.finish("avclient", "done");
         io.stdout(`Next:\n  1. Install @aventara/client ${clientVersion}: ${install}\n  2. With the server running: ${answers.packageManager} run ${GENERATE_SCRIPT}\n`);
         return 0;
     }
-    io.stdout(`avclient: running ${install}…\n`);
-    const installed = await (io.run ?? runCommand)(answers.packageManager, ["install"], {
-        cwd: io.cwd,
+    await progress.step(`Installing dependencies (${install})`, async () => {
+        const installed = await (io.run ?? runCommand)(answers.packageManager, ["install"], {
+            cwd: io.cwd,
+            onOutput: progress.output,
+        });
+        if (installed.code !== 0) {
+            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 (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()}`);
-    }
     if (command.skipGenerate) {
+        progress.finish("avclient", "done");
         io.stdout(`Next: with the server running, ${answers.packageManager} run ${GENERATE_SCRIPT}\n`);
         return 0;
     }
     try {
-        return await runGenerate(io, command.yes);
+        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/init/command.runner.d.ts

@@ -1,6 +1,8 @@
 /** One child process, stdout and stderr piped and collected: `init`'s install. */
 export type CommandRunner = (command: string, args: readonly string[], options: {
     readonly cwd: string;
+    /** Each chunk of the child's stdout and stderr as it arrives (`--verbose`). */
+    readonly onOutput?: (chunk: string) => void;
 }) => Promise<{
     readonly code: number;
     readonly stderr: string;

package/dist/init/command.runner.js

@@ -6,9 +6,12 @@ export const runCommand = (command, args, options) => new Promise((resolve, reje
         env: process.env,
     });
     let stderr = "";
-    child.stdout.resume();
+    child.stdout.setEncoding("utf8").on("data", (chunk) => {
+        options.onOutput?.(chunk);
+    });
     child.stderr.setEncoding("utf8").on("data", (chunk) => {
         stderr += chunk;
+        options.onOutput?.(chunk);
     });
     child.once("error", reject);
     child.once("close", (code) => {

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": "0.1.0-pilot.4",
+  "version": "1.0.0-rc.1",
   "license": "SEE LICENSE IN LICENSE",
   "description": "Development-time generator for Aventara typed remote clients.",
   "type": "module",
@@ -20,10 +20,11 @@
   },
   "files": [
     "dist",
-    "LICENSE-ADDITIONAL-PERMISSION.md"
+    "LICENSE-ADDITIONAL-PERMISSION.md",
+    "CHANGELOG.md"
   ],
   "dependencies": {
-    "@aventara/core": "0.1.0-pilot.4",
+    "@aventara/core": "1.0.0-rc.1",
     "c12": "3.3.4",
     "get-tsconfig": "4.10.0"
   },
@@ -39,12 +40,12 @@
     "access": "public"
   },
   "devDependencies": {
-    "@aventara/testing": "0.1.0-pilot.4",
+    "@aventara/testing": "1.0.0-rc.1",
     "@types/node": "24.10.1",
     "typescript": "^5.9.2"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.json --removeComments --declaration false && tsc -p tsconfig.json --emitDeclarationOnly && node ../../scripts/build/declaration-comments.sanitizer.ts dist",
+    "build": "node ../../scripts/build/build-output.cleaner.ts dist && tsc -p tsconfig.json --removeComments --declaration false && tsc -p tsconfig.json --emitDeclarationOnly && node ../../scripts/build/declaration-comments.sanitizer.ts dist",
     "typecheck": "tsc -p tsconfig.typecheck.json --noEmit",
     "test": "vitest run --typecheck --config ../../vitest.config.mts --root .",
     "lint": "biome lint src"