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

package/dist/config/config.loader.js

@@ -1,77 +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.mts` (or, for a setup
- * written before pilot.1, `framework.client.ts`), default-exporting
- * `defineClientConfig({ entrypoint, generateAt })` as §15.2 writes it. One file,
- * looked up in one directory — no search up the tree, no `package.json` key —
- * and when both spellings are present the run refuses rather than choose: two
- * files would be two sources of the same fact.
- *
- * Why `.mts` (pilot.1): `npm init -y` writes `"type": "commonjs"`, under which
- * Node reads a `.ts` file as CommonJS and the config's `import`/`export` stop
- * the run. A `.mts` file is an ES module in every project. A `.ts` config that
- * fails that way is told to rename itself.
- *
- * 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 `avclient init` writes: an ES module whatever the project's `type` (pilot.1). */
-export const CLIENT_CONFIG_FILE = "framework.client.mts";
-/** §15.2's spelling, still read for the setups written before pilot.1. */
-export const LEGACY_CLIENT_CONFIG_FILE = "framework.client.ts";
-/**
- * Evaluates `<directory>/framework.client.mts`, or `framework.client.ts` when
- * only that one is there.
- *
- * @throws ClientConfigError, in one line, when neither or both are there, or
- *   the file does not evaluate, or does not default-export a client config.
- */
-export async function loadClientConfigFile(directory) {
-    const present = [CLIENT_CONFIG_FILE, LEGACY_CLIENT_CONFIG_FILE].filter((name) => existsSync(path.resolve(directory, name)));
+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) {
-        throw new ClientConfigError(`both ${CLIENT_CONFIG_FILE} and ${LEGACY_CLIENT_CONFIG_FILE} are in ${path.resolve(directory)}, and only one may configure the generator; keep ${CLIENT_CONFIG_FILE} and delete ${LEGACY_CLIENT_CONFIG_FILE}.`);
+        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" : ""}.`);
     }
-    const [name] = present;
+    return present[0];
+}
+export async function loadClientConfigFile(directory) {
+    const name = findClientConfigFile(directory);
     if (name === undefined) {
-        throw new ClientConfigError(`no ${CLIENT_CONFIG_FILE} at ${path.resolve(directory, CLIENT_CONFIG_FILE)}; create it with ` +
+        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)}${name === LEGACY_CLIENT_CONFIG_FILE && error instanceof SyntaxError
-            ? `; if this project's package.json says "type": "commonjs" (npm init -y writes it), Node reads a .ts file as CommonJS — rename it ${CLIENT_CONFIG_FILE}, which is an ES module in every project`
-            : ""}`, { cause: 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) {
@@ -88,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;

package/dist/config/module-style.resolver.js

@@ -0,0 +1,75 @@
+import { readFileSync, statSync } from "node:fs";
+import path from "node:path";
+import { ClientConfigError } 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));
+    }
+    return {
+        tsconfig: located.path,
+        importFileExtension: importFileExtensionOf(located.config),
+        moduleFormat: moduleFormatOf(located, input.generateAt),
+    };
+}
+export function noTsconfigRefusal(generateAt) {
+    return (`no tsconfig.json was found in ${generateAt} or any directory above it. ` +
+        "Aventara's generated client is TypeScript, compiled by your project's own toolchain and written the way " +
+        "its tsconfig.json says; JavaScript projects are not supported yet. Add a tsconfig.json to the project " +
+        "(`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) {
+    const options = config.compilerOptions;
+    if (options?.allowImportingTsExtensions ||
+        options?.rewriteRelativeImportExtensions) {
+        return "ts";
+    }
+    const moduleResolution = options?.moduleResolution?.toLowerCase();
+    return options?.module?.toLowerCase() === "commonjs" ||
+        moduleResolution === "bundler"
+        ? ""
+        : "js";
+}
+export function moduleFormatOf(tsconfig, generateAt) {
+    const module = tsconfig.config.compilerOptions?.module?.toLowerCase();
+    if (module === undefined || module === "") {
+        return "esm";
+    }
+    if (module === "commonjs") {
+        return "cjs";
+    }
+    if (module === "node16" || module === "nodenext") {
+        return packageTypeFormat(generateAt);
+    }
+    return "esm";
+}
+function packageTypeFormat(directory) {
+    const manifest = nearestPackageJson(directory);
+    if (manifest === undefined) {
+        return "cjs";
+    }
+    try {
+        return JSON.parse(readFileSync(manifest, "utf8"))
+            .type === "module"
+            ? "esm"
+            : "cjs";
+    }
+    catch {
+        return "cjs";
+    }
+}
+function nearestPackageJson(directory) {
+    for (let current = path.resolve(directory);;) {
+        const candidate = path.join(current, "package.json");
+        if (statSync(candidate, { throwIfNoEntry: false })?.isFile() === true) {
+            return candidate;
+        }
+        const parent = path.dirname(current);
+        if (parent === current) {
+            return undefined;
+        }
+        current = parent;
+    }
+}

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

@@ -0,0 +1,45 @@
+import { type TsConfigJsonResolved } from "get-tsconfig";
+/**
+ * Which `tsconfig.json` the generated client is spelled for
+ * (`module-style.resolver.ts`): the project's own, found the way Prisma 7's
+ * `prisma-client` generator finds it — `get-tsconfig`'s `getTsconfig`, the very
+ * library and version Prisma 7.10 bundles, searching from the output directory
+ * up, `extends` chains merged — with one step Prisma does not take.
+ *
+ * # A solution-style root (Vite's layout)
+ *
+ * `npm create vite` writes a `tsconfig.json` that compiles nothing — `"files":
+ * []` and `references` to `tsconfig.app.json` and `tsconfig.node.json` — so the
+ * nearest config names no compiler option at all. When the config found does
+ * not include the generated entry file and has `references`, the referenced
+ * project that does include it is the one used, the first in `references`
+ * order — how TypeScript's own language service picks a file's project. With
+ * none including it, the root stays the answer, as it is Prisma's.
+ *
+ * # `tsconfigFile`
+ *
+ * The escape hatch for a layout this discovery gets wrong (a monorepo, a
+ * non-standard name): the config's `tsconfigFile`, resolved against the config
+ * file's directory, used as named — no search, no reference step. A missing or
+ * unreadable one is refused, naming the path it resolved to.
+ */
+/** The tsconfig a run follows: its path and its resolved content (`extends` merged). */
+export interface LocatedTsconfig {
+    readonly path: string;
+    readonly config: TsConfigJsonResolved;
+}
+export interface TsconfigLocation {
+    /** The absolute `generateAt`: the search starts there. */
+    readonly generateAt: string;
+    /** The generated entry file the project must include, absolute. */
+    readonly entryFile: string;
+    /** The config's `tsconfigFile`, already absolute; the search otherwise. */
+    readonly tsconfigFile?: string;
+}
+/**
+ * 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.
+ */
+export declare function locateTsconfig(location: TsconfigLocation): LocatedTsconfig | undefined;

package/dist/config/tsconfig.locator.js

@@ -0,0 +1,52 @@
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { createFilesMatcher, getTsconfig, parseTsconfig, } from "get-tsconfig";
+import { ClientConfigError } from "./config.resolver.js";
+export function locateTsconfig(location) {
+    if (location.tsconfigFile !== undefined) {
+        return namedTsconfig(location.tsconfigFile);
+    }
+    const found = getTsconfig(location.generateAt);
+    if (found === null) {
+        return undefined;
+    }
+    if (found.config.references === undefined ||
+        createFilesMatcher(found)(location.entryFile) !== undefined) {
+        return found;
+    }
+    for (const reference of found.config.references) {
+        const referenced = referencedTsconfig(found.path, reference.path);
+        if (referenced !== undefined &&
+            createFilesMatcher(referenced)(location.entryFile) !== undefined) {
+            return referenced;
+        }
+    }
+    return found;
+}
+function namedTsconfig(file) {
+    try {
+        readFileSync(file, "utf8");
+        return { path: file, config: parseTsconfig(file) };
+    }
+    catch (error) {
+        const reason = error instanceof Error && "code" in error
+            ? String(error.code)
+            : error instanceof Error
+                ? error.message
+                : String(error);
+        throw new ClientConfigError(`tsconfigFile names ${file}, which could not be read (${reason}); it must name the tsconfig.json your project compiles the generated client with.`);
+    }
+}
+function referencedTsconfig(from, reference) {
+    const target = path.resolve(path.dirname(from), reference);
+    for (const candidate of [target, path.join(target, "tsconfig.json")]) {
+        try {
+            readFileSync(candidate, "utf8");
+        }
+        catch {
+            continue;
+        }
+        return { path: candidate, config: parseTsconfig(candidate) };
+    }
+    return undefined;
+}