ttsc 0.30.3 → 0.31.0

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

@@ -0,0 +1,80 @@
+import type { ITtscParsedProjectConfig } from "../../../structures/internal/ITtscParsedProjectConfig";
+import type { TtscCommonOptions } from "../../../structures/internal/TtscCommonOptions";
+/**
+ * Share compiler project authority, original argument anchoring and freshness.
+ *
+ * @evidence contracts/common.md#principled-implementation Members separate observed selection, publication freshness and safe phase guards while native APIs retain compiler validation.
+ * @evidence contracts/common.md#clear-and-simple-design One internal identity groups the shared invocation concern; members own their independent boundaries.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts No global state, compiler parser replacement or foreign API mutation is introduced.
+ * @evidence contracts/common.md#meaningful-documentation Each member documents its selection, lifetime and native diagnostic limits.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation The grouping has no separate native boundary; member operations own native input handling.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms The grouping contains no independent algorithm.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Members own invocation reuse rather than namespace history.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The namespace retains no state or handles.
+ */
+export declare namespace CompilerProjectSelection {
+    /**
+     * Resolve one compiler project without rebasing its original argument frame.
+     *
+     * Validated visible selectors retain their positions beside original response
+     * tokens. The existing observed inspector projects those frames for selection;
+     * the native producer still receives their original bytes and owns validation.
+     * Positional discovery starts at the supplied file until an observed project
+     * assignment selects another config. Explicit resolvedProject callers retain
+     * their independent API authority.
+     * Observations are sequential and do not pin bytes across a later producer.
+     *
+     * @evidence contracts/common.md#principled-implementation Existing schema occurrence metadata and observed response inspection establish ordered canonical project assignments; one selected config is returned separately from the retained compiler argument cwd.
+     * @evidence contracts/common.md#clear-and-simple-design One invocation record carries project, original transport, inspection projection and response observations to build and watch consumers.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Existing compiler metadata and response inspection are reused without a new tokenizer, compiler option parser, path-option rewrite or upstream modification. Explicit resolvedProject remains authoritative.
+     * @evidence contracts/common.md#meaningful-documentation Native prose explains order, separate argument anchoring, explicit API authority and non-atomic observation limits.
+     * @evidence contracts/portability.md#os-neutral-implementation Native path resolution and existing project identity preserve physical config/root spelling; visible operands use invocation cwd while response operands retain compiler cwd.
+     * @evidence contracts/performance.md#efficient-algorithms One ordered merge visits forwarded tokens and visible selectors, followed by one existing projection or response inspection and selected config resolution. Cost includes response bytes and inherited config work; no historical cache is introduced.
+     * @evidence contracts/performance.md#reuse-equivalent-work The returned invocation view shares current inspection and project selection across consumers; a new selection rereads response/config state.
+     * @evidence contracts/performance.md#bound-retention-and-release-resources Synchronous reads acquire no retained handles. Returned arguments, config and observations belong to the invocation and scale with its expanded inputs.
+     */
+    function read(options: TtscCommonOptions & {
+        file?: string;
+        files?: readonly string[];
+        tsconfig?: string;
+        resolvedProject?: ITtscParsedProjectConfig;
+    }): {
+        args: string[];
+        passthrough: string[];
+        compilerArgsCwd: string;
+        inspectionError: unknown;
+        inspectedArgs: string[];
+        observations: Map<string, string>;
+        project: ITtscParsedProjectConfig;
+        projectGuard: readonly string[];
+    };
+    /**
+     * Reject a changed response generation before a consumer publishes or runs it.
+     * This is a sequential reobservation, not an atomic producer snapshot.
+     *
+     * @evidence contracts/common.md#principled-implementation Current physical/content observations must match every response input admitted by this selection before its consumer proceeds.
+     * @evidence contracts/common.md#clear-and-simple-design One loop delegates actual file observation to the existing owner and propagates read failures.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts A mismatch rejects stale authority rather than silently recomputing only one consumer or certifying an atomic filesystem snapshot.
+     * @evidence contracts/common.md#meaningful-documentation Native prose states generation rejection and the sequential observation limitation.
+     * @evidence contracts/portability.md#os-neutral-implementation Existing native physical identity and content observations supply equality without path-case or platform guesses.
+     * @evidence contracts/performance.md#efficient-algorithms One observation per distinct response input rereads/hashes its bytes and native metadata; cost follows the admitted population and byte volume.
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work A current filesystem observation cannot reuse a historical signature as proof of freshness.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Synchronous observation retains no handle or history; the selection belongs to its caller.
+     */
+    function assertCurrent(selection: Pick<ReturnType<typeof read>, "observations">): void;
+    /**
+     * Pin an established project only after the current forwarded frame is safe.
+     * A phase may filter or extend argv after context acquisition; it must retain
+     * that live payload without letting a final flag satisfy an incomplete scalar.
+     *
+     * @evidence contracts/common.md#principled-implementation An unchanged observed frame reuses its admitted guard; changed phase arguments receive the existing conservative inspection before the selected project can be pinned.
+     * @evidence contracts/common.md#clear-and-simple-design One guard reader preserves live argv and the context's selected project without duplicating option arity or response grammar.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Unsafe frames receive no added project operand and retain native validation; response bytes are reobserved instead of assuming a changed phase still matches acquisition.
+     * @evidence contracts/common.md#meaningful-documentation Native prose states the phase mutation and missing-scalar premise.
+     * @evidence contracts/portability.md#os-neutral-implementation The existing observed inspector owns native response identity and decoding; selected native paths are returned without slash or case rewriting.
+     * @evidence contracts/performance.md#efficient-algorithms A length and token comparison costs current argv text; changed guarded frames add existing response expansion and hashing work proportional to expanded bytes.
+     * @evidence contracts/performance.md#reuse-equivalent-work Exact unchanged argv reuses the current selection guard; a different phase frame is inspected independently rather than borrowing its safety proof.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The operation retains no phase history or handles; returned guards remain selection-owned.
+     */
+    function readGuard(selection: ReturnType<typeof read>, passthrough?: readonly string[]): readonly string[];
+}

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

@@ -0,0 +1,187 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompilerProjectSelection = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const readCompilerOptionValues_1 = require("../../../flags/readCompilerOptionValues");
+const CompilerArgumentsInspection_1 = require("../CompilerArgumentsInspection");
+const readProjectConfig_1 = require("./readProjectConfig");
+const resolveProjectIdentity_1 = require("./resolveProjectIdentity");
+/**
+ * Share compiler project authority, original argument anchoring and freshness.
+ *
+ * @evidence contracts/common.md#principled-implementation Members separate observed selection, publication freshness and safe phase guards while native APIs retain compiler validation.
+ * @evidence contracts/common.md#clear-and-simple-design One internal identity groups the shared invocation concern; members own their independent boundaries.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts No global state, compiler parser replacement or foreign API mutation is introduced.
+ * @evidence contracts/common.md#meaningful-documentation Each member documents its selection, lifetime and native diagnostic limits.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation The grouping has no separate native boundary; member operations own native input handling.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms The grouping contains no independent algorithm.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Members own invocation reuse rather than namespace history.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The namespace retains no state or handles.
+ */
+var CompilerProjectSelection;
+(function (CompilerProjectSelection) {
+    /**
+     * Resolve one compiler project without rebasing its original argument frame.
+     *
+     * Validated visible selectors retain their positions beside original response
+     * tokens. The existing observed inspector projects those frames for selection;
+     * the native producer still receives their original bytes and owns validation.
+     * Positional discovery starts at the supplied file until an observed project
+     * assignment selects another config. Explicit resolvedProject callers retain
+     * their independent API authority.
+     * Observations are sequential and do not pin bytes across a later producer.
+     *
+     * @evidence contracts/common.md#principled-implementation Existing schema occurrence metadata and observed response inspection establish ordered canonical project assignments; one selected config is returned separately from the retained compiler argument cwd.
+     * @evidence contracts/common.md#clear-and-simple-design One invocation record carries project, original transport, inspection projection and response observations to build and watch consumers.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Existing compiler metadata and response inspection are reused without a new tokenizer, compiler option parser, path-option rewrite or upstream modification. Explicit resolvedProject remains authoritative.
+     * @evidence contracts/common.md#meaningful-documentation Native prose explains order, separate argument anchoring, explicit API authority and non-atomic observation limits.
+     * @evidence contracts/portability.md#os-neutral-implementation Native path resolution and existing project identity preserve physical config/root spelling; visible operands use invocation cwd while response operands retain compiler cwd.
+     * @evidence contracts/performance.md#efficient-algorithms One ordered merge visits forwarded tokens and visible selectors, followed by one existing projection or response inspection and selected config resolution. Cost includes response bytes and inherited config work; no historical cache is introduced.
+     * @evidence contracts/performance.md#reuse-equivalent-work The returned invocation view shares current inspection and project selection across consumers; a new selection rereads response/config state.
+     * @evidence contracts/performance.md#bound-retention-and-release-resources Synchronous reads acquire no retained handles. Returned arguments, config and observations belong to the invocation and scale with its expanded inputs.
+     */
+    function read(options) {
+        const cwd = node_path_1.default.resolve(options.cwd ?? process.cwd());
+        const file = options.file ??
+            (options.files?.length === 1 ? options.files[0] : undefined);
+        let initial = options.resolvedProject?.identity;
+        let initialError;
+        if (initial === undefined) {
+            try {
+                initial = (0, resolveProjectIdentity_1.resolveProjectIdentity)({ ...options, file });
+            }
+            catch (error) {
+                // An earlier locator is not necessarily the native-selected project.
+                // With no resolved anchor, preserve invocation cwd rather than guessing
+                // whether a missing path denotes a file or a directory. Its original
+                // failure remains authoritative when no later selector supersedes it.
+                initialError = error;
+            }
+        }
+        const compilerArgsCwd = node_path_1.default.resolve(options.compilerArgsCwd ?? initial?.physicalProjectRoot ?? cwd);
+        const passthrough = options.passthrough ?? [];
+        const responseFrames = (0, readCompilerOptionValues_1.readCompilerOptionValues)(passthrough).responseFiles;
+        const selections = responseFrames.length === 0
+            ? []
+            : (options.compilerProjectSelections ?? []);
+        const args = [];
+        let cursor = 0;
+        for (let index = 0; index <= passthrough.length; index++) {
+            while (selections[cursor]?.passthroughIndex === index) {
+                const value = selections[cursor].value;
+                args.push("--project", value === "" ? "" : node_path_1.default.resolve(cwd, value));
+                cursor++;
+            }
+            if (index !== passthrough.length)
+                args.push(passthrough[index]);
+        }
+        let inspected = { args, observations: new Map() };
+        let inspectionError;
+        if (responseFrames.length !== 0) {
+            try {
+                inspected = CompilerArgumentsInspection_1.CompilerArgumentsInspection.inspect(args, compilerArgsCwd);
+            }
+            catch (error) {
+                // An unavailable inspection cannot establish another project. Preserve
+                // the original producer frame, without a final selection/reporting flag.
+                inspectionError = error;
+            }
+        }
+        const assignments = inspectionError === undefined
+            ? (0, readCompilerOptionValues_1.readCompilerOptionValues)(inspected.args).values
+            : new Map();
+        const selected = assignments.get("project");
+        if (!assignments.has("project") && initialError !== undefined)
+            throw initialError;
+        const project = options.resolvedProject ??
+            (0, readProjectConfig_1.readProjectConfig)({
+                cwd: assignments.has("project") ? compilerArgsCwd : cwd,
+                file: assignments.has("project") ? undefined : file,
+                projectRoot: options.projectRoot,
+                tsconfig: assignments.has("project")
+                    ? typeof selected === "string"
+                        ? selected
+                        : undefined
+                    : options.tsconfig,
+            });
+        let projectGuard = [];
+        if (responseFrames.length !== 0 && inspectionError === undefined) {
+            projectGuard = ["-p", project.path];
+        }
+        else if (options.resolvedProject !== undefined && assignments.has("project")) {
+            // A reporting/selection guard must not become a missing top-level scalar
+            // operand. An unsafe native request retains its original diagnostic frame.
+            try {
+                CompilerArgumentsInspection_1.CompilerArgumentsInspection.inspect(args, compilerArgsCwd);
+                projectGuard = ["-p", project.path];
+            }
+            catch {
+                // The original producer diagnoses this unsafe request without a guard.
+            }
+        }
+        return {
+            args,
+            passthrough: [...passthrough],
+            compilerArgsCwd,
+            inspectionError,
+            inspectedArgs: inspected.args,
+            observations: inspected.observations,
+            project,
+            projectGuard,
+        };
+    }
+    CompilerProjectSelection.read = read;
+    /**
+     * Reject a changed response generation before a consumer publishes or runs it.
+     * This is a sequential reobservation, not an atomic producer snapshot.
+     *
+     * @evidence contracts/common.md#principled-implementation Current physical/content observations must match every response input admitted by this selection before its consumer proceeds.
+     * @evidence contracts/common.md#clear-and-simple-design One loop delegates actual file observation to the existing owner and propagates read failures.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts A mismatch rejects stale authority rather than silently recomputing only one consumer or certifying an atomic filesystem snapshot.
+     * @evidence contracts/common.md#meaningful-documentation Native prose states generation rejection and the sequential observation limitation.
+     * @evidence contracts/portability.md#os-neutral-implementation Existing native physical identity and content observations supply equality without path-case or platform guesses.
+     * @evidence contracts/performance.md#efficient-algorithms One observation per distinct response input rereads/hashes its bytes and native metadata; cost follows the admitted population and byte volume.
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work A current filesystem observation cannot reuse a historical signature as proof of freshness.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Synchronous observation retains no handle or history; the selection belongs to its caller.
+     */
+    function assertCurrent(selection) {
+        for (const [file, observation] of selection.observations)
+            if (CompilerArgumentsInspection_1.CompilerArgumentsInspection.observeInputFile(file) !== observation)
+                throw new Error(`Compiler response file changed after project selection: ${file}`);
+    }
+    CompilerProjectSelection.assertCurrent = assertCurrent;
+    /**
+     * Pin an established project only after the current forwarded frame is safe.
+     * A phase may filter or extend argv after context acquisition; it must retain
+     * that live payload without letting a final flag satisfy an incomplete scalar.
+     *
+     * @evidence contracts/common.md#principled-implementation An unchanged observed frame reuses its admitted guard; changed phase arguments receive the existing conservative inspection before the selected project can be pinned.
+     * @evidence contracts/common.md#clear-and-simple-design One guard reader preserves live argv and the context's selected project without duplicating option arity or response grammar.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Unsafe frames receive no added project operand and retain native validation; response bytes are reobserved instead of assuming a changed phase still matches acquisition.
+     * @evidence contracts/common.md#meaningful-documentation Native prose states the phase mutation and missing-scalar premise.
+     * @evidence contracts/portability.md#os-neutral-implementation The existing observed inspector owns native response identity and decoding; selected native paths are returned without slash or case rewriting.
+     * @evidence contracts/performance.md#efficient-algorithms A length and token comparison costs current argv text; changed guarded frames add existing response expansion and hashing work proportional to expanded bytes.
+     * @evidence contracts/performance.md#reuse-equivalent-work Exact unchanged argv reuses the current selection guard; a different phase frame is inspected independently rather than borrowing its safety proof.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The operation retains no phase history or handles; returned guards remain selection-owned.
+     */
+    function readGuard(selection, passthrough = []) {
+        if (selection.projectGuard.length === 0)
+            return [];
+        if (passthrough.length === selection.passthrough.length &&
+            passthrough.every((arg, index) => arg === selection.passthrough[index]))
+            return selection.projectGuard;
+        try {
+            const inspected = CompilerArgumentsInspection_1.CompilerArgumentsInspection.inspect(passthrough, selection.compilerArgsCwd);
+            assertCurrent(inspected);
+            return selection.projectGuard;
+        }
+        catch {
+            return [];
+        }
+    }
+    CompilerProjectSelection.readGuard = readGuard;
+})(CompilerProjectSelection || (exports.CompilerProjectSelection = CompilerProjectSelection = {}));
+//# sourceMappingURL=CompilerProjectSelection.js.map

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

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

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

@@ -0,0 +1,50 @@
+/**
+ * Text handling shared by the strict JSON and the JSONC config readers.
+ *
+ * Both readers must report a failure the same way, and both accept a leading
+ * byte-order mark, or a `package.json` and a `tsconfig.json` saved by the same
+ * editor would be accepted by one reader and rejected by the other. The JSONC
+ * reader counts a byte-order mark as whitespace at trivia positions, as the
+ * compiler does, so only the strict JSON reader needs {@link stripLeadingBom}.
+ *
+ * @evidence contracts/common.md#principled-implementation Shared error rendering and leading-BOM replacement express the two readers' common text concerns without claiming their distinct JSON and compiler JSONC grammars are interchangeable.
+ * @evidence contracts/common.md#clear-and-simple-design The namespace groups two stateless text operations used by both file readers; parsing, root validation and filename attribution remain with their actual owners.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The grouping contains no parser replacement or fallback config values; it exposes only encoding-marker handling and actual failure text.
+ * @evidence contracts/common.md#meaningful-documentation The namespace explains why readers share text handling and why JSONC does not need the strict reader's prefix operation, in paragraphs following the documentation skill.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources A namespace only groups the declarations inside it; each carries its own acknowledgments.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms A namespace only groups the declarations inside it; each carries its own acknowledgments.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work A namespace only groups the declarations inside it; each carries its own acknowledgments.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation A namespace only groups the declarations inside it; each carries its own acknowledgments.
+ */
+export declare namespace ConfigJsonText {
+    /**
+     * Render a parse failure's message without the Error prefix.
+     *
+     * @evidence contracts/common.md#principled-implementation Native Error instances expose their message; other thrown values use JavaScript String conversion so attribution does not assume every failure is an Error object.
+     * @evidence contracts/common.md#clear-and-simple-design This accessor owns only error-text extraction while the file reader supplies the filename and diagnostic context.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts The actual thrown value supplies the text, with no fixture-specific diagnostic substitution or global Error mutation.
+     * @evidence contracts/common.md#meaningful-documentation The native sentence states the useful formatting effect and keeps prose separate from acknowledgments following the documentation skill.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources describe acquires no handle, buffer or cache and retains nothing after it returns.
+     * @evidence contracts/performance.md#efficient-algorithms One Error test selects a message property or JavaScript String conversion. Primitive conversion cost follows the rendered value; a custom property or conversion can run user behavior or throw, so fixed local expressions do not bound arbitrary thrown-value formatting work.
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work This formatter coordinates no work across requests and retains no result history; it describes the current supplied failure.
+     * @evidenceExclude contracts/portability.md#os-neutral-implementation describe computes from its arguments only; it opens no file, builds no path and calls no platform or process API.
+     */
+    function describe(error: unknown): string;
+    /**
+     * Replace a leading UTF-8 BOM with a space. JSON ignores leading whitespace,
+     * so blanking rather than removing keeps every later offset equal to the
+     * offset in the original file. Later U+FEFF characters are left in place:
+     * strict JSON rejects them as outside-string whitespace, while quoted string
+     * data can contain them.
+     *
+     * @evidence contracts/common.md#principled-implementation Replacing exactly one leading U+FEFF with whitespace preserves later UTF-16 offsets while JSON.parse accepts the replacement; later characters retain strict JSON's distinction between valid string data and invalid outside-string whitespace.
+     * @evidence contracts/common.md#clear-and-simple-design One prefix adapter supplies strict-JSON compatibility without duplicating the JSONC reader's broader compiler whitespace grammar.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts U+FEFF is the declared encoding marker, not an expected-output special case; arbitrary nonleading characters are not erased to force acceptance.
+     * @evidence contracts/common.md#meaningful-documentation The native paragraph explains length-preserving replacement and the later-character string-versus-whitespace distinction, following the documentation skill.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources stripLeadingBom acquires no handle, buffer or cache and retains nothing after it returns.
+     * @evidence contracts/performance.md#efficient-algorithms One leading-code-unit test returns the unchanged string when no BOM is present; replacement slices the remaining text and constructs a same-length string. Work and local string storage can grow with text length rather than the fixed expression count, and no scan for later markers or parser duplication is performed.
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work This prefix adapter coordinates no cross-request work or retained cache; consumers normalize their current text before strict parsing.
+     * @evidenceExclude contracts/portability.md#os-neutral-implementation stripLeadingBom computes from its arguments only; it opens no file, builds no path and calls no platform or process API.
+     */
+    function stripLeadingBom(input: string): string;
+}

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

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigJsonText = void 0;
+/**
+ * Text handling shared by the strict JSON and the JSONC config readers.
+ *
+ * Both readers must report a failure the same way, and both accept a leading
+ * byte-order mark, or a `package.json` and a `tsconfig.json` saved by the same
+ * editor would be accepted by one reader and rejected by the other. The JSONC
+ * reader counts a byte-order mark as whitespace at trivia positions, as the
+ * compiler does, so only the strict JSON reader needs {@link stripLeadingBom}.
+ *
+ * @evidence contracts/common.md#principled-implementation Shared error rendering and leading-BOM replacement express the two readers' common text concerns without claiming their distinct JSON and compiler JSONC grammars are interchangeable.
+ * @evidence contracts/common.md#clear-and-simple-design The namespace groups two stateless text operations used by both file readers; parsing, root validation and filename attribution remain with their actual owners.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The grouping contains no parser replacement or fallback config values; it exposes only encoding-marker handling and actual failure text.
+ * @evidence contracts/common.md#meaningful-documentation The namespace explains why readers share text handling and why JSONC does not need the strict reader's prefix operation, in paragraphs following the documentation skill.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources A namespace only groups the declarations inside it; each carries its own acknowledgments.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms A namespace only groups the declarations inside it; each carries its own acknowledgments.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work A namespace only groups the declarations inside it; each carries its own acknowledgments.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation A namespace only groups the declarations inside it; each carries its own acknowledgments.
+ */
+var ConfigJsonText;
+(function (ConfigJsonText) {
+    /**
+     * Render a parse failure's message without the Error prefix.
+     *
+     * @evidence contracts/common.md#principled-implementation Native Error instances expose their message; other thrown values use JavaScript String conversion so attribution does not assume every failure is an Error object.
+     * @evidence contracts/common.md#clear-and-simple-design This accessor owns only error-text extraction while the file reader supplies the filename and diagnostic context.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts The actual thrown value supplies the text, with no fixture-specific diagnostic substitution or global Error mutation.
+     * @evidence contracts/common.md#meaningful-documentation The native sentence states the useful formatting effect and keeps prose separate from acknowledgments following the documentation skill.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources describe acquires no handle, buffer or cache and retains nothing after it returns.
+     * @evidence contracts/performance.md#efficient-algorithms One Error test selects a message property or JavaScript String conversion. Primitive conversion cost follows the rendered value; a custom property or conversion can run user behavior or throw, so fixed local expressions do not bound arbitrary thrown-value formatting work.
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work This formatter coordinates no work across requests and retains no result history; it describes the current supplied failure.
+     * @evidenceExclude contracts/portability.md#os-neutral-implementation describe computes from its arguments only; it opens no file, builds no path and calls no platform or process API.
+     */
+    function describe(error) {
+        return error instanceof Error ? error.message : String(error);
+    }
+    ConfigJsonText.describe = describe;
+    /**
+     * Replace a leading UTF-8 BOM with a space. JSON ignores leading whitespace,
+     * so blanking rather than removing keeps every later offset equal to the
+     * offset in the original file. Later U+FEFF characters are left in place:
+     * strict JSON rejects them as outside-string whitespace, while quoted string
+     * data can contain them.
+     *
+     * @evidence contracts/common.md#principled-implementation Replacing exactly one leading U+FEFF with whitespace preserves later UTF-16 offsets while JSON.parse accepts the replacement; later characters retain strict JSON's distinction between valid string data and invalid outside-string whitespace.
+     * @evidence contracts/common.md#clear-and-simple-design One prefix adapter supplies strict-JSON compatibility without duplicating the JSONC reader's broader compiler whitespace grammar.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts U+FEFF is the declared encoding marker, not an expected-output special case; arbitrary nonleading characters are not erased to force acceptance.
+     * @evidence contracts/common.md#meaningful-documentation The native paragraph explains length-preserving replacement and the later-character string-versus-whitespace distinction, following the documentation skill.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources stripLeadingBom acquires no handle, buffer or cache and retains nothing after it returns.
+     * @evidence contracts/performance.md#efficient-algorithms One leading-code-unit test returns the unchanged string when no BOM is present; replacement slices the remaining text and constructs a same-length string. Work and local string storage can grow with text length rather than the fixed expression count, and no scan for later markers or parser duplication is performed.
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work This prefix adapter coordinates no cross-request work or retained cache; consumers normalize their current text before strict parsing.
+     * @evidenceExclude contracts/portability.md#os-neutral-implementation stripLeadingBom computes from its arguments only; it opens no file, builds no path and calls no platform or process API.
+     */
+    function stripLeadingBom(input) {
+        return input.charCodeAt(0) === 0xfeff ? ` ${input.slice(1)}` : input;
+    }
+    ConfigJsonText.stripLeadingBom = stripLeadingBom;
+})(ConfigJsonText || (exports.ConfigJsonText = ConfigJsonText = {}));
+//# sourceMappingURL=ConfigJsonText.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ConfigJsonText.js","sourceRoot":"","sources":["../../../../src/compiler/internal/project/ConfigJsonText.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,IAAiB,cAAc,CAoC9B;AApCD,WAAiB,cAAc;IAC7B;;;;;;;;;;;OAWG;IACH,SAAgB,QAAQ,CAAC,KAAc;QACrC,OAAO,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IAChE,CAAC;IAFe,eAAA,QAAQ,WAEvB,CAAA;IAED;;;;;;;;;;;;;;;OAeG;IACH,SAAgB,eAAe,CAAC,KAAa;QAC3C,OAAO,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC;IACvE,CAAC;IAFe,eAAA,eAAe,kBAE9B,CAAA;AACH,CAAC,EApCgB,cAAc,aAAd,cAAc,GAAd,cAAc,QAoC9B"}

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

@@ -0,0 +1,48 @@
+/**
+ * Approximate the compiler's file-name case policy before its reported answer
+ * is available.
+ *
+ * TypeScript-Go decides it once, from the executable it runs as
+ * (`internal/vfs/osvfs/os.go`, `isFileSystemCaseSensitive`):
+ *
+ * - On Windows, never; on the upstream WebAssembly host, always;
+ * - On other upstream hosts, unless `os.Executable()` is found again under its
+ *   case-swapped spelling, every letter's case flipped (`swapCase`); a missing
+ *   swapped path means sensitive, and any other failure stops the compiler.
+ *
+ * This Node helper returns false on Windows. Elsewhere it resolves the
+ * project's plugin-cache root (`--cache-dir`, `TTSC_CACHE_DIR`, or the default
+ * workspace root), creates it and probes its physical spelling. Source-built
+ * compiler and plugin hosts are placed at `<plugin cache root>/<key>/plugin`,
+ * but probing the root is a proxy, not observation of their executable.
+ * Different directory case policies, lexical symlink spellings and Unicode case
+ * mappings can make the proxy disagree. In particular, on Darwin an explicitly
+ * linked root is probed at its target rather than the spelling the compiler
+ * sees. This helper does not implement the upstream WebAssembly branch or
+ * certify an arbitrary selected compiler binary.
+ *
+ * Cache setup failures and swapped-path errors other than ENOENT return false.
+ * That fallback admits more case spellings than a sensitive answer; it does not
+ * establish what the actual compiler would report. Consumers can replace the
+ * approximation with a reported graph policy and retry membership admission.
+ *
+ * @param props.projectRoot The project the compile runs for.
+ * @param props.cacheDir The cache directory the compile is given, if any.
+ * @param props.env The compile's environment.
+ * @evidence contracts/common.md#principled-implementation The Windows return matches the pinned compiler's explicit policy; other hosts probe the physical plugin-cache root's swapped spelling as a proxy for the executable placed beneath it, with the documented Darwin lexical-path limitation.
+ * @evidence contracts/common.md#clear-and-simple-design Cache-root selection stays with SourceBuildCacheLayout while this boundary owns the compiler case-policy approximation and swapCase owns Unicode spelling conversion.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The platform branch expresses actual upstream compiler behavior rather than a generic filesystem assumption; unreadable probes conservatively admit more spellings instead of inventing a known project answer.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs distinguish upstream executable observation from this physical-root proxy, its platform/path/Unicode limitations and false fallback; params describe compile context and tags are visibly separated.
+ * @evidence contracts/portability.md#os-neutral-implementation Code uses native mkdir/realpath/stat and probes the selected cache volume rather than guessing its policy from OS names; the Windows special case intentionally mirrors the compiler, and the Darwin symlink spelling limitation is explicit.
+ * @evidence contracts/performance.md#efficient-algorithms Windows returns without filesystem work. Every other call resolves cache placement before consulting ANSWERS: default discovery can walk ancestors, read uncapped manifest bytes and snapshot cache-layout entries, followed by marker/root setup and native canonicalization. A cached answer skips only the swapped-spelling conversion and stat. Conversion visits root code points and builds proportional output; native path, metadata and delegated entry work is not bounded by the boolean result.
+ * @evidence contracts/performance.md#reuse-equivalent-work Answers share the physical plugin-root key only after placement and root setup repeat; this avoids repeating the case probe, not the delegated discovery. Native case-policy changes during the process are not revalidated, and the root-to-executable approximation remains conditional even for a cached answer.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources The process owns one boolean per distinct physical plugin-cache root; there is no eviction bound, so historical root cardinality grows until process exit, while the probe retains no descriptor.
+ */
+export declare function compilerUsesCaseSensitiveFileNames(props: {
+    /** Explicit cache root; absence uses environment or workspace-local selection. */
+    cacheDir?: string;
+    /** Compile environment; absence uses the current process environment. */
+    env?: NodeJS.ProcessEnv;
+    /** Project directory used for workspace-local cache placement. */
+    projectRoot: string;
+}): boolean;

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

@@ -0,0 +1,119 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compilerUsesCaseSensitiveFileNames = compilerUsesCaseSensitiveFileNames;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const SourceBuildCacheLayout_1 = require("../../../plugin/internal/source/SourceBuildCacheLayout");
+const resolveSourceBuildCachePaths_1 = require("../../../plugin/internal/source/resolveSourceBuildCachePaths");
+/**
+ * Approximate the compiler's file-name case policy before its reported answer
+ * is available.
+ *
+ * TypeScript-Go decides it once, from the executable it runs as
+ * (`internal/vfs/osvfs/os.go`, `isFileSystemCaseSensitive`):
+ *
+ * - On Windows, never; on the upstream WebAssembly host, always;
+ * - On other upstream hosts, unless `os.Executable()` is found again under its
+ *   case-swapped spelling, every letter's case flipped (`swapCase`); a missing
+ *   swapped path means sensitive, and any other failure stops the compiler.
+ *
+ * This Node helper returns false on Windows. Elsewhere it resolves the
+ * project's plugin-cache root (`--cache-dir`, `TTSC_CACHE_DIR`, or the default
+ * workspace root), creates it and probes its physical spelling. Source-built
+ * compiler and plugin hosts are placed at `<plugin cache root>/<key>/plugin`,
+ * but probing the root is a proxy, not observation of their executable.
+ * Different directory case policies, lexical symlink spellings and Unicode case
+ * mappings can make the proxy disagree. In particular, on Darwin an explicitly
+ * linked root is probed at its target rather than the spelling the compiler
+ * sees. This helper does not implement the upstream WebAssembly branch or
+ * certify an arbitrary selected compiler binary.
+ *
+ * Cache setup failures and swapped-path errors other than ENOENT return false.
+ * That fallback admits more case spellings than a sensitive answer; it does not
+ * establish what the actual compiler would report. Consumers can replace the
+ * approximation with a reported graph policy and retry membership admission.
+ *
+ * @param props.projectRoot The project the compile runs for.
+ * @param props.cacheDir The cache directory the compile is given, if any.
+ * @param props.env The compile's environment.
+ * @evidence contracts/common.md#principled-implementation The Windows return matches the pinned compiler's explicit policy; other hosts probe the physical plugin-cache root's swapped spelling as a proxy for the executable placed beneath it, with the documented Darwin lexical-path limitation.
+ * @evidence contracts/common.md#clear-and-simple-design Cache-root selection stays with SourceBuildCacheLayout while this boundary owns the compiler case-policy approximation and swapCase owns Unicode spelling conversion.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The platform branch expresses actual upstream compiler behavior rather than a generic filesystem assumption; unreadable probes conservatively admit more spellings instead of inventing a known project answer.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs distinguish upstream executable observation from this physical-root proxy, its platform/path/Unicode limitations and false fallback; params describe compile context and tags are visibly separated.
+ * @evidence contracts/portability.md#os-neutral-implementation Code uses native mkdir/realpath/stat and probes the selected cache volume rather than guessing its policy from OS names; the Windows special case intentionally mirrors the compiler, and the Darwin symlink spelling limitation is explicit.
+ * @evidence contracts/performance.md#efficient-algorithms Windows returns without filesystem work. Every other call resolves cache placement before consulting ANSWERS: default discovery can walk ancestors, read uncapped manifest bytes and snapshot cache-layout entries, followed by marker/root setup and native canonicalization. A cached answer skips only the swapped-spelling conversion and stat. Conversion visits root code points and builds proportional output; native path, metadata and delegated entry work is not bounded by the boolean result.
+ * @evidence contracts/performance.md#reuse-equivalent-work Answers share the physical plugin-root key only after placement and root setup repeat; this avoids repeating the case probe, not the delegated discovery. Native case-policy changes during the process are not revalidated, and the root-to-executable approximation remains conditional even for a cached answer.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources The process owns one boolean per distinct physical plugin-cache root; there is no eviction bound, so historical root cardinality grows until process exit, while the probe retains no descriptor.
+ */
+function compilerUsesCaseSensitiveFileNames(props) {
+    if (process.platform === "win32")
+        return false;
+    const env = props.env ?? process.env;
+    let root;
+    try {
+        const paths = (0, resolveSourceBuildCachePaths_1.resolveSourceBuildCachePaths)(node_path_1.default.resolve(props.projectRoot), props.cacheDir, env);
+        if (!props.cacheDir && !env.TTSC_CACHE_DIR) {
+            SourceBuildCacheLayout_1.SourceBuildCacheLayout.markDefaultWorkspaceCacheRoot(paths.root);
+            root = SourceBuildCacheLayout_1.SourceBuildCacheLayout.canonicalPluginCacheRoot(paths.pluginRoot);
+        }
+        else {
+            node_fs_1.default.mkdirSync(paths.pluginRoot, { recursive: true });
+            root = node_fs_1.default.realpathSync.native(paths.pluginRoot);
+        }
+    }
+    catch {
+        return false;
+    }
+    const cached = ANSWERS.get(root);
+    if (cached !== undefined)
+        return cached;
+    let answer;
+    try {
+        node_fs_1.default.statSync(swapCase(root));
+        answer = false;
+    }
+    catch (error) {
+        answer = error.code === "ENOENT";
+    }
+    ANSWERS.set(root, answer);
+    return answer;
+}
+/** Answers by physical plugin cache root, fixed like the compiler's own. */
+const ANSWERS = new Map();
+/**
+ * Flip the case of every character, as TypeScript-Go's `swapCase` does: a
+ * character with an upper-case form takes it, and any other takes its
+ * lower-case form.
+ *
+ * Go uses the simple case mappings, one character to one, and JavaScript
+ * exposes only the full ones. They differ where a full mapping expands to
+ * several characters: `ß` has no simple upper-case form in either, but `İ`
+ * (U+0130) lower-cases to `i` in Go, and the Greek letters with ypogegrammeni
+ * upper-case to their title-case forms. Such a character is kept as it is here.
+ * The resulting string therefore need not equal Go's swapped string. Whether
+ * either spelling resolves is a separate native filesystem observation; this
+ * conversion alone does not prove that one probe's answers contain the
+ * other's.
+ *
+ * This private helper owns only spelling conversion. The caller owns native
+ * filesystem interpretation and caches established root answers. One code-point
+ * pass uses space proportional to the spelling and retains no historical
+ * paths.
+ */
+function swapCase(text) {
+    let output = "";
+    for (const character of text) {
+        const upper = character.toUpperCase();
+        if (upper !== character && [...upper].length === 1) {
+            output += upper;
+            continue;
+        }
+        const lower = character.toLowerCase();
+        output += [...lower].length === 1 ? lower : character;
+    }
+    return output;
+}
+//# sourceMappingURL=compilerUsesCaseSensitiveFileNames.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"compilerUsesCaseSensitiveFileNames.js","sourceRoot":"","sources":["../../../../src/compiler/internal/project/compilerUsesCaseSensitiveFileNames.ts"],"names":[],"mappings":";;;;;;AAAA,sDAAyB;AACzB,0DAA6B;AAE7B,mGAAgG;AAChG,+GAA4G;AAE5G;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,4CAAmD,KASlD;IACC,IAAI,OAAO,CAAC,QAAQ,KAAK,OAAO;QAAE,OAAO,KAAK,CAAC;IAC/C,MAAM,GAAG,GAAG,KAAK,CAAC,GAAG,IAAI,OAAO,CAAC,GAAG,CAAC;IACrC,IAAI,IAAY,CAAC;IACjB,IAAI,CAAC;QACH,MAAM,KAAK,GAAG,IAAA,2DAA4B,EACxC,mBAAI,CAAC,OAAO,CAAC,KAAK,CAAC,WAAW,CAAC,EAC/B,KAAK,CAAC,QAAQ,EACd,GAAG,CACJ,CAAC;QACF,IAAI,CAAC,KAAK,CAAC,QAAQ,IAAI,CAAC,GAAG,CAAC,cAAc,EAAE,CAAC;YAC3C,+CAAsB,CAAC,6BAA6B,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;YACjE,IAAI,GAAG,+CAAsB,CAAC,wBAAwB,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;QAC3E,CAAC;aAAM,CAAC;YACN,iBAAE,CAAC,SAAS,CAAC,KAAK,CAAC,UAAU,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;YACpD,IAAI,GAAG,iBAAE,CAAC,YAAY,CAAC,MAAM,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;QAClD,CAAC;IACH,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,KAAK,CAAC;IACf,CAAC;IACD,MAAM,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IACjC,IAAI,MAAM,KAAK,SAAS;QAAE,OAAO,MAAM,CAAC;IACxC,IAAI,MAAe,CAAC;IACpB,IAAI,CAAC;QACH,iBAAE,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC;QAC5B,MAAM,GAAG,KAAK,CAAC;IACjB,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,MAAM,GAAI,KAA+B,CAAC,IAAI,KAAK,QAAQ,CAAC;IAC9D,CAAC;IACD,OAAO,CAAC,GAAG,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;IAC1B,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,4EAA4E;AAC5E,MAAM,OAAO,GAAG,IAAI,GAAG,EAAmB,CAAC;AAE3C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,SAAS,QAAQ,CAAC,IAAY;IAC5B,IAAI,MAAM,GAAG,EAAE,CAAC;IAChB,KAAK,MAAM,SAAS,IAAI,IAAI,EAAE,CAAC;QAC7B,MAAM,KAAK,GAAG,SAAS,CAAC,WAAW,EAAE,CAAC;QACtC,IAAI,KAAK,KAAK,SAAS,IAAI,CAAC,GAAG,KAAK,CAAC,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACnD,MAAM,IAAI,KAAK,CAAC;YAChB,SAAS;QACX,CAAC;QACD,MAAM,KAAK,GAAG,SAAS,CAAC,WAAW,EAAE,CAAC;QACtC,MAAM,IAAI,CAAC,GAAG,KAAK,CAAC,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IACxD,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC"}

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

@@ -1,12 +1,15 @@
 import type { ITtscParsedProjectConfig } from "../../../structures/internal/ITtscParsedProjectConfig";
-/** Serialize the retained project identity for a native sidecar invocation. */
-export declare function createNativeProjectContextArgs(project: ITtscParsedProjectConfig, pluginConfigOrigin?: string): string[];
 /**
- * The identity payload itself, for a caller that spawns a sidecar without going
- * through the compiler's own argument list.
+ * Encode retained project identity as one native sidecar argument. The JSON
+ * serializer owns payload shape; the argument carries no shell quoting.
  *
- * Split from the flag so there is still exactly one place that decides what a
- * sidecar is told about the project. A second caller assembling the same JSON,
- * or slicing it back out of the flag, is how the two drift.
+ * @evidence contracts/common.md#principled-implementation One --project-context-json argument contains the shared serializer's complete identity payload, preserving the native host's flag/value boundary for direct argv spawning.
+ * @evidence contracts/common.md#clear-and-simple-design This adapter owns the CLI envelope only; createNativeProjectContextJson is the sole project-context wire-shape owner.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The flag name is a declared sidecar protocol constant and the payload comes from retained project identity, without per-consumer path guesses or shell interpolation.
+ * @evidence contracts/common.md#meaningful-documentation The native comment distinguishes envelope and payload responsibility and explains argv representation following the documentation skill.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The one-element argv array and encoded string transfer to the caller; this adapter retains no history or native resource.
+ * @evidence contracts/performance.md#efficient-algorithms The shared serializer encodes identity bytes once, then a fixed protocol prefix and one-element array form the envelope; string work and returned storage scale with the encoded payload bytes.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This invocation-data envelope coordinates no completed or in-flight producer computation.
+ * @evidence contracts/portability.md#os-neutral-implementation Native path spellings stay JSON-encoded inside one argv element with no shell quoting or separator rewriting; the spawning caller owns OS process argument transport.
  */
-export declare function createNativeProjectContextJson(project: ITtscParsedProjectConfig, pluginConfigOrigin?: string): string;
+export declare function createNativeProjectContextArgs(project: ITtscParsedProjectConfig, pluginConfigOrigin?: string): string[];