ttsc 0.30.4 → 0.31.1

package/lib/compiler/internal/project/resolveProjectIdentity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveProjectIdentity.js","sourceRoot":"","sources":["../../../../src/compiler/internal/project/resolveProjectIdentity.ts"],"names":[],"mappings":"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"}

package/lib/compiler/internal/project/resolveTsconfigExtends.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Resolve one `extends` specifier using ttsc's shared file-candidate rule and
+ * Node package resolution from the declaring config.
+ *
+ * - A specifier naming a file (host-absolute, `./`, or `../`, after `\` is folded
+ *   into `/`) resolves to the first candidate that is a regular file
+ *   (`tsconfigExtendsFileCandidates`), under the spelling it was reached by.
+ * - Any other specifier is resolved like a module from the declaring config: a
+ *   bare package root selects its preset through `package.json#tsconfig`, then
+ *   Node's resolver is asked for the specifier and for the specifier with
+ *   `.json` appended. Selected module paths use realpath when it succeeds and
+ *   retain the selected spelling when it fails. Node's resolver does not
+ *   reproduce every TypeScript-Go module condition or expose its full search
+ *   topology; observers therefore cannot certify module-chain freshness.
+ *
+ * The one rule both of the workspace's config readers use: ttsc's project
+ * reader canonicalizes the answer before it reads the chain further, and
+ * `@ttsc/unplugin` keeps the spelling, since TypeScript anchors a relatively
+ * extended config at the path it was reached by.
+ *
+ * @param tsconfig The declaring config, as the reader named it.
+ * @param specifier The `extends` value as written.
+ * @param onInput Optional observer of lexical file candidates and selected
+ *   module/manifest paths. Module search topology is not completely observed.
+ * @returns The extended config's path.
+ * @throws When the specifier names nothing, or a preset's `package.json` does
+ *   not parse, naming what failed in ttsc's voice.
+ * @evidence contracts/common.md#principled-implementation File inheritance uses exact/.json candidates within the shared host-native classification; bare preset manifests and Node's module resolver supply package selection without claiming universal compiler module-condition parity or complete observed search topology.
+ * @evidence contracts/common.md#clear-and-simple-design One shared config resolver owns file-versus-module selection, with a small manifest-preset helper and an optional input observer rather than a parallel package resolver.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The .json fallback and manifest tsconfig field address supported compiler differences; selected malformed manifests are errors rather than swallowed faults or fixture-specific paths.
+ * @evidence contracts/common.md#meaningful-documentation Native JSDoc distinguishes lexical file spelling, physical module identity, preset selection and observation limits; param and acknowledgment spacing follows the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation Config separators are folded before native file resolution, package presets use createRequire from their declaring config, and filesystem identities use native realpath instead of POSIX path parsing.
+ * @evidence contracts/performance.md#efficient-algorithms File selection performs at most two native stats plus path text construction; package branches can make manifest and entrypoint resolution attempts, parse the selected manifest bytes, test config candidates and attempt realpath. Node's ancestor/package search and native operations have delegated costs, not fixed costs implied by a bounded local branch count.
+ *
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This resolver owns no result cache; Node's internal module-resolution cache is outside its control and therefore cannot justify an owning freshness proof.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources All paths, require objects and parsed manifest data belong to this invocation; no cache registry or process handle is acquired here.
+ */
+export declare function resolveTsconfigExtends(tsconfig: string, specifier: string, onInput?: (file: string) => void): string;

package/lib/compiler/internal/project/resolveTsconfigExtends.js

@@ -0,0 +1,163 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveTsconfigExtends = resolveTsconfigExtends;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_module_1 = require("node:module");
+const node_path_1 = __importDefault(require("node:path"));
+const readJsonFile_1 = require("./readJsonFile");
+const tsconfigExtendsFileCandidates_1 = require("./tsconfigExtendsFileCandidates");
+/**
+ * Resolve one `extends` specifier using ttsc's shared file-candidate rule and
+ * Node package resolution from the declaring config.
+ *
+ * - A specifier naming a file (host-absolute, `./`, or `../`, after `\` is folded
+ *   into `/`) resolves to the first candidate that is a regular file
+ *   (`tsconfigExtendsFileCandidates`), under the spelling it was reached by.
+ * - Any other specifier is resolved like a module from the declaring config: a
+ *   bare package root selects its preset through `package.json#tsconfig`, then
+ *   Node's resolver is asked for the specifier and for the specifier with
+ *   `.json` appended. Selected module paths use realpath when it succeeds and
+ *   retain the selected spelling when it fails. Node's resolver does not
+ *   reproduce every TypeScript-Go module condition or expose its full search
+ *   topology; observers therefore cannot certify module-chain freshness.
+ *
+ * The one rule both of the workspace's config readers use: ttsc's project
+ * reader canonicalizes the answer before it reads the chain further, and
+ * `@ttsc/unplugin` keeps the spelling, since TypeScript anchors a relatively
+ * extended config at the path it was reached by.
+ *
+ * @param tsconfig The declaring config, as the reader named it.
+ * @param specifier The `extends` value as written.
+ * @param onInput Optional observer of lexical file candidates and selected
+ *   module/manifest paths. Module search topology is not completely observed.
+ * @returns The extended config's path.
+ * @throws When the specifier names nothing, or a preset's `package.json` does
+ *   not parse, naming what failed in ttsc's voice.
+ * @evidence contracts/common.md#principled-implementation File inheritance uses exact/.json candidates within the shared host-native classification; bare preset manifests and Node's module resolver supply package selection without claiming universal compiler module-condition parity or complete observed search topology.
+ * @evidence contracts/common.md#clear-and-simple-design One shared config resolver owns file-versus-module selection, with a small manifest-preset helper and an optional input observer rather than a parallel package resolver.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The .json fallback and manifest tsconfig field address supported compiler differences; selected malformed manifests are errors rather than swallowed faults or fixture-specific paths.
+ * @evidence contracts/common.md#meaningful-documentation Native JSDoc distinguishes lexical file spelling, physical module identity, preset selection and observation limits; param and acknowledgment spacing follows the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation Config separators are folded before native file resolution, package presets use createRequire from their declaring config, and filesystem identities use native realpath instead of POSIX path parsing.
+ * @evidence contracts/performance.md#efficient-algorithms File selection performs at most two native stats plus path text construction; package branches can make manifest and entrypoint resolution attempts, parse the selected manifest bytes, test config candidates and attempt realpath. Node's ancestor/package search and native operations have delegated costs, not fixed costs implied by a bounded local branch count.
+ *
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This resolver owns no result cache; Node's internal module-resolution cache is outside its control and therefore cannot justify an owning freshness proof.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources All paths, require objects and parsed manifest data belong to this invocation; no cache registry or process handle is acquired here.
+ */
+function resolveTsconfigExtends(tsconfig, specifier, onInput) {
+    const files = (0, tsconfigExtendsFileCandidates_1.tsconfigExtendsFileCandidates)(tsconfig, specifier);
+    if (files !== undefined) {
+        for (const candidate of files) {
+            onInput?.(candidate);
+            if (isFile(candidate))
+                return candidate;
+        }
+        throw new Error(`ttsc: extended tsconfig not found: ${files[0]}`);
+    }
+    const normalized = specifier.replaceAll("\\", "/");
+    const resolver = (0, node_module_1.createRequire)(tsconfig);
+    // A bare package root selects its preset through `package.json#tsconfig`,
+    // matching TypeScript's config resolution. Presets shipped this way often
+    // have no JavaScript/JSON entrypoint at all, so Node's entrypoint resolver
+    // and the `<specifier>.json` fallback below both miss them.
+    const viaManifest = resolvePackageManifestTsconfig(resolver, normalized, onInput);
+    if (viaManifest !== undefined) {
+        for (const candidate of viaManifest.endsWith(".json")
+            ? [viaManifest]
+            : [viaManifest, `${viaManifest}.json`]) {
+            onInput?.(candidate);
+            if (isFile(candidate))
+                return resolveRealPath(candidate);
+        }
+        throw new Error(`ttsc: extended tsconfig not found: ${viaManifest}`);
+    }
+    try {
+        const selected = resolver.resolve(normalized);
+        onInput?.(selected);
+        return resolveRealPath(selected);
+    }
+    catch {
+        const selected = resolver.resolve(`${normalized}.json`);
+        onInput?.(selected);
+        return resolveRealPath(selected);
+    }
+}
+/**
+ * When `specifier` names a bare package root, resolve the config file its
+ * `package.json#tsconfig` field selects (anchored at the package directory).
+ * Returns `undefined` when the specifier is a subpath, the manifest cannot be
+ * resolved at all, or it declares no `tsconfig` field, so the caller falls back
+ * to Node entrypoint resolution. A manifest that resolves but does not parse
+ * throws, naming the file.
+ */
+function resolvePackageManifestTsconfig(resolver, specifier, onInput) {
+    if (!isBarePackageRoot(specifier)) {
+        return undefined;
+    }
+    let manifestPath;
+    try {
+        manifestPath = resolver.resolve(`${specifier}/package.json`);
+    }
+    catch (error) {
+        // Node parses a package's manifest while resolving into it, so a malformed
+        // preset manifest fails here rather than at the read below. Swallowing it
+        // would turn a broken manifest into a confusing downstream
+        // "Cannot find module 'example-preset.json'" from the `extends` fallback,
+        // which names a file that was never the problem. Node's own message names
+        // the real one, so report it in ttsc's voice instead of continuing.
+        if (error?.code ===
+            "ERR_INVALID_PACKAGE_CONFIG") {
+            throw new Error(`ttsc: failed to parse the package manifest of ${JSON.stringify(specifier)}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        return undefined;
+    }
+    // A manifest that exists but does not parse is a real configuration error:
+    // falling back to Node entrypoint resolution would tell the user nothing
+    // about the file that actually broke. A manifest that parses to something
+    // other than an object carries no `tsconfig` field to read, so it falls back
+    // rather than throwing on a property access.
+    onInput?.(manifestPath);
+    const manifest = (0, readJsonFile_1.readJsonFile)(manifestPath);
+    const field = typeof manifest === "object" && manifest !== null
+        ? manifest.tsconfig
+        : undefined;
+    if (typeof field !== "string" || field.length === 0) {
+        return undefined;
+    }
+    return node_path_1.default.resolve(node_path_1.default.dirname(manifestPath), field.replaceAll("\\", "/"));
+}
+/**
+ * Return true when `specifier` is a bare package root (no subpath): a plain
+ * package name (`preset`) or a scoped name (`@scope/preset`). Subpaths such as
+ * `@scope/preset/base.json` resolve directly and keep their current meaning.
+ */
+function isBarePackageRoot(specifier) {
+    if (specifier.startsWith("@")) {
+        return specifier.split("/").length === 2;
+    }
+    return !specifier.includes("/");
+}
+/** Whether a path is a regular file; any failure to stat counts as not. */
+function isFile(location) {
+    try {
+        return node_fs_1.default.statSync(location).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Resolve symlinks on `location`, returning the original path when
+ * `realpathSync` fails.
+ */
+function resolveRealPath(location) {
+    try {
+        return node_fs_1.default.realpathSync(location);
+    }
+    catch {
+        return location;
+    }
+}
+//# sourceMappingURL=resolveTsconfigExtends.js.map

package/lib/compiler/internal/project/resolveTsconfigExtends.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveTsconfigExtends.js","sourceRoot":"","sources":["../../../../src/compiler/internal/project/resolveTsconfigExtends.ts"],"names":[],"mappings":"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"}

package/lib/compiler/internal/project/selectReferencedProject.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Select the first observed owning config in declaration-order depth-first
+ * traversal, retaining discovery when no positive membership was observed.
+ *
+ * The caller supplies current direct references, observed identity keys and
+ * membership observations. Native reference resolution, compiler expansion and
+ * retry policy remain with those owners. A fresh visited set belongs to each
+ * lookup; matching keys terminate cycles without a cross-request cache.
+ *
+ * @evidence contracts/common.md#principled-implementation Discovery membership takes precedence; each unseen reference is checked before its children, so declaration-order DFS preserves the first observed owner and discovered fallback.
+ * @evidence contracts/common.md#clear-and-simple-design One traversal owns ordering and lookup-local visited keys; supplied operations retain native reference and membership responsibilities.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Selection consumes actual observations rather than guessed include patterns, fixture layouts or persistent pathname-only answers.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs distinguish positive membership, fallback, cycles and delegated native observations.
+ * @evidence contracts/portability.md#os-neutral-implementation Config spellings pass unchanged through actual reference and identity owners; observed keys, rather than platform-name case assumptions, decide repeated states.
+ * @evidence contracts/performance.md#efficient-algorithms Each unseen observed identity receives at most one membership request and reference visit; edge iteration, string-key set work and delegated identity, config and compiler costs remain part of the lookup. Recursive stack depth follows the explored chain and is not bounded here.
+ * @evidence contracts/performance.md#reuse-equivalent-work Initial references are reused only for discovery, and the fresh visited set avoids repeated observed identities within this lookup. No state or failed observation is reused across calls; key quality remains the identity owner's premise.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources The visited keys and recursion frames live only for this synchronous lookup. Returned spelling transfers to the caller; native handles, subprocess capture and their lifetime remain delegated, with no deadline introduced here.
+ */
+export declare function selectReferencedProject(discovered: string, discoveredReferences: readonly string[], observations: {
+    /** Current best-effort native identity key for a config spelling. */
+    identity(config: string): string;
+    /** Positive observation that expanded roots contain this lookup's target. */
+    contains(config: string): boolean;
+    /** Current direct reference configs in declaration order. */
+    readReferences(config: string): readonly string[];
+}): string;

package/lib/compiler/internal/project/selectReferencedProject.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.selectReferencedProject = selectReferencedProject;
+/**
+ * Select the first observed owning config in declaration-order depth-first
+ * traversal, retaining discovery when no positive membership was observed.
+ *
+ * The caller supplies current direct references, observed identity keys and
+ * membership observations. Native reference resolution, compiler expansion and
+ * retry policy remain with those owners. A fresh visited set belongs to each
+ * lookup; matching keys terminate cycles without a cross-request cache.
+ *
+ * @evidence contracts/common.md#principled-implementation Discovery membership takes precedence; each unseen reference is checked before its children, so declaration-order DFS preserves the first observed owner and discovered fallback.
+ * @evidence contracts/common.md#clear-and-simple-design One traversal owns ordering and lookup-local visited keys; supplied operations retain native reference and membership responsibilities.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Selection consumes actual observations rather than guessed include patterns, fixture layouts or persistent pathname-only answers.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs distinguish positive membership, fallback, cycles and delegated native observations.
+ * @evidence contracts/portability.md#os-neutral-implementation Config spellings pass unchanged through actual reference and identity owners; observed keys, rather than platform-name case assumptions, decide repeated states.
+ * @evidence contracts/performance.md#efficient-algorithms Each unseen observed identity receives at most one membership request and reference visit; edge iteration, string-key set work and delegated identity, config and compiler costs remain part of the lookup. Recursive stack depth follows the explored chain and is not bounded here.
+ * @evidence contracts/performance.md#reuse-equivalent-work Initial references are reused only for discovery, and the fresh visited set avoids repeated observed identities within this lookup. No state or failed observation is reused across calls; key quality remains the identity owner's premise.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources The visited keys and recursion frames live only for this synchronous lookup. Returned spelling transfers to the caller; native handles, subprocess capture and their lifetime remain delegated, with no deadline introduced here.
+ */
+function selectReferencedProject(discovered, discoveredReferences, observations) {
+    if (discoveredReferences.length === 0)
+        return discovered;
+    if (observations.contains(discovered))
+        return discovered;
+    const seen = new Set([observations.identity(discovered)]);
+    /** DFS checks each unseen reference before descending into its children. */
+    function search(config) {
+        const references = config === discovered
+            ? discoveredReferences
+            : observations.readReferences(config);
+        for (const reference of references) {
+            const key = observations.identity(reference);
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            if (observations.contains(reference))
+                return reference;
+            const nested = search(reference);
+            if (nested !== null)
+                return nested;
+        }
+        return null;
+    }
+    return search(discovered) ?? discovered;
+}
+//# sourceMappingURL=selectReferencedProject.js.map

package/lib/compiler/internal/project/selectReferencedProject.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"selectReferencedProject.js","sourceRoot":"","sources":["../../../../src/compiler/internal/project/selectReferencedProject.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,iCACE,UAAkB,EAClB,oBAAuC,EACvC,YASC;IAED,IAAI,oBAAoB,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,UAAU,CAAC;IACzD,IAAI,YAAY,CAAC,QAAQ,CAAC,UAAU,CAAC;QAAE,OAAO,UAAU,CAAC;IACzD,MAAM,IAAI,GAAG,IAAI,GAAG,CAAS,CAAC,YAAY,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;IAElE,4EAA4E;IAC5E,SAAS,MAAM,CAAC,MAAc;QAC5B,MAAM,UAAU,GACd,MAAM,KAAK,UAAU;YACnB,CAAC,CAAC,oBAAoB;YACtB,CAAC,CAAC,YAAY,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;QAC1C,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE,CAAC;YACnC,MAAM,GAAG,GAAG,YAAY,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC;YAC7C,IAAI,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC;gBAAE,SAAS;YAC5B,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;YACd,IAAI,YAAY,CAAC,QAAQ,CAAC,SAAS,CAAC;gBAAE,OAAO,SAAS,CAAC;YACvD,MAAM,MAAM,GAAG,MAAM,CAAC,SAAS,CAAC,CAAC;YACjC,IAAI,MAAM,KAAK,IAAI;gBAAE,OAAO,MAAM,CAAC;QACrC,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IACD,OAAO,MAAM,CAAC,UAAU,CAAC,IAAI,UAAU,CAAC;AAC1C,CAAC"}

package/lib/compiler/internal/project/tsconfigExtendsFileCandidates.d.ts

@@ -0,0 +1,34 @@
+/**
+ * The file candidates ttsc tries for an `extends` specifier recognized as
+ * host-absolute or dot-relative, or `undefined` for module selection.
+ *
+ * TypeScript-Go's `getExtendsConfigPath` first folds every `\` of the specifier
+ * into `/`. A rooted specifier, or one starting with `./` or `../`, then names
+ * a file below the declaring config's directory, kept under the spelling it was
+ * reached by: the file itself, and, unless it already ends in `.json`, the file
+ * with `.json` appended. A directory is never expanded to its `tsconfig.json`.
+ * Every other specifier is resolved like a module (`resolveTsconfigExtends`). A
+ * bare `.` or `..` is taken as a file path too, as ttsc's readers treat it.
+ * Classification and normalization here use the host's native path API;
+ * TypeScript-Go's host-independent DOS-root recognition is not reproduced for
+ * foreign drive spellings or a bare drive such as `C:`.
+ *
+ * A reader that records what an `extends` it could not resolve would take to
+ * appear, as `@ttsc/unplugin` does to observe a missing base config, asks this
+ * rather than repeating the rule.
+ *
+ * @param tsconfig The declaring config, as the reader named it.
+ * @param specifier The `extends` value as written.
+ * @returns Ordered native candidates, or undefined when this reader delegates
+ *   the normalized specifier to module resolution.
+ * @evidence contracts/common.md#principled-implementation Backslash normalization followed by host-absolute/dot-relative classification uses the compiler's exact-then-json candidate order for those paths; bare dot spellings retain the existing reader extension, and native root classification is not universal compiler DOS-root parity.
+ * @evidence contracts/common.md#clear-and-simple-design This helper constructs candidates without reading them or resolving packages, so both readers share the spelling rule while retaining their own observation and selection responsibilities.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The dot-relative prefixes and json suffix express config grammar rather than named consumers or fixtures; no directory-to-tsconfig guess is inserted.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain candidate order, lexical anchoring, module classification and the deliberate bare-dot extension; params state whose spelling is retained.
+ * @evidence contracts/portability.md#os-neutral-implementation Compiler-style slash normalization precedes host-native isAbsolute/dirname/resolve operations; no realpath or case folding discards the lexical anchor needed for relative extends.
+ * @evidence contracts/performance.md#efficient-algorithms Normalization scans the specifier and native dirname/resolve process path text; at most two output strings are constructed, but their bytes are not bounded by the array length. No filesystem candidates are read here.
+ *
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Returns caller-owned path strings and an array, with no independent handle, task or historical retention.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This candidate adapter owns no coordinated config lifecycle or cache; relative declaring paths also depend on the native current-directory resolution context.
+ */
+export declare function tsconfigExtendsFileCandidates(tsconfig: string, specifier: string): string[] | undefined;

package/lib/compiler/internal/project/tsconfigExtendsFileCandidates.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tsconfigExtendsFileCandidates = tsconfigExtendsFileCandidates;
+const node_path_1 = __importDefault(require("node:path"));
+/**
+ * The file candidates ttsc tries for an `extends` specifier recognized as
+ * host-absolute or dot-relative, or `undefined` for module selection.
+ *
+ * TypeScript-Go's `getExtendsConfigPath` first folds every `\` of the specifier
+ * into `/`. A rooted specifier, or one starting with `./` or `../`, then names
+ * a file below the declaring config's directory, kept under the spelling it was
+ * reached by: the file itself, and, unless it already ends in `.json`, the file
+ * with `.json` appended. A directory is never expanded to its `tsconfig.json`.
+ * Every other specifier is resolved like a module (`resolveTsconfigExtends`). A
+ * bare `.` or `..` is taken as a file path too, as ttsc's readers treat it.
+ * Classification and normalization here use the host's native path API;
+ * TypeScript-Go's host-independent DOS-root recognition is not reproduced for
+ * foreign drive spellings or a bare drive such as `C:`.
+ *
+ * A reader that records what an `extends` it could not resolve would take to
+ * appear, as `@ttsc/unplugin` does to observe a missing base config, asks this
+ * rather than repeating the rule.
+ *
+ * @param tsconfig The declaring config, as the reader named it.
+ * @param specifier The `extends` value as written.
+ * @returns Ordered native candidates, or undefined when this reader delegates
+ *   the normalized specifier to module resolution.
+ * @evidence contracts/common.md#principled-implementation Backslash normalization followed by host-absolute/dot-relative classification uses the compiler's exact-then-json candidate order for those paths; bare dot spellings retain the existing reader extension, and native root classification is not universal compiler DOS-root parity.
+ * @evidence contracts/common.md#clear-and-simple-design This helper constructs candidates without reading them or resolving packages, so both readers share the spelling rule while retaining their own observation and selection responsibilities.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The dot-relative prefixes and json suffix express config grammar rather than named consumers or fixtures; no directory-to-tsconfig guess is inserted.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain candidate order, lexical anchoring, module classification and the deliberate bare-dot extension; params state whose spelling is retained.
+ * @evidence contracts/portability.md#os-neutral-implementation Compiler-style slash normalization precedes host-native isAbsolute/dirname/resolve operations; no realpath or case folding discards the lexical anchor needed for relative extends.
+ * @evidence contracts/performance.md#efficient-algorithms Normalization scans the specifier and native dirname/resolve process path text; at most two output strings are constructed, but their bytes are not bounded by the array length. No filesystem candidates are read here.
+ *
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Returns caller-owned path strings and an array, with no independent handle, task or historical retention.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This candidate adapter owns no coordinated config lifecycle or cache; relative declaring paths also depend on the native current-directory resolution context.
+ */
+function tsconfigExtendsFileCandidates(tsconfig, specifier) {
+    const normalized = specifier.replaceAll("\\", "/");
+    if (!node_path_1.default.isAbsolute(normalized) &&
+        normalized !== "." &&
+        normalized !== ".." &&
+        !normalized.startsWith("./") &&
+        !normalized.startsWith("../")) {
+        return undefined;
+    }
+    const location = node_path_1.default.resolve(node_path_1.default.dirname(tsconfig), normalized);
+    return location.endsWith(".json")
+        ? [location]
+        : [location, `${location}.json`];
+}
+//# sourceMappingURL=tsconfigExtendsFileCandidates.js.map

package/lib/compiler/internal/project/tsconfigExtendsFileCandidates.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tsconfigExtendsFileCandidates.js","sourceRoot":"","sources":["../../../../src/compiler/internal/project/tsconfigExtendsFileCandidates.ts"],"names":[],"mappings":";;;;;;AAAA,0DAA6B;AAE7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,uCACE,QAAgB,EAChB,SAAiB;IAEjB,MAAM,UAAU,GAAG,SAAS,CAAC,UAAU,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;IACnD,IACE,CAAC,mBAAI,CAAC,UAAU,CAAC,UAAU,CAAC;QAC5B,UAAU,KAAK,GAAG;QAClB,UAAU,KAAK,IAAI;QACnB,CAAC,UAAU,CAAC,UAAU,CAAC,IAAI,CAAC;QAC5B,CAAC,UAAU,CAAC,UAAU,CAAC,KAAK,CAAC,EAC7B,CAAC;QACD,OAAO,SAAS,CAAC;IACnB,CAAC;IACD,MAAM,QAAQ,GAAG,mBAAI,CAAC,OAAO,CAAC,mBAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,UAAU,CAAC,CAAC;IAClE,OAAO,QAAQ,CAAC,QAAQ,CAAC,OAAO,CAAC;QAC/B,CAAC,CAAC,CAAC,QAAQ,CAAC;QACZ,CAAC,CAAC,CAAC,QAAQ,EAAE,GAAG,QAAQ,OAAO,CAAC,CAAC;AACrC,CAAC"}

package/lib/compiler/internal/readEffectiveCompilerOptions.d.ts

@@ -0,0 +1,54 @@
+import type { ITtscParsedProjectConfig } from "../../structures/internal/ITtscParsedProjectConfig";
+/**
+ * A reader of the compiler options a build will actually use: the project's
+ * config with the flags forwarded on the command line applied over it, in the
+ * order the compiler applies them.
+ *
+ * Several decisions ttsc makes about a build depend on an option the user can
+ * override from the command line: whether the runtime build lowers `target:
+ * ESNext` or a preserved `jsx`, and which `rootDir` the compiler mirrors
+ * outputs against. Reading the config alone answers for a build that is not the
+ * one that runs.
+ *
+ * A forwarded `@file` response file is expanded by the compiler itself through
+ * `--showConfig`, which owns its quoting, nesting, and ordering; replaying only
+ * the visible flags would miss the options inside it. Path values are returned
+ * as written: a config path is already absolute, a forwarded one is relative to
+ * the build's working directory, and a response-file one to the config's
+ * directory. The optional compilerArgsCwd preserves that original base when
+ * project selection redirects to another configuration. The supplied project
+ * remains the authority for this query, including reference-child queries.
+ *
+ * A separate observed safety tokenizer checks response frames before reporting
+ * flags are appended; the native compiler still owns expansion and value
+ * validation. Inspection uses the caller-provided child environment when
+ * supplied.
+ *
+ * Native shown properties remain authoritative, including paths and enums.
+ * Reporting booleans omitted from showConfig retain their observed ordered
+ * response assignments or configured boolean; an explicit null is still
+ * present. Other omissions remain undefined rather than reviving a configured
+ * value.
+ *
+ * Visible arguments share one native-frame projection. Enum discriminants
+ * follow their origin: CLI values are trimmed before lookup, while config
+ * values retain whitespace. A present reset wins over the configured value.
+ *
+ * @returns The reader, or `null` when safe response inspection is unavailable
+ *   or the compiler rejects the arguments. The caller forwards the original
+ *   request untouched and retains the compiler diagnostic. Binary resolution,
+ *   capture/read and malformed JSON failures can still throw; null is not a
+ *   universal failure conversion. Safety observation does not pin response-file
+ *   state across the later native inspection or actual build.
+ * @evidence contracts/common.md#principled-implementation Actual response-file frames are validated by native showConfig, whose present properties remain authoritative; omitted booleans use observed shared-frame assignments before configured booleans without reviving present null resets; one native-frame projection applies visible assignments in order over resolved config values, including bare booleans and explicit resets, while config enums are lowercased without trimming or arbitrary schema validation.
+ * @evidence contracts/common.md#clear-and-simple-design One returned reader exposes effective values to rootDir, runtime-profile and display consumers. Shared observed tokenization owns safe inspection admission, while native showConfig remains authoritative for response expansion and option values.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Unavailable safety inspection or rejected response arguments yield null instead of fabricated effective values; shared generated occurrence metadata determines option arity and boolean assignment, while the separate conservative response tokenizer does not replace native validation.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain precedence, response-file ownership, path bases and the null outcome before acknowledgment tags following documentation guidance.
+ * @evidence contracts/performance.md#efficient-algorithms Visible arguments are projected once; response mode additionally observes/decodes/hashes expanded response bytes and reprojects them before one showConfig child. Complete capture/JSON parsing, delegated binary selection and native launch costs remain part of this operation. Each query performs option-name/alias normalization and lookups; config enum normalization adds value-text costs.
+ * @evidence contracts/performance.md#reuse-equivalent-work One invocation shares the argument projection or compiler-expanded result across option queries; a new build invocation creates a reader because config and response-file state may change.
+ *
+ * @evidence contracts/performance.md#bound-retention-and-release-resources The returned closure retains the compiler-options reference, assignment Map and optional shown record until its caller discards it; they are not a deep snapshot of mutable configuration. The invocation owns no historical reader cache. Response inspection and spawnNative own synchronous observation/capture cleanup attempts; child duration and expanded/captured bytes have no ceiling supplied here.
+ *
+ * @evidence contracts/portability.md#os-neutral-implementation Executable and argument arrays are passed through the supported native runner; path values preserve compiler-selected bases instead of shell interpolation or an OS-specific rewrite.
+ */
+export declare function readEffectiveCompilerOptions(project: ITtscParsedProjectConfig, passthrough?: readonly string[], binary?: string, env?: NodeJS.ProcessEnv, compilerArgsCwd?: string): ((name: string, aliases?: readonly string[]) => unknown) | null;

package/lib/compiler/internal/readEffectiveCompilerOptions.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readEffectiveCompilerOptions = readEffectiveCompilerOptions;
+const COMPILER_OPTIONS_1 = require("../../flags/COMPILER_OPTIONS");
+const normalizeCompilerEnumValue_1 = require("../../flags/normalizeCompilerEnumValue");
+const readCompilerOptionValues_1 = require("../../flags/readCompilerOptionValues");
+const CompilerArgumentsInspection_1 = require("./CompilerArgumentsInspection");
+const outputText_1 = require("./outputText");
+const resolveTsgo_1 = require("./resolveTsgo");
+const spawnNative_1 = require("./spawnNative");
+/**
+ * A reader of the compiler options a build will actually use: the project's
+ * config with the flags forwarded on the command line applied over it, in the
+ * order the compiler applies them.
+ *
+ * Several decisions ttsc makes about a build depend on an option the user can
+ * override from the command line: whether the runtime build lowers `target:
+ * ESNext` or a preserved `jsx`, and which `rootDir` the compiler mirrors
+ * outputs against. Reading the config alone answers for a build that is not the
+ * one that runs.
+ *
+ * A forwarded `@file` response file is expanded by the compiler itself through
+ * `--showConfig`, which owns its quoting, nesting, and ordering; replaying only
+ * the visible flags would miss the options inside it. Path values are returned
+ * as written: a config path is already absolute, a forwarded one is relative to
+ * the build's working directory, and a response-file one to the config's
+ * directory. The optional compilerArgsCwd preserves that original base when
+ * project selection redirects to another configuration. The supplied project
+ * remains the authority for this query, including reference-child queries.
+ *
+ * A separate observed safety tokenizer checks response frames before reporting
+ * flags are appended; the native compiler still owns expansion and value
+ * validation. Inspection uses the caller-provided child environment when
+ * supplied.
+ *
+ * Native shown properties remain authoritative, including paths and enums.
+ * Reporting booleans omitted from showConfig retain their observed ordered
+ * response assignments or configured boolean; an explicit null is still
+ * present. Other omissions remain undefined rather than reviving a configured
+ * value.
+ *
+ * Visible arguments share one native-frame projection. Enum discriminants
+ * follow their origin: CLI values are trimmed before lookup, while config
+ * values retain whitespace. A present reset wins over the configured value.
+ *
+ * @returns The reader, or `null` when safe response inspection is unavailable
+ *   or the compiler rejects the arguments. The caller forwards the original
+ *   request untouched and retains the compiler diagnostic. Binary resolution,
+ *   capture/read and malformed JSON failures can still throw; null is not a
+ *   universal failure conversion. Safety observation does not pin response-file
+ *   state across the later native inspection or actual build.
+ * @evidence contracts/common.md#principled-implementation Actual response-file frames are validated by native showConfig, whose present properties remain authoritative; omitted booleans use observed shared-frame assignments before configured booleans without reviving present null resets; one native-frame projection applies visible assignments in order over resolved config values, including bare booleans and explicit resets, while config enums are lowercased without trimming or arbitrary schema validation.
+ * @evidence contracts/common.md#clear-and-simple-design One returned reader exposes effective values to rootDir, runtime-profile and display consumers. Shared observed tokenization owns safe inspection admission, while native showConfig remains authoritative for response expansion and option values.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Unavailable safety inspection or rejected response arguments yield null instead of fabricated effective values; shared generated occurrence metadata determines option arity and boolean assignment, while the separate conservative response tokenizer does not replace native validation.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain precedence, response-file ownership, path bases and the null outcome before acknowledgment tags following documentation guidance.
+ * @evidence contracts/performance.md#efficient-algorithms Visible arguments are projected once; response mode additionally observes/decodes/hashes expanded response bytes and reprojects them before one showConfig child. Complete capture/JSON parsing, delegated binary selection and native launch costs remain part of this operation. Each query performs option-name/alias normalization and lookups; config enum normalization adds value-text costs.
+ * @evidence contracts/performance.md#reuse-equivalent-work One invocation shares the argument projection or compiler-expanded result across option queries; a new build invocation creates a reader because config and response-file state may change.
+ *
+ * @evidence contracts/performance.md#bound-retention-and-release-resources The returned closure retains the compiler-options reference, assignment Map and optional shown record until its caller discards it; they are not a deep snapshot of mutable configuration. The invocation owns no historical reader cache. Response inspection and spawnNative own synchronous observation/capture cleanup attempts; child duration and expanded/captured bytes have no ceiling supplied here.
+ *
+ * @evidence contracts/portability.md#os-neutral-implementation Executable and argument arrays are passed through the supported native runner; path values preserve compiler-selected bases instead of shell interpolation or an OS-specific rewrite.
+ */
+function readEffectiveCompilerOptions(project, passthrough = [], binary, env, compilerArgsCwd = project.root) {
+    const projected = (0, readCompilerOptionValues_1.readCompilerOptionValues)(passthrough);
+    let assignments = projected.values;
+    let shown;
+    if (projected.responseFiles.length !== 0) {
+        let observations;
+        try {
+            const inspected = CompilerArgumentsInspection_1.CompilerArgumentsInspection.inspect(["-p", project.path, ...passthrough], compilerArgsCwd);
+            observations = inspected.observations;
+            assignments = (0, readCompilerOptionValues_1.readCompilerOptionValues)(inspected.args).values;
+            for (const [file, observation] of inspected.observations)
+                if (CompilerArgumentsInspection_1.CompilerArgumentsInspection.observeInputFile(file) !== observation)
+                    return null;
+        }
+        catch {
+            return null;
+        }
+        const tsgo = (0, resolveTsgo_1.resolveTsgo)({ cwd: project.root, binary });
+        const result = (0, spawnNative_1.spawnNative)(tsgo.binary, ["-p", project.path, ...passthrough, "-p", project.path, "--showConfig"], { cwd: compilerArgsCwd, env, encoding: "utf8" });
+        if (result.status !== 0)
+            return null;
+        for (const [file, observation] of observations)
+            if (CompilerArgumentsInspection_1.CompilerArgumentsInspection.observeInputFile(file) !== observation)
+                return null;
+        shown = JSON.parse((0, outputText_1.outputText)(result.stdout)).compilerOptions;
+    }
+    const compilerOptions = project.compilerOptions;
+    return (name, aliases = []) => {
+        const spec = COMPILER_OPTIONS_1.COMPILER_OPTIONS.get(name.toLowerCase()) ??
+            aliases
+                .map((alias) => COMPILER_OPTIONS_1.COMPILER_OPTIONS.get(alias.toLowerCase()))
+                .find((candidate) => candidate !== undefined);
+        const canonical = spec?.name ?? name;
+        if (shown !== undefined) {
+            if (Object.prototype.hasOwnProperty.call(shown, canonical))
+                return shown[canonical];
+            // showConfig omits reporting booleans even when explicitly enabled.
+            // Paths and enums stay native-owned; omission must not revive a reset.
+            if (spec?.kind !== "boolean")
+                return undefined;
+            if (assignments.has(canonical))
+                return assignments.get(canonical);
+            const configured = compilerOptions[canonical];
+            return typeof configured === "boolean" ? configured : undefined;
+        }
+        if (assignments.has(canonical))
+            return assignments.get(canonical);
+        const configured = compilerOptions[canonical];
+        return spec?.kind === "enum" && typeof configured === "string"
+            ? (0, normalizeCompilerEnumValue_1.normalizeCompilerEnumValue)(configured, "json")
+            : configured;
+    };
+}
+//# sourceMappingURL=readEffectiveCompilerOptions.js.map

package/lib/compiler/internal/readEffectiveCompilerOptions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"readEffectiveCompilerOptions.js","sourceRoot":"","sources":["../../../src/compiler/internal/readEffectiveCompilerOptions.ts"],"names":[],"mappings":"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"}

package/lib/compiler/internal/resolveBinary.d.ts

@@ -5,7 +5,23 @@
  *
  * 1. `TTSC_BINARY` env var — must be an absolute path when set.
  * 2. The per-platform npm package `@ttsc/<platform>-<arch>/bin/ttsc[.exe]`.
- * 3. A `ttsc-native[.exe]` sibling of this package's root (dev/CI layout).
+ * 3. `native/ttsc-native[.exe]` inside this package (local Go build layout).
+ *
+ * A relative TTSC_BINARY is ignored; an absolute override is returned without a
+ * filesystem probe so the spawn operation owns its executable error.
+ * Platform-package lookup failures fall through to the local candidate. Local
+ * source/lib realpath errors can propagate instead of returning null, and a
+ * selected existing path is not an executable or ABI compatibility check.
+ *
+ * @evidence contracts/common.md#principled-implementation Explicit absolute authority precedes Node's platform-package resolution and then the package-local Go build output, matching the helper binary ownership exported through ttsc/binary.
+ * @evidence contracts/common.md#clear-and-simple-design A single resolver owns precedence for compiler and external helper consumers; the local-path helper separates source/lib layout from installed platform-package lookup.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Platform package names and executable suffixes follow the published package contract; the resolver uses supported require.resolve without replacing foreign resolution methods.
+ * @evidence contracts/common.md#meaningful-documentation Ordered resolution and override behavior are documented separately; the corrected development path matches go:build, following the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation Platform and architecture select the native package and executable suffix; native path APIs establish the development path, and override lookup follows Windows environment-name identity even in a caller's ordinary object.
+ * @evidence contracts/performance.md#efficient-algorithms Precedence has a fixed branch count, but Windows environment-name lookup scans key bytes, native path normalization processes text, Node package lookup has delegated search costs, and local fallback realpaths the source/lib root before checking candidate existence. No compiler executes merely to select this path.
+ *
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Environment overrides and development binaries may change between calls; the resolver owns no invalidation protocol beyond Node's own module resolver and introduces no stale path cache.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Resolution owns no persistent map, descriptor or task and returns only the selected path spelling.
  */
 export declare function resolveBinary(opts?: {
     env?: NodeJS.ProcessEnv;