@aventara/client 0.0.0-stage → 0.1.0-pilot.0

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

@@ -0,0 +1,54 @@
+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 { UnsupportedTypeScriptError } from "../output/output.validator.js";
+import { OutputWriteError, warningsRaisedBeforeDefect, } from "../output/output.writer.js";
+import { CliCommandError } from "./command.parser.js";
+import { renderWarningLines } from "./warning.renderer.js";
+/**
+ * How a failed generation reaches the person running it (M3, the adapter CLI's
+ * precedent): a refusal is a sentence and a non-zero exit code, never a stack — a
+ * stack printed over it buries the sentence that says what to do. Anything else is
+ * a defect and keeps its stack.
+ *
+ * A refusal that stopped a run part-way carries what the run said before it —
+ * a crash recovered, a name renamed — and those lines come first, in the order a
+ * success prints them, so nothing the run did goes unreported because it failed.
+ * A defect's come first too, then its stack, whole.
+ */
+/** Every error the generator raises on purpose. One list, read by `instanceof`. */
+const REFUSALS = [
+    CliCommandError,
+    ClientConfigError,
+    EnvFileError,
+    ContractTransportError,
+    ContractProtocolError,
+    GeneratedNameError,
+    OutputWriteError,
+    UnsupportedTypeScriptError,
+    ClientInitAnswerError,
+    ClientInitUnansweredError,
+    ClientProjectRefusedError,
+    ClientInitNotConfirmedError,
+    ClientInitStepError,
+];
+export function renderGenerationFailure(error) {
+    if (REFUSALS.some((refusal) => error instanceof refusal)) {
+        const carried = error instanceof OutputWriteError ? error.warnings : [];
+        return {
+            // A refused contract carries its own (plan §7); the other refusals are 1,
+            // the adapter CLI's precedent (M3).
+            exitCode: error instanceof ContractProtocolError ? error.exitCode : 1,
+            text: `${renderWarningLines(carried)}avclient: ${error.message}\n`,
+        };
+    }
+    return {
+        exitCode: 1,
+        text: `${renderWarningLines(warningsRaisedBeforeDefect(error))}${String(error instanceof Error ? error.stack : error)}\n`,
+    };
+}

package/dist/cli/generation-success.renderer.d.ts

@@ -0,0 +1,32 @@
+import type { ClientGenerated, ClientUpToDate, ForeignOutputContent } from "../generate.js";
+/**
+ * How a generation that succeeded reaches the person running it: one line on
+ * stdout saying what was written where and how deeply it was checked, and every
+ * warning the run raised on its own stderr line, in the order the run returned
+ * them — renames, the degraded check, crash recovery — so the same run prints the
+ * same lines.
+ */
+export interface GenerationSuccessReport {
+    /** What goes to stdout, newline-terminated. */
+    readonly stdout: string;
+    /** What goes to stderr: one line per warning, or nothing. */
+    readonly stderr: string;
+}
+export declare function renderGenerationSuccess(result: ClientGenerated): GenerationSuccessReport;
+/** Nothing written (Phase 12-rest Q6): the deployment's ClientContract and these bytes are what is there. */
+export declare function renderUpToDate(result: ClientUpToDate): GenerationSuccessReport;
+/**
+ * What the person running the generator is told before being asked: every path
+ * in `AvClient.ts` and `generated/` that the generator did not produce, which
+ * proceeding overwrites or removes.
+ */
+export declare function renderForeignContentWarning(found: ForeignOutputContent): string;
+/** The question; answered yes, generation proceeds. */
+export declare const FOREIGN_CONTENT_QUESTION = "avclient: overwrite them and generate? [y/N] ";
+/**
+ * Nobody confirmed: nothing was touched. One sentence naming what to sort out —
+ * and, where nobody could have been asked, the flag that answers yes — after
+ * every warning the run raised before it stopped, so a cancelled run's renames
+ * are reported as a refused one's are.
+ */
+export declare function renderForeignContentCancellation(found: ForeignOutputContent, asked: boolean): string;

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

@@ -0,0 +1,47 @@
+import { renderWarningLines, WARNING_LINE_PREFIX } from "./warning.renderer.js";
+export function renderGenerationSuccess(result) {
+    const count = result.files.length;
+    return {
+        stdout: `avclient: ${result.contractUnchanged ? "regenerated" : "generated"} ${count} ${count === 1 ? "file" : "files"} into ` +
+            `${result.generateAt} (checked: ${result.checked})` +
+            (result.contractUnchanged
+                ? ": the ClientContract is unchanged; the generator or the entrypoint changed.\n"
+                : ".\n"),
+        stderr: renderWarningLines(result.warnings),
+    };
+}
+/** Nothing written (Phase 12-rest Q6): the deployment's ClientContract and these bytes are what is there. */
+export function renderUpToDate(result) {
+    return {
+        stdout: `avclient: up to date: ${result.generateAt} already holds this deployment's client; nothing was written.\n`,
+        stderr: renderWarningLines(result.warnings),
+    };
+}
+/**
+ * What the person running the generator is told before being asked: every path
+ * in `AvClient.ts` and `generated/` that the generator did not produce, which
+ * proceeding overwrites or removes.
+ */
+export function renderForeignContentWarning(found) {
+    return (`${WARNING_LINE_PREFIX}${found.foreign.join(", ")} in ${found.generateAt} ` +
+        `${found.foreign.length === 1 ? "was" : "were"} not generated by @aventara/client, ` +
+        "and generating will overwrite or remove " +
+        `${found.foreign.length === 1 ? "it" : "them"}.\n`);
+}
+/** The question; answered yes, generation proceeds. */
+export const FOREIGN_CONTENT_QUESTION = "avclient: overwrite them and generate? [y/N] ";
+/**
+ * Nobody confirmed: nothing was touched. One sentence naming what to sort out —
+ * and, where nobody could have been asked, the flag that answers yes — after
+ * every warning the run raised before it stopped, so a cancelled run's renames
+ * are reported as a refused one's are.
+ */
+export function renderForeignContentCancellation(found, asked) {
+    const them = found.foreign.length === 1 ? "it" : "them";
+    return `${renderWarningLines(found.warnings)}${asked
+        ? `avclient: cancelled, and nothing was touched; move ${found.foreign.join(", ")} out of ${found.generateAt}, ` +
+            `or run again and answer yes to overwrite ${them}.\n`
+        : `avclient: not generating, and nothing was touched: ${found.foreign.join(", ")} in ${found.generateAt} ` +
+            `${found.foreign.length === 1 ? "was" : "were"} not generated by @aventara/client and nobody can be asked ` +
+            `(stdin is not a terminal); move ${them} out, or run \`avclient generate --yes\` to overwrite ${them}.\n`}`;
+}

package/dist/cli/terminal.prompter.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The terminal's questions — `generate`'s yes/no and `init`'s wizard — over one
+ * `node:readline` interface whose lines are **queued**: a line typed (or piped
+ * into a pseudo-terminal) before its question is kept for it, where a fresh
+ * interface per question, or `readline/promises`' `question`, drops it (measured
+ * in `@aventara/cli`'s S5; the same rule there, P7).
+ */
+export type TerminalPrompter = {
+    readonly ask: (prompt: string) => Promise<string>;
+    readonly confirm: (question: string) => Promise<boolean>;
+    readonly close: () => void;
+};
+export declare function createTerminalPrompter(): TerminalPrompter;

package/dist/cli/terminal.prompter.js

@@ -0,0 +1,53 @@
+import { createInterface } from "node:readline";
+export function createTerminalPrompter() {
+    let session;
+    let ended = false;
+    const lines = [];
+    const waiting = [];
+    const open = () => {
+        if (session === undefined) {
+            session = createInterface({
+                input: process.stdin,
+                output: process.stderr,
+            });
+            session.on("line", (line) => {
+                const next = waiting.shift();
+                if (next === undefined) {
+                    lines.push(line);
+                }
+                else {
+                    next.resolve(line);
+                }
+            });
+            session.once("close", () => {
+                ended = true;
+                for (const next of waiting.splice(0)) {
+                    next.reject(new Error("the terminal was closed before the question was answered"));
+                }
+            });
+        }
+        return session;
+    };
+    const ask = (prompt) => {
+        const readline = open();
+        readline.setPrompt(prompt);
+        readline.prompt();
+        const typed = lines.shift();
+        if (typed !== undefined) {
+            return Promise.resolve(typed);
+        }
+        if (ended) {
+            return Promise.resolve("");
+        }
+        return new Promise((resolve, reject) => {
+            waiting.push({ resolve, reject });
+        });
+    };
+    return {
+        ask,
+        confirm: async (question) => /^y(?:es)?$/i.test((await ask(question)).trim()),
+        close: () => {
+            session?.close();
+        },
+    };
+}

package/dist/cli/warning.renderer.d.ts

@@ -0,0 +1,10 @@
+/**
+ * How one warning reaches the person running the generator: its own stderr line,
+ * under the CLI's one prefix. Warnings carry no prefix of their own, so the line
+ * says "warning" once (S7b's report: the degraded check used to say it twice).
+ * Shared by a success and a refusal, so a warning reads the same either way.
+ */
+/** The prefix every warning line opens with. */
+export declare const WARNING_LINE_PREFIX = "avclient: warning: ";
+/** One newline-terminated line per warning, in the order given; empty for none. */
+export declare function renderWarningLines(warnings: readonly string[]): string;

package/dist/cli/warning.renderer.js

@@ -0,0 +1,14 @@
+/**
+ * How one warning reaches the person running the generator: its own stderr line,
+ * under the CLI's one prefix. Warnings carry no prefix of their own, so the line
+ * says "warning" once (S7b's report: the degraded check used to say it twice).
+ * Shared by a success and a refusal, so a warning reads the same either way.
+ */
+/** The prefix every warning line opens with. */
+export const WARNING_LINE_PREFIX = "avclient: warning: ";
+/** One newline-terminated line per warning, in the order given; empty for none. */
+export function renderWarningLines(warnings) {
+    return warnings
+        .map((warning) => `${WARNING_LINE_PREFIX}${warning}\n`)
+        .join("");
+}

package/dist/cli.d.ts

@@ -0,0 +1,29 @@
+import { type CliIo } from "./cli/generate.command.js";
+export type { CliIo } from "./cli/generate.command.js";
+/**
+ * `avclient` — the generator's bin (`avclient generate`), S7b.
+ *
+ * It parses the command line, runs §15.3's pipeline (`generate.ts`) in the
+ * current directory, and owns the terminal: the success line goes to stdout,
+ * every warning the run returned to stderr in the run's order, and a failure
+ * through the refusal renderer — a refusal is one sentence and exit 1 with no
+ * stack (M3), anything else is a defect and keeps its stack.
+ *
+ * It is also the one place that ASKS (architect, 2026-10-04): when content the
+ * generator did not produce stands in `AvClient.ts` or `generated/`, the paths
+ * are listed and the person is asked whether to overwrite them. `--yes` answers
+ * for them. Where nobody can answer — stdin is not a terminal — it never asks
+ * and never overrides: it refuses, naming `--yes`. Cancelled or refused, nothing
+ * was touched, the run's warnings are printed before the sentence, and the exit
+ * code is 1. A killed run's leftovers are looked at before the question, so the
+ * answer — and `--yes` — covers what it hid as well.
+ */
+/** Runs one command line; resolves to the exit code. Never throws. */
+export declare function runCli(argv: readonly string[], io: CliIo): Promise<number>;
+/**
+ * Runs `avclient` over this process — its arguments, its terminal, its exit
+ * code. Called by the bin's entry (`avclient.bin.ts`) once the Node guard has
+ * admitted this Node; importing this module runs nothing, which is what lets
+ * `runCli` be tested in process.
+ */
+export declare function runFromProcess(): Promise<void>;

package/dist/cli.js

@@ -0,0 +1,71 @@
+import { parseCliCommand, USAGE } from "./cli/command.parser.js";
+import { runGenerate } from "./cli/generate.command.js";
+import { renderGenerationFailure } from "./cli/generation-failure.renderer.js";
+import { createTerminalPrompter } from "./cli/terminal.prompter.js";
+import { runClientInit } from "./init/client-init.orchestrator.js";
+import { runCommand } from "./init/command.runner.js";
+/**
+ * `avclient` — the generator's bin (`avclient generate`), S7b.
+ *
+ * It parses the command line, runs §15.3's pipeline (`generate.ts`) in the
+ * current directory, and owns the terminal: the success line goes to stdout,
+ * every warning the run returned to stderr in the run's order, and a failure
+ * through the refusal renderer — a refusal is one sentence and exit 1 with no
+ * stack (M3), anything else is a defect and keeps its stack.
+ *
+ * It is also the one place that ASKS (architect, 2026-10-04): when content the
+ * generator did not produce stands in `AvClient.ts` or `generated/`, the paths
+ * are listed and the person is asked whether to overwrite them. `--yes` answers
+ * for them. Where nobody can answer — stdin is not a terminal — it never asks
+ * and never overrides: it refuses, naming `--yes`. Cancelled or refused, nothing
+ * was touched, the run's warnings are printed before the sentence, and the exit
+ * code is 1. A killed run's leftovers are looked at before the question, so the
+ * answer — and `--yes` — covers what it hid as well.
+ */
+/** Runs one command line; resolves to the exit code. Never throws. */
+export async function runCli(argv, io) {
+    try {
+        const command = parseCliCommand(argv);
+        if (command.command === "help") {
+            io.stdout(USAGE);
+            return 0;
+        }
+        if (command.command === "init") {
+            return await runClientInit(command, io);
+        }
+        return await runGenerate(io, command.yes);
+    }
+    catch (error) {
+        const failure = renderGenerationFailure(error);
+        io.stderr(failure.text);
+        return failure.exitCode;
+    }
+}
+/**
+ * Runs `avclient` over this process — its arguments, its terminal, its exit
+ * code. Called by the bin's entry (`avclient.bin.ts`) once the Node guard has
+ * admitted this Node; importing this module runs nothing, which is what lets
+ * `runCli` be tested in process.
+ */
+export async function runFromProcess() {
+    const terminal = createTerminalPrompter();
+    try {
+        process.exitCode = await runCli(process.argv.slice(2), {
+            cwd: process.cwd(),
+            env: { ...process.env },
+            stdout: (text) => {
+                process.stdout.write(text);
+            },
+            stderr: (text) => {
+                process.stderr.write(text);
+            },
+            interactive: process.stdin.isTTY === true,
+            confirm: terminal.confirm,
+            ask: terminal.ask,
+            run: runCommand,
+        });
+    }
+    finally {
+        terminal.close();
+    }
+}

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

@@ -0,0 +1,62 @@
+/**
+ * The generator's configuration, in its two states (plan §7, group 1).
+ *
+ * `ClientConfigInput` is what a `framework.client.ts` default-exports through
+ * `defineClientConfig`. It is passive data: an environment variable appears as
+ * an `EnvReference`, a NAME to look up, so the file can be evaluated without the
+ * environment having been loaded into the global and resolution stays a pure
+ * function of the input and an `EnvRecord`.
+ *
+ * `ResolvedClientConfig` is what later slices consume: the one §15.2 entrypoint
+ * split into the deployment it addresses and its canonical mount path,
+ * `generateAt` made absolute, and the mode the cascade resolved under.
+ */
+/** A deferred read of one environment variable from the resolved cascade. */
+export interface EnvReference {
+    readonly kind: "env";
+    readonly name: string;
+}
+/** A value written literally, or read from the resolved environment. */
+export type ConfigValue = string | EnvReference;
+export interface ClientConfigInput {
+    /** The full deployed framework entrypoint: origin plus mount path (§15.2). */
+    readonly entrypoint: ConfigValue;
+    /**
+     * The directory the client is generated into, relative to the config file's
+     * directory (architect, 2026-10-04). It is SHARED: the generator owns only
+     * `AvClient.ts` and `generated/` in it, and never touches anything else there.
+     * Named `generateAt`, not §15.2's `output`, by the architect's decision.
+     */
+    readonly generateAt: ConfigValue;
+}
+/** A filesystem path known to be absolute. */
+export type AbsolutePath = string & {
+    readonly __absolutePath: true;
+};
+/**
+ * A mount path in F-822's canonical form: `""` at the root, otherwise
+ * `/seg(/seg)*` — one leading slash, no trailing slash, no empty segment. Root is
+ * the empty string, not `"/"`, so every route is `path + "/<route>"` with no
+ * special case. Only resolution makes one.
+ */
+export type EntrypointPath = ("" | `/${string}`) & {
+    readonly __entrypointPath: true;
+};
+/**
+ * The deployed entrypoint, normalised once at resolution so every consumer reads
+ * one canonical form (F-822). Joining a route onto it is concatenation.
+ */
+export interface ClientEntrypoint {
+    /**
+     * The deployment the entrypoint addresses: scheme, credentials, host and port.
+     * Its own path is the root and carries nothing; the mount path is `path`.
+     */
+    readonly deployment: URL;
+    readonly path: EntrypointPath;
+}
+export interface ResolvedClientConfig {
+    readonly entrypoint: ClientEntrypoint;
+    /** `generateAt`, made absolute. */
+    readonly generateAt: AbsolutePath;
+    readonly mode: string;
+}

package/dist/config/client-config.interface.js

@@ -0,0 +1,14 @@
+/**
+ * The generator's configuration, in its two states (plan §7, group 1).
+ *
+ * `ClientConfigInput` is what a `framework.client.ts` default-exports through
+ * `defineClientConfig`. It is passive data: an environment variable appears as
+ * an `EnvReference`, a NAME to look up, so the file can be evaluated without the
+ * environment having been loaded into the global and resolution stays a pure
+ * function of the input and an `EnvRecord`.
+ *
+ * `ResolvedClientConfig` is what later slices consume: the one §15.2 entrypoint
+ * split into the deployment it addresses and its canonical mount path,
+ * `generateAt` made absolute, and the mode the cascade resolved under.
+ */
+export {};

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

@@ -0,0 +1,33 @@
+import type { ClientConfigInput } from "./client-config.interface.js";
+/**
+ * Finds and evaluates the client config: `framework.client.ts`, default-exporting
+ * `defineClientConfig({ entrypoint, generateAt })`, exactly as §15.2 writes it. One
+ * file name, looked up in one directory — no search up the tree, no alternative
+ * spellings, no `package.json` key: the specification names one file, and a
+ * second way to configure the generator would be a second source of the same
+ * fact.
+ *
+ * The file is TypeScript and is evaluated by Node itself (type stripping, on by
+ * default in the Node this repository requires), so the generator needs no
+ * compiler to read its own config. What it imports — `@aventara/client` for
+ * `defineClientConfig` and `env` — resolves from the consumer's project, as any
+ * import of theirs would.
+ *
+ * The evaluated value is checked against `ClientConfigInput`'s shape before it
+ * is trusted: the config is the consumer's code, and a typo there should be a
+ * sentence naming the member, not a `TypeError` from deep inside resolution.
+ */
+/** The config file §15.2 names. */
+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;
+}
+/**
+ * Evaluates `<directory>/framework.client.ts`.
+ *
+ * @throws ClientConfigError, in one line, when the file is missing, 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

@@ -0,0 +1,80 @@
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { ClientConfigError } from "./config.resolver.js";
+/**
+ * Finds and evaluates the client config: `framework.client.ts`, default-exporting
+ * `defineClientConfig({ entrypoint, generateAt })`, exactly as §15.2 writes it. One
+ * file name, looked up in one directory — no search up the tree, no alternative
+ * spellings, no `package.json` key: the specification names one file, and a
+ * second way to configure the generator would be a second source of the same
+ * fact.
+ *
+ * The file is TypeScript and is evaluated by Node itself (type stripping, on by
+ * default in the Node this repository requires), so the generator needs no
+ * compiler to read its own config. What it imports — `@aventara/client` for
+ * `defineClientConfig` and `env` — resolves from the consumer's project, as any
+ * import of theirs would.
+ *
+ * The evaluated value is checked against `ClientConfigInput`'s shape before it
+ * is trusted: the config is the consumer's code, and a typo there should be a
+ * sentence naming the member, not a `TypeError` from deep inside resolution.
+ */
+/** The config file §15.2 names. */
+export const CLIENT_CONFIG_FILE = "framework.client.ts";
+/**
+ * Evaluates `<directory>/framework.client.ts`.
+ *
+ * @throws ClientConfigError, in one line, when the file is missing, does not
+ *   evaluate, or does not default-export a client config.
+ */
+export async function loadClientConfigFile(directory) {
+    const file = path.resolve(directory, CLIENT_CONFIG_FILE);
+    if (!existsSync(file)) {
+        throw new ClientConfigError(`no ${CLIENT_CONFIG_FILE} at ${file}; create it with ` +
+            "`export default defineClientConfig({ entrypoint, generateAt })` and run the generator from its directory.");
+    }
+    let evaluated;
+    try {
+        evaluated = (await import(pathToFileURL(file).href));
+    }
+    catch (error) {
+        throw new ClientConfigError(`${file} could not be evaluated: ${firstLineOf(error)}`, { cause: error });
+    }
+    return { file, config: clientConfigOf(file, evaluated) };
+}
+/** The default export, checked member by member against `ClientConfigInput`. */
+function clientConfigOf(file, evaluated) {
+    const shape = "`export default defineClientConfig({ entrypoint, generateAt })`";
+    if (!Object.hasOwn(evaluated, "default")) {
+        throw new ClientConfigError(`${file} has no default export; it must be ${shape}.`);
+    }
+    const config = evaluated.default;
+    if (typeof config !== "object" || config === null || Array.isArray(config)) {
+        throw new ClientConfigError(`${file}'s default export is not an object; it must be ${shape}.`);
+    }
+    const members = config;
+    return {
+        entrypoint: configValueOf(file, "entrypoint", members.entrypoint),
+        generateAt: configValueOf(file, "generateAt", members.generateAt),
+    };
+}
+function configValueOf(file, member, value) {
+    if (typeof value === "string") {
+        return value;
+    }
+    if (typeof value === "object" &&
+        value !== null &&
+        value.kind === "env") {
+        const name = value.name;
+        if (typeof name === "string" && name !== "") {
+            return { kind: "env", name };
+        }
+    }
+    throw new ClientConfigError(`${file}'s ${member} must be a string or env("NAME"), and it is ${value === undefined ? "missing" : "neither"}.`);
+}
+/** An error's message, cut at its first line break: the refusal is one line. */
+function firstLineOf(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return message.split("\n", 1)[0] ?? "";
+}

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

@@ -0,0 +1,50 @@
+import type { ClientConfigInput, ClientEntrypoint, EnvReference, ResolvedClientConfig } from "./client-config.interface.js";
+import type { EnvCascadeResolution } from "./env.cascade.js";
+/** The identity function that gives a `framework.client.ts` its type (§15.2). */
+export declare function defineClientConfig(config: ClientConfigInput): ClientConfigInput;
+/** Names an environment variable to be read from the resolved cascade (§15.2). */
+export declare function env(name: string): EnvReference;
+/**
+ * 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 interface ClientConfigResolutionInput {
+    readonly config: ClientConfigInput;
+    readonly cascade: EnvCascadeResolution;
+    /** The directory holding the config file; `generateAt` resolves against it. */
+    readonly configDirectory: string;
+}
+/**
+ * Resolves a config against an already-resolved cascade. Pure: it reads no
+ * file and no global, so it is tested against literal inputs.
+ */
+export declare function resolveClientConfig(input: ClientConfigResolutionInput): ResolvedClientConfig;
+/**
+ * An entrypoint value resolved to its canonical form (F-822, architect's
+ * decision 2026-10-04; Q15). The URL half is this function's: whitespace (which
+ * the URL parser would trim or drop unseen), a value that is not an absolute
+ * URL, a scheme other than http(s), credentials (Q5, architect 2026-10-05), a
+ * query or fragment (even an empty one, which the parser forgets), and a `..`
+ * segment (which the parser would resolve away) are refused here, reading the
+ * value as written.
+ *
+ * The mount-path half is core's: the path AS WRITTEN — before `URL` has turned
+ * a backslash into a slash, resolved a `.` segment away or percent-encoded a
+ * character — goes to `AvProtocol.normalizeEntrypoint`, the rule the server's
+ * config resolution applies, so the two halves of F-822 cannot disagree
+ * (`entrypoint.parity.spec.ts`). Only its slash spelling is coerced — `api`,
+ * `/api/` and `//api//` are one intent, `/api` — and root is `""`.
+ *
+ * @throws ClientConfigError in one sentence that does not echo the value.
+ */
+export declare function resolveEntrypoint(value: string): ClientEntrypoint;
+/**
+ * The entrypoint as one absolute URL with no trailing slash — the form the
+ * emitted transport joins its routes to (§12.1), and the default a generated
+ * client embeds (§15.2, Q5: `generated/metadata.ts`'s `DEFAULT_ENTRYPOINT`).
+ * Root is the bare origin.
+ */
+export declare function entrypointHref(entrypoint: ClientEntrypoint): string;