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

package/dist/init/client-init.planner.js

@@ -1,13 +1,5 @@
-import { CLIENT_CONFIG_FILE, LEGACY_CLIENT_CONFIG_FILE, } from "../config/config.loader.js";
+import { CLIENT_CONFIG_FILE } from "../config/config.loader.js";
 import { clientConfigSource } from "./client-config.template.js";
-/**
- * §4.5 — what `avclient init` writes, decided before anything is: the config
- * file, the `.env` entry (only with a variable), the `avclient:generate` script
- * and the exact devDependency (N6) — each computed with existing content kept
- * and replaced, and every **conflict** (content it did not produce) named for
- * the generateAt rule.
- */
-/** R4: the script a frontend regenerates its client with. */
 export const GENERATE_SCRIPT = "avclient:generate";
 const ENV_LINE = /^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*?)\s*$/;
 function unquoted(value) {
@@ -29,23 +21,13 @@ export function planClientInit(input) {
             replacing.push({ path, content: replaced });
         }
     };
-    const config = clientConfigSource(answers);
-    const existingConfig = project.read(CLIENT_CONFIG_FILE);
-    // pilot.1: a `framework.client.ts` is moved to `framework.client.mts` — two
-    // configs would make `avclient generate` refuse. The one pilot.0 wrote for
-    // these answers moves without asking; anything else is a conflict.
-    const legacyConfig = project.read(LEGACY_CLIENT_CONFIG_FILE);
-    if (legacyConfig !== undefined) {
-        if (legacyConfig !== clientConfigSource(answers, LEGACY_CLIENT_CONFIG_FILE)) {
-            conflicts.push(`${LEGACY_CLIENT_CONFIG_FILE} (replaced by ${CLIENT_CONFIG_FILE})`);
-        }
-        keeping.push({ path: LEGACY_CLIENT_CONFIG_FILE, content: undefined });
-        replacing.push({ path: LEGACY_CLIENT_CONFIG_FILE, content: undefined });
-    }
+    const configFile = project.configFile ?? CLIENT_CONFIG_FILE;
+    const config = clientConfigSource(answers, configFile);
+    const existingConfig = project.read(configFile);
     if (existingConfig !== undefined && existingConfig !== config) {
-        conflicts.push(CLIENT_CONFIG_FILE);
+        conflicts.push(configFile);
     }
-    add(CLIENT_CONFIG_FILE, existingConfig, existingConfig ?? config, config);
+    add(configFile, existingConfig, existingConfig ?? config, config);
     if (answers.envVar !== undefined) {
         const before = project.read(".env");
         const lines = before === undefined || before === ""
@@ -65,6 +47,16 @@ export function planClientInit(input) {
             replaced[at] = line;
         }
         add(".env", before, `${kept.join("\n")}\n`, `${replaced.join("\n")}\n`);
+        const ignore = project.read(".gitignore");
+        const ignored = (ignore ?? "")
+            .split("\n")
+            .some((line) => line.trim() === ".env");
+        if (!ignored) {
+            const appended = ignore === undefined || ignore === ""
+                ? ".env\n"
+                : `${ignore.endsWith("\n") ? ignore : `${ignore}\n`}.env\n`;
+            add(".gitignore", ignore, appended, appended);
+        }
     }
     const manifest = (replace) => {
         const parsed = JSON.parse(project.manifestText);

package/dist/init/client-init.questions.d.ts

@@ -1,18 +1,11 @@
-/**
- * R4, R5, Q16 rows 12–15 — `avclient init`'s questions in one table: each
- * question's flag, label and default, from which the command line, the prompt,
- * `--yes`'s defaults and the non-interactive refusal are derived — the rule
- * `@aventara/cli`'s wizard follows, implemented here because the two packages
- * never import each other (P7).
- */
 export declare const PACKAGE_MANAGERS: readonly ["npm", "pnpm"];
 export type PackageManager = (typeof PACKAGE_MANAGERS)[number];
 export type ClientInitAnswers = {
-    /** The deployment's entrypoint (Q16-12: `--entrypoint`, `defineClientConfig`'s key). */
+    /** The deployment's entrypoint. */
     readonly entrypoint: string;
-    /** The variable `framework.client.ts` reads it from, or `undefined` for a literal (Q16-13). */
+    /** The variable `framework.client.ts` reads it from, or `undefined` for a literal. */
     readonly envVar: string | undefined;
-    /** Where the client is generated (Q16-14: `--generate-at`, the config key). */
+    /** Where the client is generated. */
     readonly generateAt: string;
     readonly packageManager: PackageManager;
 };
@@ -34,7 +27,7 @@ export type ClientInitQuestion = {
     /** @throws ClientInitAnswerError */
     readonly parse: (raw: string) => string;
 };
-/** The project convention for the variable (spec §15.2). */
+/** The project convention for the variable. */
 export declare const DEFAULT_ENV_VAR = "AVENTARA_API_URL";
 export declare const CLIENT_INIT_QUESTIONS: readonly ClientInitQuestion[];
 export type ClientInitSources = {
@@ -47,6 +40,9 @@ export type ClientInitSources = {
     readonly say: (line: string) => void;
     readonly detectedPackageManager: PackageManager;
 };
-/** Flag → `--yes`'s default → the prompt → the refusal naming exactly the unanswered flags (R5). */
+/**
+ * Flag → `--yes`'s default → the prompt → the refusal naming exactly the
+ * unanswered flags.
+ */
 export declare function resolveClientInitAnswers(sources: ClientInitSources): Promise<ClientInitAnswers>;
 export {};

package/dist/init/client-init.questions.js

@@ -1,21 +1,11 @@
 import { resolveEntrypoint } from "../config/config.resolver.js";
-/**
- * R4, R5, Q16 rows 12–15 — `avclient init`'s questions in one table: each
- * question's flag, label and default, from which the command line, the prompt,
- * `--yes`'s defaults and the non-interactive refusal are derived — the rule
- * `@aventara/cli`'s wizard follows, implemented here because the two packages
- * never import each other (P7).
- */
 export const PACKAGE_MANAGERS = ["npm", "pnpm"];
-/** An answer the question cannot take. A refusal: one sentence. */
 export class ClientInitAnswerError extends Error {
     name = "ClientInitAnswerError";
 }
-/** Nobody can answer and some questions are unanswered. A refusal: one sentence. */
 export class ClientInitUnansweredError extends Error {
     name = "ClientInitUnansweredError";
 }
-/** The project convention for the variable (spec §15.2). */
 export const DEFAULT_ENV_VAR = "AVENTARA_API_URL";
 export const CLIENT_INIT_QUESTIONS = [
     {
@@ -77,7 +67,6 @@ export const CLIENT_INIT_QUESTIONS = [
         },
     },
 ];
-/** Flag → `--yes`'s default → the prompt → the refusal naming exactly the unanswered flags (R5). */
 export async function resolveClientInitAnswers(sources) {
     const answered = {};
     const missing = [];

package/dist/init/client-project.inspector.d.ts

@@ -7,6 +7,12 @@ export declare class ClientProjectRefusedError extends Error {
 export type ClientProject = {
     readonly directory: string;
     readonly manifestText: string;
+    /**
+     * Its `framework.client.<ext>`, by name, when it has one — `undefined` when it
+     * has none. Two or more are refused while inspecting, as `avclient generate`
+     * refuses them.
+     */
+    readonly configFile: string | undefined;
     /** The package manager its lockfile names, if exactly one does. */
     readonly lockfile: PackageManager | undefined;
     /** The current text of a project file, or `undefined`. */

package/dist/init/client-project.inspector.js

@@ -1,7 +1,6 @@
 import { existsSync, readFileSync } from "node:fs";
 import path from "node:path";
-/** The frontend `avclient init` serves, read before anything is asked or written. */
-/** The directory is not a project `avclient init` can set up. A refusal: nothing written. */
+import { findClientConfigFile } from "../config/config.loader.js";
 export class ClientProjectRefusedError extends Error {
     name = "ClientProjectRefusedError";
 }
@@ -19,6 +18,7 @@ export function inspectClientProject(directory) {
     return {
         directory,
         manifestText: readFileSync(manifest, "utf8"),
+        configFile: findClientConfigFile(directory),
         lockfile: lockfiles.length === 1 ? lockfiles[0] : undefined,
         read: (file) => {
             try {

package/dist/node-version.guard.js

@@ -1,4 +1,3 @@
-// biome-ignore lint/style/useNodejsImportProtocol: Node 14.0–14.13.0 resolves no "node:" specifier in an ES module, and this module runs on the Nodes the packages do not support.
 import { readFileSync } from "fs";
 function versionOf(text) {
     const match = /^v?(\d+)\.(\d+)\.(\d+)/.exec(text);
@@ -16,11 +15,6 @@ function compareVersions(left, right) {
     }
     return 0;
 }
-/**
- * Whether `range` admits `version`. Reads `^x.y.z` (the same major, from the
- * floor; majors ≥ 1) and `>=x.y.z`, joined by `||`; anything else throws rather
- * than admit or refuse by guess.
- */
 function admits(range, version) {
     return range.split("||").some((part) => {
         const comparator = /^\s*(\^|>=)(\d+\.\d+\.\d+)\s*$/.exec(part);
@@ -32,17 +26,11 @@ function admits(range, version) {
             (comparator[1] === ">=" || version[0] === floor[0]));
     });
 }
-/** The sentence a bin answers on `version`, or `undefined` when `range` admits it. */
 export function nodeVersionRefusal(bin, packageName, range, version) {
     return admits(range, versionOf(version))
         ? undefined
         : `${bin}: Node ${version} is not supported; ${packageName} needs Node ${range}.`;
 }
-/**
- * Reads the manifest at `manifestUrl`; on a Node its `engines.node` does not
- * admit, writes the sentence to stderr, sets exit code 1 and answers `true` —
- * the bin then loads nothing else.
- */
 export function refuseUnsupportedNode(bin, manifestUrl) {
     const manifest = JSON.parse(readFileSync(manifestUrl, "utf8"));
     const range = manifest.engines === undefined ? undefined : manifest.engines.node;

package/dist/output/output.validator.d.ts

@@ -1,30 +1,32 @@
 import type * as ts from "typescript";
-import type { EmittedTree } from "../emit/emitted-tree.interface.js";
+import type { ClientEmission } from "../emit/emitted-tree.interface.js";
 /**
- * §15.3's "type/sanity validation" step, between emit-to-temp and the replace:
- * the gate that makes the atomicity worth having (plan §4 Q6). It judges a
- * directory the writer has just filled with `tree`, and answers with a value — the
- * writer decides what a rejection means for the previous output.
+ * It judges a directory the writer has just filled with `tree`, and answers with a
+ * value — the writer decides what a rejection means for the previous output.
  *
  * # Three checks, the strongest available first
  *
  * - **Shape**, always: the directory holds exactly `tree` — no file missing, none
- *   extra, every one byte-for-byte what was emitted — and every file carries the
- *   ownership line. That last is not decoration: the NEXT run reads it to decide
- *   that this directory is a previous generation it may replace whole, so a file
- *   without it would make the next run refuse.
- * - **Types**, when the `typescript` optional peer resolves (Q5, Q6): a real
- *   program over the tree under a consumer's strictest plausible settings. The
- *   tree is judged ALONE — the compiler host serves nothing outside the directory
- *   but TypeScript's own `lib` files, so an import the tree cannot satisfy itself
- *   fails here even when a `node_modules` beside the output could satisfy it
- *   (§15.5).
+ *   extra, every one byte-for-byte what was emitted — every file carries the
+ *   ownership line, and every module a file names is a file of the tree, spelled
+ *   the project's way. The ownership line is not decoration: the NEXT run reads it
+ *   to decide that this directory is a previous generation it may replace whole,
+ *   so a file without it would make the next run refuse. The imports are read
+ *   lexically (`module-specifier.scanner.ts`), with no compiler — so a wrongly
+ *   spelled import is refused even where the type check cannot run (TypeScript 7).
+ * - **Types**, when the `typescript` optional peer resolves FROM THE PROJECT in
+ *   its peer range: a real program over the tree under a consumer's strictest
+ *   plausible settings, in the project's module resolution and format
+ *   (`compilerOptionsFor`). The tree is judged ALONE — the compiler host serves
+ *   nothing outside the directory but TypeScript's own `lib` files, so an import
+ *   the tree cannot satisfy itself fails here even when a `node_modules` beside
+ *   the output could satisfy it.
  * - **Syntax**, when it does not — or when the `typescript` that resolves has no
- *   classic compiler API (TypeScript 7, plan B3; pilot.1): each file through
- *   Node's own TypeScript parser (`node:module`'s `stripTypeScriptTypes`), with a
- *   loud warning that the output was NOT type-checked. Degraded, never skipped
- *   (S7), and never a refusal: the developer's own `tsc` still checks the tree
- *   when their project compiles.
+ *   classic compiler API: each file through Node's own TypeScript parser
+ *   (`node:module`'s `stripTypeScriptTypes`, its ExperimentalWarning held back),
+ *   with a loud warning of our own that the output was NOT type-checked. Degraded,
+ *   never skipped, and never a refusal: the developer's own `tsc` still checks the
+ *   tree when their project compiles.
  */
 /** The `typescript` module, as the validator uses it. */
 export type TypeScriptCompiler = typeof ts;
@@ -35,12 +37,23 @@ export type TypeScriptCompiler = typeof ts;
  */
 export type TypeScriptResolver = () => Promise<TypeScriptCompiler | undefined>;
 /**
- * A resolver for `specifier`, looked up from this package the way Node would look
- * it up: an optional peer is linked beside the package that declares it.
+ * A resolver for `specifier`, looked up from `directory` the way Node looks up
+ * a package from a file there: its `node_modules`, then each parent's.
  */
-export declare function typeScriptResolverFor(specifier: string): TypeScriptResolver;
-/** The `typescript` this package's optional peer names (Q5). */
-export declare const resolveInstalledTypeScript: TypeScriptResolver;
+export declare function typeScriptResolverFor(specifier: string, directory: string): TypeScriptResolver;
+/**
+ * The `typescript` of the project that compiles the client, resolved from its
+ * `generateAt`. Never this package's own: run through `npx`, the generator is
+ * installed in npm's cache, where its optional peer never is — and the type check
+ * is a stand-in for the project's own `tsc`, so the project's compiler is the one
+ * that answers.
+ */
+export declare function projectTypeScriptResolver(generateAt: string): TypeScriptResolver;
+/**
+ * The lowest `typescript` the generator type-checks with: this package's
+ * optional peer range, `>=5.5.0` (`packaging-gate.spec.ts` holds the two equal).
+ */
+export declare const MINIMUM_TYPESCRIPT = "5.5.0";
 /** How deeply the tree was judged. */
 export type OutputCheck = "types" | "syntax" | "shape";
 export interface OutputAccepted {
@@ -70,6 +83,15 @@ export declare const SYNTAX_CHECK_UNAVAILABLE_WARNING: string;
  */
 export declare function typeScriptWithoutCompilerApiWarning(version: string, checked: "syntax" | "shape"): string;
 /**
- * Judges `directory`, which the caller has just filled with `tree`.
+ * The warning a run carries when the project's `typescript` is older than the
+ * peer range: its compiler API lacks options the check sets (`Bundler`
+ * resolution, `verbatimModuleSyntax`), so its verdict would not be the one a
+ * supported compiler gives.
+ */
+export declare function typeScriptBelowRangeWarning(version: string, checked: "syntax" | "shape"): string;
+/**
+ * Judges `directory`, which the caller has just filled with `tree`, with the
+ * `typescript` `resolveTypeScript` finds — the project's
+ * ({@link projectTypeScriptResolver}).
  */
-export declare function validateOutputTree(directory: string, tree: EmittedTree, resolveTypeScript?: TypeScriptResolver): Promise<OutputValidation>;
+export declare function validateOutputTree(directory: string, emission: Pick<ClientEmission, "style" | "tree">, resolveTypeScript: TypeScriptResolver): Promise<OutputValidation>;

package/dist/output/output.validator.js

@@ -4,15 +4,12 @@ import { createRequire } from "node:module";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
 import { carriesGeneratedOwnership } from "../emit/banner.emitter.js";
-/**
- * A resolver for `specifier`, looked up from this package the way Node would look
- * it up: an optional peer is linked beside the package that declares it.
- */
-export function typeScriptResolverFor(specifier) {
+import { scanModuleSpecifiers } from "../emit/module-specifier.scanner.js";
+export function typeScriptResolverFor(specifier, directory) {
     return async () => {
         let resolved;
         try {
-            resolved = createRequire(import.meta.url).resolve(specifier);
+            resolved = createRequire(path.join(directory, "package.json")).resolve(specifier);
         }
         catch (error) {
             if (isErrorWithCode(error, "MODULE_NOT_FOUND")) {
@@ -24,58 +21,73 @@ export function typeScriptResolverFor(specifier) {
         return loaded.default ?? loaded;
     };
 }
-/** The `typescript` this package's optional peer names (Q5). */
-export const resolveInstalledTypeScript = typeScriptResolverFor("typescript");
-/**
- * Whether `compiler` has the classic compiler API {@link typeFindingsOf} uses.
- * TypeScript 7 does not (plan B3: its package exports its version and nothing
- * else); before pilot.1 the generator refused it, and its peer range stopped
- * below it — which made `npm i` fail with ERESOLVE in any frontend whose
- * `typescript` is the current `latest`.
- */
+export function projectTypeScriptResolver(generateAt) {
+    return typeScriptResolverFor("typescript", generateAt);
+}
+export const MINIMUM_TYPESCRIPT = "5.5.0";
+function meetsMinimum(version) {
+    const parts = /^(\d+)\.(\d+)\.(\d+)/.exec(version);
+    const minimum = MINIMUM_TYPESCRIPT.split(".").map(Number);
+    if (parts === null) {
+        return false;
+    }
+    for (let at = 0; at < 3; at += 1) {
+        const have = Number(parts[at + 1]);
+        const need = minimum[at];
+        if (have !== need) {
+            return have > need;
+        }
+    }
+    return true;
+}
 function hasClassicCompilerApi(compiler) {
-    // One member, not `Partial<typeof ts>`: a mapped type over the whole
-    // compiler namespace costs thousands of instantiations to ask one question.
     return (typeof compiler.createProgram ===
         "function");
 }
-/** The version a resolved `typescript` names, whatever its API. */
 function versionOf(compiler) {
     const { version } = compiler;
     return typeof version === "string" ? version : "(no version)";
 }
-/**
- * The warning a run without `typescript` carries. Loud on purpose, in its words:
- * the prefix is the CLI's one `warning:`, so the text carries none of its own.
- */
 export const TYPESCRIPT_UNRESOLVED_WARNING = "`typescript` could not be resolved, so the generated output was NOT type-checked — " +
     "only its shape and syntax were. Install `typescript` (an optional peer of @aventara/client) " +
     "in this project to restore the type check.";
-/** The warning a run with neither `typescript` nor Node's parser carries. */
 export const SYNTAX_CHECK_UNAVAILABLE_WARNING = "neither `typescript` nor Node's TypeScript parser is available, so the generated " +
     "output was NOT type-checked or parsed — only its shape was. Install `typescript` (an " +
     "optional peer of @aventara/client) in this project to restore the type check.";
-/**
- * The warning a run carries when the `typescript` that resolves is one the
- * generator cannot type-check with (TypeScript 7): what was checked instead,
- * and where the type check still happens.
- */
 export function typeScriptWithoutCompilerApiWarning(version, checked) {
     return (`the installed \`typescript\` ${version} has no classic compiler API (\`createProgram\`), so the generated ` +
         `output was NOT type-checked${checked === "shape" ? " or parsed — only its shape was" : " — only its shape and syntax were"}. ` +
         "Your project's own `tsc` checks it when it compiles; a `typescript` 5.5 to 6 restores the generator's own type check.");
 }
-/**
- * Judges `directory`, which the caller has just filled with `tree`.
- */
-export async function validateOutputTree(directory, tree, resolveTypeScript = resolveInstalledTypeScript) {
-    const shapeFindings = await shapeFindingsOf(directory, tree);
+export function typeScriptBelowRangeWarning(version, checked) {
+    return (`the installed \`typescript\` ${version} is older than ${MINIMUM_TYPESCRIPT}, the lowest @aventara/client supports, so the generated ` +
+        `output was NOT type-checked${checked === "shape" ? " or parsed — only its shape was" : " — only its shape and syntax were"}. ` +
+        `Upgrade the project's \`typescript\` to ${MINIMUM_TYPESCRIPT} or later to restore the type check.`);
+}
+function degradedWarning(compiler, checked) {
+    if (compiler === undefined) {
+        return checked === "syntax"
+            ? TYPESCRIPT_UNRESOLVED_WARNING
+            : SYNTAX_CHECK_UNAVAILABLE_WARNING;
+    }
+    if (!hasClassicCompilerApi(compiler)) {
+        return typeScriptWithoutCompilerApiWarning(versionOf(compiler), checked);
+    }
+    if (!meetsMinimum(versionOf(compiler))) {
+        return typeScriptBelowRangeWarning(versionOf(compiler), checked);
+    }
+    return undefined;
+}
+export async function validateOutputTree(directory, emission, resolveTypeScript) {
+    const { tree, style } = emission;
+    const shapeFindings = await shapeFindingsOf(directory, tree, style);
     if (shapeFindings.length > 0) {
         return { accepted: false, checked: "shape", findings: shapeFindings };
     }
     const compiler = await resolveTypeScript();
-    if (compiler !== undefined && hasClassicCompilerApi(compiler)) {
-        const findings = typeFindingsOf(compiler, directory, tree);
+    if (compiler !== undefined &&
+        degradedWarning(compiler, "syntax") === undefined) {
+        const findings = typeFindingsOf(compiler, directory, tree, style);
         return findings.length > 0
             ? { accepted: false, checked: "types", findings }
             : { accepted: true, checked: "types", warnings: [] };
@@ -85,11 +97,7 @@ export async function validateOutputTree(directory, tree, resolveTypeScript = re
         return {
             accepted: true,
             checked: "shape",
-            warnings: [
-                compiler === undefined
-                    ? SYNTAX_CHECK_UNAVAILABLE_WARNING
-                    : typeScriptWithoutCompilerApiWarning(versionOf(compiler), "shape"),
-            ],
+            warnings: [degradedWarning(compiler, "shape")],
         };
     }
     const findings = syntaxFindingsOf(strip, tree);
@@ -98,17 +106,10 @@ export async function validateOutputTree(directory, tree, resolveTypeScript = re
         : {
             accepted: true,
             checked: "syntax",
-            warnings: [
-                compiler === undefined
-                    ? TYPESCRIPT_UNRESOLVED_WARNING
-                    : typeScriptWithoutCompilerApiWarning(versionOf(compiler), "syntax"),
-            ],
+            warnings: [degradedWarning(compiler, "syntax")],
         };
 }
-/* ------------------------------------------------------------------ *
- * Shape                                                                *
- * ------------------------------------------------------------------ */
-async function shapeFindingsOf(directory, tree) {
+async function shapeFindingsOf(directory, tree, style) {
     const findings = [];
     const expected = new Map(tree.map((file) => [file.path, file.bytes]));
     const entries = await readdir(directory, {
@@ -151,29 +152,50 @@ async function shapeFindingsOf(directory, tree) {
         if (!carriesGeneratedOwnership(text)) {
             findings.push(`${relative}: does not carry the generated banner`);
         }
+        for (const specifier of scanModuleSpecifiers(text).specifiers) {
+            if (!namesTreeFile(relative, specifier, style, expected)) {
+                findings.push(`${relative}: imports ${JSON.stringify(specifier)}, which is not a file of the emitted tree spelled with ${JSON.stringify(style.importFileExtension)}`);
+            }
+        }
     }
     return findings.sort();
 }
-/* ------------------------------------------------------------------ *
- * Types: a real program over the tree, and nothing outside it          *
- * ------------------------------------------------------------------ */
-/**
- * The emitted-tree fixture's settings (`__fixtures__/emitted-tree.fixture.ts`),
- * restated here because production code does not import a test fixture: a
- * consumer's strictest plausible configuration, with no DOM and no Node (§15.7:
- * both are first-class targets, so the tree may assume neither).
- */
-function compilerOptionsFor(compiler) {
+function namesTreeFile(file, specifier, style, tree) {
+    if (!specifier.startsWith("./") && !specifier.startsWith("../")) {
+        return false;
+    }
+    const target = path.posix.normalize(path.posix.join(path.posix.dirname(file), specifier));
+    const extension = file.startsWith("generated/derivation/")
+        ? ".js"
+        : style.importFileExtension === ""
+            ? ""
+            : `.${style.importFileExtension}`;
+    const spelled = extension === ""
+        ? !/\.[cm]?[jt]s$/.test(target)
+        : target.endsWith(extension);
+    if (!spelled) {
+        return false;
+    }
+    const stem = target.slice(0, target.length - extension.length);
+    return tree.has(`${stem}.ts`) || tree.has(`${stem}.d.ts`);
+}
+function compilerOptionsFor(compiler, style) {
+    const bundler = style.importFileExtension === "" && style.moduleFormat === "esm";
     return {
         target: compiler.ScriptTarget.ES2022,
-        module: compiler.ModuleKind.NodeNext,
-        moduleResolution: compiler.ModuleResolutionKind.NodeNext,
+        module: bundler ? compiler.ModuleKind.ESNext : compiler.ModuleKind.NodeNext,
+        moduleResolution: bundler
+            ? compiler.ModuleResolutionKind.Bundler
+            : compiler.ModuleResolutionKind.NodeNext,
+        ...(style.importFileExtension === "ts"
+            ? { allowImportingTsExtensions: true }
+            : {}),
         lib: ["lib.es2022.d.ts"],
         types: [],
         strict: true,
         noUncheckedIndexedAccess: true,
         exactOptionalPropertyTypes: true,
-        verbatimModuleSyntax: true,
+        verbatimModuleSyntax: style.moduleFormat === "esm",
         isolatedModules: true,
         erasableSyntaxOnly: true,
         noUnusedLocals: true,
@@ -186,15 +208,12 @@ function compilerOptionsFor(compiler) {
         noEmit: true,
     };
 }
-/**
- * The tree is served as an ES module package of its own: NodeNext reads the
- * nearest `package.json` to decide a `.ts` file's module format, and the one a
- * consumer's project happens to have must not decide this verdict.
- */
-const VIRTUAL_PACKAGE_JSON = '{ "type": "module" }';
-function typeFindingsOf(compiler, directory, tree) {
+function virtualPackageManifest(style) {
+    return `{ "type": "${style.moduleFormat === "esm" ? "module" : "commonjs"}" }`;
+}
+function typeFindingsOf(compiler, directory, tree, style) {
     const root = path.resolve(directory);
-    const options = compilerOptionsFor(compiler);
+    const options = compilerOptionsFor(compiler, style);
     const libraryDirectory = path.dirname(compiler.getDefaultLibFilePath(options));
     const virtualPackageJson = path.join(root, "package.json");
     const servable = (file) => isInside(root, file) || isInside(libraryDirectory, file);
@@ -205,7 +224,7 @@ function typeFindingsOf(compiler, directory, tree) {
     host.fileExists = (file) => path.resolve(file) === virtualPackageJson ||
         (servable(path.resolve(file)) && baseFileExists(file));
     host.readFile = (file) => path.resolve(file) === virtualPackageJson
-        ? VIRTUAL_PACKAGE_JSON
+        ? virtualPackageManifest(style)
         : servable(path.resolve(file))
             ? baseReadFile(file)
             : undefined;
@@ -229,16 +248,36 @@ function typeFindingsOf(compiler, directory, tree) {
     })
         .trimEnd());
 }
-/** Whether `file` is `directory` or lies beneath it. */
 function isInside(directory, file) {
     const relative = path.relative(directory, file);
     return (relative === "" ||
         (!relative.startsWith("..") && !path.isAbsolute(relative)));
 }
-/** Node's TypeScript parser, where this Node has one. */
 function nodeTypeScriptParser() {
     const candidate = nodeModule.stripTypeScriptTypes;
-    return typeof candidate === "function" ? candidate : undefined;
+    if (typeof candidate !== "function") {
+        return undefined;
+    }
+    return (source) => {
+        const emitWarning = process.emitWarning;
+        process.emitWarning = function (warning, ...rest) {
+            const [kind] = rest;
+            const type = typeof kind === "string"
+                ? kind
+                : kind?.type;
+            if (type === "ExperimentalWarning" &&
+                String(warning).startsWith("stripTypeScriptTypes ")) {
+                return;
+            }
+            emitWarning.call(this, warning, ...rest);
+        };
+        try {
+            return candidate(source);
+        }
+        finally {
+            process.emitWarning = emitWarning;
+        }
+    };
 }
 function syntaxFindingsOf(strip, tree) {
     const decoder = new TextDecoder("utf-8");