@aventara/client 0.1.0-pilot.0 → 0.1.0-pilot.2

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

@@ -1,15 +1,11 @@
 /**
- * The generator's configuration, in its two states (plan §7, group 1).
+ * The generator's configuration, in its two states.
  *
  * `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
+ * `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 {
@@ -19,32 +15,36 @@ export interface EnvReference {
 /** 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). */
+    /** The full deployed framework entrypoint: origin plus mount path. */
     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.
+     * directory. It is SHARED: the generator owns only `AvClient.ts` and `generated/`
+     * in it, and never touches anything else there.
      */
     readonly generateAt: ConfigValue;
+    /**
+     * 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
+     * monorepo, a non-standard name). Absent, the nearest `tsconfig.json` above
+     * `generateAt` (`tsconfig.locator.ts`).
+     */
+    readonly tsconfigFile?: string;
 }
 /** 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.
+ * 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.
+ * one canonical form. Joining a route onto it is concatenation.
  */
 export interface ClientEntrypoint {
     /**
@@ -58,5 +58,7 @@ export interface ResolvedClientConfig {
     readonly entrypoint: ClientEntrypoint;
     /** `generateAt`, made absolute. */
     readonly generateAt: AbsolutePath;
+    /** `tsconfigFile`, made absolute; absent when the config names none. */
+    readonly tsconfigFile?: AbsolutePath;
     readonly mode: string;
 }

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

@@ -1,14 +1 @@
-/**
- * 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

@@ -1,15 +1,18 @@
 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.
+ * Finds and evaluates the client config, `framework.client.<ext>`, the way
+ * Prisma 7 loads `prisma.config.ts` (`@prisma/config` 7.10's
+ * `loadConfigFromFile`): through `c12`, which evaluates it with `jiti`
+ * (`interopDefault`, no module cache), with no `.env` loading, no rc file, no
+ * remote or `extends` layers and no `package.json` key. So any of
+ * {@link CLIENT_CONFIG_FILE_EXTENSIONS} — Prisma's own list — in ES module or
+ * CommonJS syntax, whatever the project's `"type"`, TypeScript included, with
+ * no compiler of the project's needed (pilot.1's `.mts` rule is gone: jiti, not
+ * Node, decides how the file is read).
  *
- * 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
+ * One file, looked up in one directory — no search up the tree — and when more
+ * than one is present the run refuses rather than choose: two files would be
+ * two sources of the same fact. What the file imports — `@aventara/client` for
  * `defineClientConfig` and `env` — resolves from the consumer's project, as any
  * import of theirs would.
  *
@@ -17,7 +20,11 @@ import type { ClientConfigInput } from "./client-config.interface.js";
  * 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. */
+/** 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 config file `avclient init` writes when the project has none. */
 export declare const CLIENT_CONFIG_FILE = "framework.client.ts";
 export interface LoadedClientConfig {
     /** The config file's absolute path; `generateAt` resolves against its directory. */
@@ -25,9 +32,22 @@ export interface LoadedClientConfig {
     readonly config: ClientConfigInput;
 }
 /**
- * Evaluates `<directory>/framework.client.ts`.
+ * The config files present in `directory`, by name, in
+ * {@link CLIENT_CONFIG_FILE_EXTENSIONS} order: none, one, or — refused by
+ * {@link findClientConfigFile} — more.
+ */
+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.
+ */
+export declare function findClientConfigFile(directory: string): string | undefined;
+/**
+ * Evaluates the one `framework.client.<ext>` in `directory`.
  *
- * @throws ClientConfigError, in one line, when the file is missing, does not
- *   evaluate, or does not default-export a client config.
+ * @throws ClientConfigError, 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,62 +1,75 @@
-import { existsSync } from "node:fs";
+import { statSync } 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 const CLIENT_CONFIG_FILE_EXTENSIONS = [
+    ".js",
+    ".ts",
+    ".mjs",
+    ".cjs",
+    ".mts",
+    ".cts",
+];
+export 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), {
+        throwIfNoEntry: false,
+    })?.isFile() === true);
+}
+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" : ""}.`);
+    }
+    return present[0];
+}
 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.");
+    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 ` +
+            "`export default defineClientConfig({ entrypoint, generateAt })` (or run `avclient init`) and run the generator from its directory.");
     }
+    const file = path.resolve(directory, name);
     let evaluated;
     try {
-        evaluated = (await import(pathToFileURL(file).href));
+        const { loadConfig } = await import("c12");
+        const loaded = await loadConfig({
+            cwd: path.dirname(file),
+            name: CLIENT_CONFIG_BASENAME,
+            configFile: file,
+            dotenv: false,
+            rcFile: false,
+            giget: false,
+            extend: false,
+            packageJson: false,
+            jitiOptions: {
+                interopDefault: true,
+                moduleCache: false,
+                extensions: [...CLIENT_CONFIG_FILE_EXTENSIONS],
+            },
+        });
+        evaluated = loaded.layers?.find((layer) => layer.configFile === file)?.config;
     }
     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) {
+function clientConfigOf(file, config) {
     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;
+    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)}.`);
+    }
     return {
         entrypoint: configValueOf(file, "entrypoint", members.entrypoint),
         generateAt: configValueOf(file, "generateAt", members.generateAt),
+        ...(tsconfigFile === undefined ? {} : { tsconfigFile }),
     };
 }
 function configValueOf(file, member, value) {
@@ -73,7 +86,6 @@ function configValueOf(file, member, value) {
     }
     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

@@ -1,8 +1,8 @@
 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). */
+/** The identity function that gives a `framework.client.ts` its type. */
 export declare function defineClientConfig(config: ClientConfigInput): ClientConfigInput;
-/** Names an environment variable to be read from the resolved cascade (§15.2). */
+/** Names an environment variable to be read from the resolved cascade. */
 export declare function env(name: string): EnvReference;
 /**
  * The configuration cannot be resolved. The message is the whole diagnosis — the
@@ -23,28 +23,22 @@ export interface ClientConfigResolutionInput {
  */
 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.
+ * An entrypoint value resolved to its canonical form. 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, 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 `""`.
+ * 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.
+ * The entrypoint as one absolute URL with no trailing slash — the form the emitted
+ * transport joins its routes to, and the default a generated client embeds. Root
+ * is the bare origin.
  */
 export declare function entrypointHref(entrypoint: ClientEntrypoint): string;

package/dist/config/config.resolver.js

@@ -1,30 +1,29 @@
 import path from "node:path";
 import { AvProtocol } from "@aventara/core/protocol";
-/** The identity function that gives a `framework.client.ts` its type (§15.2). */
 export function defineClientConfig(config) {
     return config;
 }
-/** Names an environment variable to be read from the resolved cascade (§15.2). */
 export function env(name) {
     return { kind: "env", name };
 }
-/**
- * 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 class ClientConfigError extends Error {
     name = "ClientConfigError";
 }
-/**
- * Resolves a config against an already-resolved cascade. Pure: it reads no
- * file and no global, so it is tested against literal inputs.
- */
 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.");
+    }
     return {
         entrypoint: resolveEntrypoint(entrypoint),
         generateAt: path.resolve(input.configDirectory, generateAt),
+        ...(tsconfigFile === undefined
+            ? {}
+            : {
+                tsconfigFile: path.resolve(input.configDirectory, tsconfigFile),
+            }),
         mode: input.cascade.mode,
     };
 }
@@ -41,29 +40,7 @@ function resolveValue(field, value, cascade) {
     }
     return resolved;
 }
-/**
- * The refusal's closing clause: what an entrypoint is. Never the value itself —
- * an entrypoint may carry credentials.
- */
 const ENTRYPOINT_IS = "it must be the origin plus a mount path";
-/**
- * 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 function resolveEntrypoint(value) {
     if (/\s/u.test(value)) {
         throw new ClientConfigError(`entrypoint contains whitespace; ${ENTRYPOINT_IS}, written without spaces, tabs or line breaks.`);
@@ -86,8 +63,6 @@ export function resolveEntrypoint(value) {
     if (value.includes("?") || value.includes("#")) {
         throw new ClientConfigError("entrypoint must not carry a query or fragment; it is the origin plus mount path only.");
     }
-    // Over the whole URL, authority included — wider than the mount-path rule,
-    // which refuses a `..` too — so a `..` anywhere keeps its shipped message.
     if (value.split(/[/\\]/u).some(isDotDotSegment)) {
         throw new ClientConfigError(`entrypoint's mount path has a .. segment; ${ENTRYPOINT_IS}, with no dot segments.`);
     }
@@ -99,28 +74,14 @@ export function resolveEntrypoint(value) {
     deployment.pathname = "/";
     return { deployment, path: normalized.path };
 }
-/**
- * The mount path of an http(s) URL exactly as written: everything after the
- * scheme, the slashes that follow it, and the authority. The authority ends
- * where WHATWG URL parsing ends it for a special scheme — at the first `/`,
- * `\`, `?` or `#` — so this is the text the parser turns into `pathname`,
- * before it does.
- */
 function writtenMountPath(value) {
     return value.replace(/^[A-Za-z][A-Za-z0-9+.-]*:[/\\]*[^/\\?#]*/u, "");
 }
-/**
- * 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 function entrypointHref(entrypoint) {
     const url = new URL(entrypoint.deployment.href);
     url.pathname = entrypoint.path === "" ? "/" : entrypoint.path;
     return url.href.replace(/\/$/, "");
 }
-/** `..`, spelled as WHATWG URL resolution recognises it: `.` or `%2e`, any case. */
 function isDotDotSegment(segment) {
     return /^(?:\.|%2e){2}$/iu.test(segment);
 }

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

@@ -1,8 +1,6 @@
 /**
- * §15.2's `.env` cascade, resolved into a returned record.
- *
- * Precedence, highest first: the existing process environment
- * > `.env.<mode>.local` > `.env.<mode>` > `.env.local` > `.env`.
+ * Precedence, highest first: the existing process environment >
+ * `.env.<mode>.local` > `.env.<mode>` > `.env.local` > `.env`.
  *
  * # Why a returned record, and not `process.loadEnvFile`
  *
@@ -11,19 +9,19 @@
  * mechanism here, for three reasons that were measured rather than argued:
  *
  * 1. It writes into the live `process.env`. A resolution that mutates the global
- *    leaks across tests and across invocations in one process; a suite that
- *    passes alone and fails in sequence is exactly that leak.
- * 2. It reports an unreadable file (`EACCES`) as `ENOENT`. Catching `ENOENT`
- *    from it would treat a `.env` the user cannot read as a `.env` that is not
- *    there — a silent wrong answer.
+ *    leaks across tests and across invocations in one process; a suite that passes
+ *    alone and fails in sequence is exactly that leak.
+ * 2. It reports an unreadable file (`EACCES`) as `ENOENT`. Catching `ENOENT` from
+ *    it would treat a `.env` the user cannot read as a `.env` that is not there —
+ *    a silent wrong answer.
  * 3. It silently drops lines that are not assignments. So does `util.parseEnv`;
  *    neither has a notion of a malformed file.
  *
- * So each file is read with `readFileSync` (whose error code is the truth),
- * parsed with `util.parseEnv` (the same parser `loadEnvFile` uses — pinned by a
- * parity test), checked for lines the parser would discard, and folded
- * first-write-wins over the candidates in priority order. Nothing global is
- * read or written: the process environment is an INPUT.
+ * So each file is read with `readFileSync` (whose error code is the truth), parsed
+ * with `util.parseEnv` (the same parser `loadEnvFile` uses — pinned by a parity
+ * test), checked for lines the parser would discard, and folded first-write-wins
+ * over the candidates in priority order. Nothing global is read or written: the
+ * process environment is an INPUT.
  */
 /** A resolved environment: names to values, never `undefined`. */
 export type EnvRecord = Readonly<Record<string, string>>;

package/dist/config/env.cascade.js

@@ -1,9 +1,7 @@
 import { readFileSync } from "node:fs";
 import path from "node:path";
 import { parseEnv } from "node:util";
-/** The mode used when neither an explicit mode nor `NODE_ENV` supplies one. */
 export const DEFAULT_ENV_MODE = "development";
-/** A candidate exists but could not be read, or contains a discarded line. */
 export class EnvFileError extends Error {
     filePath;
     reason;
@@ -14,7 +12,6 @@ export class EnvFileError extends Error {
         this.reason = reason;
     }
 }
-/** The four file candidates for a mode, highest precedence first. */
 export function envCascadeCandidates(mode) {
     return [`.env.${mode}.local`, `.env.${mode}`, ".env.local", ".env"];
 }
@@ -34,8 +31,6 @@ export function resolveEnvCascade(input) {
             env[name] = value;
     }
     const loaded = [];
-    // Highest precedence first: under first-write-wins, the first source to
-    // define a name owns it. Reversing this loop inverts the precedence.
     for (const candidate of candidates) {
         const filePath = path.join(input.directory, candidate);
         const content = read(filePath);
@@ -49,7 +44,6 @@ export function resolveEnvCascade(input) {
     }
     return { mode, env: Object.freeze(env), candidates, loaded };
 }
-/** Reads a candidate from disk; `ENOENT` alone means "not there". */
 export function readEnvFileFromDisk(filePath) {
     try {
         return readFileSync(filePath, "utf8");
@@ -61,12 +55,6 @@ export function readEnvFileFromDisk(filePath) {
         throw new EnvFileError(filePath, "unreadable", `exists but cannot be read (${code ?? "unknown error"})`);
     }
 }
-/**
- * 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
- * effect, and it would not. The error names the line number, never its content
- * — a `.env` line is as likely as not to be a secret.
- */
 export function parseEnvFile(filePath, content) {
     const source = content.startsWith("") ? content.slice(1) : content;
     const discarded = firstDiscardedLine(source);
@@ -76,13 +64,6 @@ export function parseEnvFile(filePath, content) {
     return parseEnv(source);
 }
 const QUOTES = new Set(['"', "'", "`"]);
-/**
- * The 1-based number of the first line `util.parseEnv` would drop, or
- * `undefined`. Mirrors the parser's line model: blank and `#` lines are
- * skipped, an optional `export ` prefix is allowed, and a value opening with a
- * quote runs to the next matching quote anywhere later in the content —
- * spanning lines — or, when there is none, to the end of its own line.
- */
 export function firstDiscardedLine(content) {
     let offset = 0;
     while (offset < content.length) {

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

@@ -0,0 +1,52 @@
+import type { TsConfigJsonResolved } from "get-tsconfig";
+import type { ClientModuleStyle, ImportFileExtension, ModuleFormat } from "../emit/module-style.interface.js";
+import { type LocatedTsconfig } from "./tsconfig.locator.js";
+/**
+ * How the generated client is spelled for the project that compiles it: inferred
+ * from the project's `tsconfig.json` (`tsconfig.locator.ts`) and, under
+ * `node16`/`nodenext`, the nearest `package.json`, by Prisma 7.10's
+ * `prisma-client` rules, mirrored from its CLI with the generated extension fixed
+ * at `ts`:
+ *
+ * importFileExtension
+ *   1. `allowImportingTsExtensions` or `rewriteRelativeImportExtensions` → `ts`;
+ *   2. `module` is `commonjs`, or `moduleResolution` is `bundler` (either case) →
+ *      `""`;
+ *   3. otherwise → `js` (Prisma's `ts → js`).
+ *
+ * moduleFormat
+ *   1. `module` is `commonjs` → `cjs`;
+ *   2. `module` is `node16` or `nodenext` → the nearest `package.json` above
+ *      `generateAt`: `"type": "module"` → `esm`; no `package.json`, an unparseable
+ *      one, or any other `type` → `cjs`;
+ *   3. any other `module` → `esm`; no `module` → `esm` (Prisma's fallback, whose
+ *      `cjs` arm needs a generated `.cts`).
+ *
+ * Prisma falls back to the generated extension when there is no tsconfig; this
+ * generator refuses instead: its client is TypeScript, and a project without a
+ * tsconfig is a JavaScript project, not supported yet.
+ */
+/** 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 {
+    /** The absolute `generateAt`. */
+    readonly generateAt: string;
+    /** The generated entry file, absolute: the file the project must include. */
+    readonly entryFile: string;
+    /** The config's `tsconfigFile`, already absolute. */
+    readonly tsconfigFile?: string;
+}
+/**
+ * The style the project's tsconfig asks for.
+ *
+ * @throws ClientConfigError 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;