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

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

@@ -1,6 +1,7 @@
-export interface GenerationFailureReport {
+interface GenerationFailureReport {
     readonly exitCode: number;
     /** What goes to stderr, newline-terminated: the warnings carried, then the sentence. */
     readonly text: string;
 }
 export declare function renderGenerationFailure(error: unknown): GenerationFailureReport;
+export {};

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/generation-success.renderer.d.ts

@@ -6,7 +6,7 @@ import type { ClientGenerated, ClientUpToDate, ForeignOutputContent } from "../g
  * them — renames, the degraded check, crash recovery — so the same run prints the
  * same lines.
  */
-export interface GenerationSuccessReport {
+interface GenerationSuccessReport {
     /** What goes to stdout, newline-terminated. */
     readonly stdout: string;
     /** What goes to stderr: one line per warning, or nothing. */
@@ -29,3 +29,4 @@ export declare const FOREIGN_CONTENT_QUESTION = "avclient: overwrite them and ge
  * are reported as a refused one's are.
  */
 export declare function renderForeignContentCancellation(found: ForeignOutputContent, asked: boolean): string;
+export {};

package/dist/cli/step.reporter.d.ts

@@ -1,7 +1,7 @@
 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 = {
+type StepReporterOptions = {
     /** Where the lines go: the tool's stderr, so its stdout stays its result. */
     readonly write: (text: string) => void;
     readonly mode: ProgressMode;
@@ -29,3 +29,4 @@ export type StepReporter = {
 /** `12.4s`, or `1m 02s` from a minute. */
 export declare function formatElapsed(milliseconds: number): string;
 export declare function createStepReporter(options: StepReporterOptions): StepReporter;
+export {};

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

@@ -1,6 +1,7 @@
-export type TerminalPrompter = {
+type TerminalPrompter = {
     readonly ask: (prompt: string) => Promise<string>;
     readonly confirm: (question: string) => Promise<boolean>;
     readonly close: () => void;
 };
 export declare function createTerminalPrompter(): TerminalPrompter;
+export {};

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

@@ -1,33 +1,40 @@
 /** 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.
      */
     readonly tsconfigFile?: string;
+    /**
+     * The origins other than the entrypoint's that `$access` may send a
+     * sign-in to (`"https://auth.example.com"`): where the deployment mounted
+     * Aventara Access, when that is another origin. Absent, the generator
+     * refuses a ClientContract whose Access URL is on another origin.
+     */
+    readonly accessOrigins?: readonly AvClientConfigValue[];
 }
 /** A filesystem path known to be absolute. */
 export type AbsolutePath = string & {
@@ -44,11 +51,21 @@ export interface ClientEntrypoint {
     readonly deployment: URL;
     readonly path: EntrypointPath;
 }
+/** An entrypoint on the page's own origin: its mount path alone, such as `/api`. */
+export interface SameOriginEntrypoint {
+    /** Absent: the deployment is whichever origin served the page. */
+    readonly deployment?: undefined;
+    readonly path: EntrypointPath;
+}
+/** The entrypoint a generated client embeds as its default: a deployment's, or the page's own origin. */
+export type EmittedEntrypoint = ClientEntrypoint | SameOriginEntrypoint;
 export interface ResolvedClientConfig {
     readonly entrypoint: ClientEntrypoint;
     /** `generateAt`, made absolute. */
     readonly generateAt: AbsolutePath;
     /** `tsconfigFile`, made absolute; absent when the config names none. */
     readonly tsconfigFile?: AbsolutePath;
+    /** `accessOrigins`, each an http(s) origin (`scheme://host[:port]`); empty when the config names none. */
+    readonly accessOrigins: readonly string[];
     readonly mode: string;
 }

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

@@ -1,14 +1,18 @@
-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. */
-export declare const CLIENT_CONFIG_BASENAME = "framework.client";
+/**
+ * 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 file `avclient init` writes when the project has none. */
 export declare const CLIENT_CONFIG_FILE = "framework.client.ts";
-export interface LoadedClientConfig {
+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 +24,14 @@ 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>;
+export {};

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,7 +9,15 @@ export const CLIENT_CONFIG_FILE_EXTENSIONS = [
     ".mts",
     ".cts",
 ];
-export const CLIENT_CONFIG_BASENAME = "framework.client";
+export const CLIENT_CONFIG_FILE_EXTENSIONS_AS_LISTED = [
+    ".ts",
+    ".mts",
+    ".cts",
+    ".js",
+    ".mjs",
+    ".cjs",
+];
+const CLIENT_CONFIG_BASENAME = "framework.client";
 export const CLIENT_CONFIG_FILE = `${CLIENT_CONFIG_BASENAME}.ts`;
 export function clientConfigFilesIn(directory) {
     return CLIENT_CONFIG_FILE_EXTENSIONS.map((extension) => `${CLIENT_CONFIG_BASENAME}${extension}`).filter((name) => statSync(path.resolve(directory, name), {
@@ -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,24 +61,33 @@ 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)}.`);
+    }
+    const accessOrigins = members.accessOrigins;
+    if (accessOrigins !== undefined && !Array.isArray(accessOrigins)) {
+        throw new AvClientConfigError(`${file}'s accessOrigins must be a list of origins ("https://auth.example.com"), each a string or env("NAME").`);
     }
     return {
         entrypoint: configValueOf(file, "entrypoint", members.entrypoint),
         generateAt: configValueOf(file, "generateAt", members.generateAt),
         ...(tsconfigFile === undefined ? {} : { tsconfigFile }),
+        ...(accessOrigins === undefined
+            ? {}
+            : {
+                accessOrigins: accessOrigins.map((origin) => configValueOf(file, "accessOrigins", origin)),
+            }),
     };
 }
 function configValueOf(file, member, value) {
@@ -84,7 +102,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, EmittedEntrypoint, ResolvedClientConfig, SameOriginEntrypoint } 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;
+interface ClientConfigResolutionInput {
+    readonly config: AvClientConfigInput;
     readonly cascade: EnvCascadeResolution;
     /** The directory holding the config file; `generateAt` resolves against it. */
     readonly configDirectory: string;
@@ -23,7 +23,14 @@ 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;
+/**
+ * The same-origin entrypoint of a framework mounted at `api`.
+ *
+ * @throws AvClientConfigError when `api` is not a mount path.
+ */
+export declare function sameOriginEntrypoint(api: string): SameOriginEntrypoint;
+export declare function entrypointHref(entrypoint: EmittedEntrypoint): string;
+export {};

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),
@@ -24,18 +24,36 @@ export function resolveClientConfig(input) {
             : {
                 tsconfigFile: path.resolve(input.configDirectory, tsconfigFile),
             }),
+        accessOrigins: (input.config.accessOrigins ?? []).map((origin) => resolveAccessOrigin(resolveValue("accessOrigins", origin, input.cascade))),
         mode: input.cascade.mode,
     };
 }
+function resolveAccessOrigin(value) {
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        url = undefined;
+    }
+    if (url === undefined ||
+        (url.protocol !== "http:" && url.protocol !== "https:") ||
+        url.username !== "" ||
+        url.password !== "" ||
+        url.origin !== value.replace(/\/$/u, "").toLowerCase()) {
+        throw new AvClientConfigError('accessOrigins holds a value that is no http(s) origin; each must be scheme, host and port alone ("https://auth.example.com").');
+    }
+    return url.origin;
+}
 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 +61,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 = "/";
@@ -77,7 +95,17 @@ export function resolveEntrypoint(value) {
 function writtenMountPath(value) {
     return value.replace(/^[A-Za-z][A-Za-z0-9+.-]*:[/\\]*[^/\\?#]*/u, "");
 }
+export function sameOriginEntrypoint(api) {
+    const normalized = AvProtocol.normalizeEntrypoint(api);
+    if (!normalized.ok) {
+        throw new AvClientConfigError(`api ${normalized.message}.`);
+    }
+    return { path: normalized.path };
+}
 export function entrypointHref(entrypoint) {
+    if (entrypoint.deployment === undefined) {
+        return entrypoint.path;
+    }
     const url = new URL(entrypoint.deployment.href);
     url.pathname = entrypoint.path === "" ? "/" : entrypoint.path;
     return url.href.replace(/\/$/, "");

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

@@ -2,10 +2,8 @@
 export type EnvRecord = Readonly<Record<string, string>>;
 /** The process environment as Node types it: values may be `undefined`. */
 export type ProcessEnvInput = Readonly<Record<string, string | undefined>>;
-/** The mode used when neither an explicit mode nor `NODE_ENV` supplies one. */
-export declare const DEFAULT_ENV_MODE = "development";
 export type EnvFileReader = (filePath: string) => string | undefined;
-export interface EnvCascadeInput {
+interface EnvCascadeInput {
     /** The directory the five candidates are looked up in. */
     readonly directory: string;
     /** A snapshot of the process environment. Never mutated. */
@@ -23,18 +21,15 @@ 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. */
 export declare function envCascadeCandidates(mode: string): readonly string[];
-export declare function resolveEnvMode(processEnv: ProcessEnvInput, explicit?: string): string;
 export declare function resolveEnvCascade(input: EnvCascadeInput): EnvCascadeResolution;
-/** Reads a candidate from disk; `ENOENT` alone means "not there". */
-export declare function readEnvFileFromDisk(filePath: string): string | undefined;
 /**
  * Parses one file's content. A file whose content holds a line the parser would
  * silently discard is malformed: the user wrote something they expect to take
@@ -50,3 +45,4 @@ export declare function parseEnvFile(filePath: string, content: string): Record<
  * spanning lines — or, when there is none, to the end of its own line.
  */
 export declare function firstDiscardedLine(content: string): number | undefined;
+export {};

package/dist/config/env.cascade.js

@@ -1,11 +1,11 @@
 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 {
+const DEFAULT_ENV_MODE = "development";
+export class AvEnvFileError extends Error {
     filePath;
     reason;
-    name = "EnvFileError";
+    name = "AvEnvFileError";
     constructor(filePath, reason, detail) {
         super(`${filePath}: ${detail}`);
         this.filePath = filePath;
@@ -15,7 +15,7 @@ export class EnvFileError extends Error {
 export function envCascadeCandidates(mode) {
     return [`.env.${mode}.local`, `.env.${mode}`, ".env.local", ".env"];
 }
-export function resolveEnvMode(processEnv, explicit) {
+function resolveEnvMode(processEnv, explicit) {
     if (explicit !== undefined && explicit !== "")
         return explicit;
     const nodeEnv = processEnv.NODE_ENV;
@@ -44,7 +44,7 @@ export function resolveEnvCascade(input) {
     }
     return { mode, env: Object.freeze(env), candidates, loaded };
 }
-export function readEnvFileFromDisk(filePath) {
+function readEnvFileFromDisk(filePath) {
     try {
         return readFileSync(filePath, "utf8");
     }
@@ -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

@@ -1,12 +1,10 @@
-import type { TsConfigJsonResolved } from "get-tsconfig";
-import type { ClientModuleStyle, ImportFileExtension, ModuleFormat } from "../emit/module-style.interface.js";
-import { type LocatedTsconfig } from "./tsconfig.locator.js";
+import type { ClientModuleStyle } from "../emit/module-style.interface.js";
 /** What the run follows, and where it read it from. */
 export interface ResolvedModuleStyle extends ClientModuleStyle {
     /** The tsconfig the style was inferred from. */
     readonly tsconfig: string;
 }
-export interface ModuleStyleInput {
+interface ModuleStyleInput {
     /** The absolute `generateAt`. */
     readonly generateAt: string;
     /** The generated entry file, absolute: the file the project must include. */
@@ -17,11 +15,10 @@ 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;
 /** The refusal of a project with no tsconfig: a JavaScript project. */
 export declare function noTsconfigRefusal(generateAt: string): string;
-export declare function importFileExtensionOf(config: TsConfigJsonResolved): ImportFileExtension;
-export declare function moduleFormatOf(tsconfig: LocatedTsconfig, generateAt: string): ModuleFormat;
+export {};

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,
@@ -20,7 +20,7 @@ export function noTsconfigRefusal(generateAt) {
         "(`npx tsc --init` writes one), or, if it has one this search does not find, name it with `tsconfigFile` " +
         "in your framework.client config. Nothing was written.");
 }
-export function importFileExtensionOf(config) {
+function importFileExtensionOf(config) {
     const options = config.compilerOptions;
     if (options?.allowImportingTsExtensions ||
         options?.rewriteRelativeImportExtensions) {
@@ -32,7 +32,7 @@ export function importFileExtensionOf(config) {
         ? ""
         : "js";
 }
-export function moduleFormatOf(tsconfig, generateAt) {
+function moduleFormatOf(tsconfig, generateAt) {
     const module = tsconfig.config.compilerOptions?.module?.toLowerCase();
     if (module === undefined || module === "") {
         return "esm";

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

@@ -4,7 +4,7 @@ export interface LocatedTsconfig {
     readonly path: string;
     readonly config: TsConfigJsonResolved;
 }
-export interface TsconfigLocation {
+interface TsconfigLocation {
     /** The absolute `generateAt`: the search starts there. */
     readonly generateAt: string;
     /** The generated entry file the project must include, absolute. */
@@ -16,6 +16,7 @@ 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;
+export {};