ttsc 0.30.4 → 0.31.1

package/lib/compiler/internal/build/appendBuildOutput.js

@@ -0,0 +1,182 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.appendBuildOutput = appendBuildOutput;
+exports.mergeCheckGraphs = mergeCheckGraphs;
+const normalizeBuildOutput_1 = require("./normalizeBuildOutput");
+/**
+ * Merge two `TtscBuildResult` values into one.
+ *
+ * - `status`: the right status wins unless it is 0 (failure propagates).
+ * - `diagnostics`: concatenated left then right.
+ * - `emittedFiles`: right wins when present, otherwise left is kept.
+ * - `emittedSources`: only the right phase's proof survives. An unknown later
+ *   producer must not inherit an earlier phase's source ownership.
+ * - `stdout`/`stderr`: concatenated left then right.
+ * - Check inputs are unioned; independently compatible content and physical
+ *   witnesses survive. A lost witness cannot be restored by a later phase.
+ *   Explicit observation incompleteness is sticky.
+ *
+ * The shared normalizer moves combined stdout to stderr when the merged result
+ * failed and stderr is blank, preserving visibility for stderr-only consumers.
+ *
+ * @evidence contracts/common.md#principled-implementation Ordered concatenation preserves both phases' reports and failures; only the right phase's emitted-source proof and completion fact survive. Check declarations and explicit incompleteness accumulate, while each content/physical witness must agree across every declaring phase and a lost witness cannot be restored later.
+ * @evidence contracts/common.md#clear-and-simple-design Field selection is explicit in one result literal; one private witness merger applies the same independent compatibility rule to content and physical identity, and the shared normalizer owns output visibility.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Status and emitted-file selection follow phase-result semantics without special cases for particular plugins or errors.
+ * @evidence contracts/common.md#meaningful-documentation The native list describes each field's precedence, including why provenance differs from emitted-file listing; prose and tags are separated.
+ * @evidence contracts/performance.md#efficient-algorithms Diagnostic arrays and text are concatenated once, and input witnesses use indexed membership in O(total report bytes and input count); supplied diagnostics prevent the normalizer from reparsing them.
+ *
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Combining two supplied results does not coordinate shared production or cross-request work.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The returned result transfers combined data to the caller and no history or handle is retained.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation Input spellings and witness values are compared literally as producer-reported data; their native path and identity interpretation belongs to producers and proof consumers. Supplied diagnostics bypass the normalizer's native path parser.
+ */
+function appendBuildOutput(left, right) {
+    const hostInputs = [
+        ...new Set([...(left.hostInputs ?? []), ...(right.hostInputs ?? [])]),
+    ];
+    return (0, normalizeBuildOutput_1.normalizeBuildOutput)({
+        graph: mergeCheckGraphs(left.graph, right.graph),
+        diagnostics: [...left.diagnostics, ...right.diagnostics],
+        emittedFiles: right.emittedFiles !== undefined ? right.emittedFiles : left.emittedFiles,
+        emittedSources: right.emittedSources,
+        emittedSourceProofFailures: right.emittedSourceProofFailures,
+        processCompletedNormally: right.processCompletedNormally,
+        ...(left.hostInputs === undefined && right.hostInputs === undefined
+            ? {}
+            : {
+                hostInputs,
+                hostInputHashes: mergeInputWitnesses(left, right, "hostInputHashes", hostInputs),
+                hostInputRealpaths: mergeInputWitnesses(left, right, "hostInputRealpaths", hostInputs),
+            }),
+        ...(left.observationsComplete === false ||
+            right.observationsComplete === false
+            ? { observationsComplete: false }
+            : {}),
+        status: right.status !== 0 ? right.status : left.status,
+        stdout: left.stdout + right.stdout,
+        stderr: left.stderr + right.stderr,
+    });
+}
+/**
+ * Preserve each phase's source closure and refuse contradictory witnesses.
+ *
+ * @evidence contracts/common.md#principled-implementation Unioned memberships retain every producer's source authority; conflicting content, physical and predicate observations leave an explicit proof failure instead of selecting a later witness.
+ * @evidence contracts/common.md#clear-and-simple-design One graph combiner serves check composition and the later transform phase without reading inputs or creating a Program.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Reported omissions remain omissions; incompatible witnesses cannot be replaced by current filesystem observations.
+ * @evidence contracts/common.md#meaningful-documentation The native description states phase composition and the unresolved-witness behavior without claiming execution acceptance.
+ * @evidence contracts/performance.md#efficient-algorithms Each graph map and list is visited to union memberships and compare overlapping witnesses. Set membership avoids list cross-products; JSON comparison still visits overlapping predicate/value bytes and allocates comparison strings. Temporary maps, lists and Sets follow both graph populations, without a size ceiling here.
+ * @evidence contracts/performance.md#reuse-equivalent-work The combiner preserves supplied generation authority and compares overlapping witnesses; it retains no prior merged verdict and performs no input observation. A merged graph does not authorize reuse until the consuming generation validates every preserved witness and failure.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources Union maps, arrays, Sets and comparison strings are call-owned and the returned graph transfers to its caller. Inputs remain borrowed, and no historical graph population, native handle or background task is retained here; payload size is not capped.
+ * @evidence contracts/portability.md#os-neutral-implementation Compiler-reported graph coordinates and physical witnesses pass through unchanged. Case policy is retained only when both reports agree, and incompatible explicit policies leave proof failures; this combiner performs no native path lookup, separator rewriting or OS-name inference.
+ */
+function mergeCheckGraphs(left, right) {
+    if (left === undefined)
+        return right;
+    if (right === undefined)
+        return left;
+    const failures = { ...left.inputProofFailures, ...right.inputProofFailures };
+    if (left.useCaseSensitiveFileNames !== undefined &&
+        right.useCaseSensitiveFileNames !== undefined &&
+        left.useCaseSensitiveFileNames !== right.useCaseSensitiveFileNames)
+        for (const key of new Set([
+            ...Object.keys(left.edges),
+            ...Object.keys(right.edges),
+        ]))
+            failures[key] = "conflicting-check-case-policy";
+    const mergeLists = (a = {}, b = {}) => Object.fromEntries([...new Set([...Object.keys(a), ...Object.keys(b)])].map((key) => [
+        key,
+        [...new Set([...(a[key] ?? []), ...(b[key] ?? [])])],
+    ]));
+    const mergeProofs = (a = {}, b = {}) => {
+        const merged = { ...a, ...b };
+        for (const key of Object.keys(a))
+            if (Object.hasOwn(b, key) &&
+                JSON.stringify(a[key]) !== JSON.stringify(b[key])) {
+                delete merged[key];
+                failures[key] = "conflicting-check-generations";
+            }
+        return merged;
+    };
+    const observations = {
+        ...left.inputObservations,
+        ...right.inputObservations,
+    };
+    for (const key of Object.keys(left.inputObservations ?? {})) {
+        const a = left.inputObservations[key];
+        const b = right.inputObservations?.[key];
+        if (b === undefined)
+            continue;
+        const merged = { ...a, ...b };
+        for (const field of Object.keys(a)) {
+            if (field === "nativePredicates")
+                continue;
+            if (Object.hasOwn(b, field) &&
+                JSON.stringify(a[field]) !== JSON.stringify(b[field]))
+                failures[key] = "conflicting-check-generations";
+        }
+        if (a.nativePredicates !== undefined || b.nativePredicates !== undefined) {
+            const predicates = new Map();
+            const witnesses = new Map();
+            for (const predicate of [
+                ...(a.nativePredicates ?? []),
+                ...(b.nativePredicates ?? []),
+            ]) {
+                const { scope, ...witness } = predicate;
+                const serialized = JSON.stringify(witness);
+                const prior = witnesses.get(predicate.kind);
+                if (prior !== undefined && prior !== serialized)
+                    failures[key] = "conflicting-check-generations";
+                witnesses.set(predicate.kind, serialized);
+                predicates.set(`${predicate.kind}:${scope}`, predicate);
+            }
+            merged.nativePredicates = [...predicates.values()].sort((a, b) => `${a.kind}:${a.scope}`.localeCompare(`${b.kind}:${b.scope}`));
+        }
+        observations[key] = merged;
+    }
+    return {
+        edges: mergeLists(left.edges, right.edges),
+        globals: [...new Set([...left.globals, ...right.globals])],
+        configs: [...new Set([...left.configs, ...right.configs])],
+        candidates: mergeLists(left.candidates, right.candidates),
+        resolutionInputs: [
+            ...new Set([
+                ...(left.resolutionInputs ?? []),
+                ...(right.resolutionInputs ?? []),
+            ]),
+        ],
+        inputHashes: mergeProofs(left.inputHashes, right.inputHashes),
+        inputRealpaths: mergeProofs(left.inputRealpaths, right.inputRealpaths),
+        inputObservations: observations,
+        inputProofFailures: failures,
+        ...(left.useCaseSensitiveFileNames === right.useCaseSensitiveFileNames
+            ? { useCaseSensitiveFileNames: left.useCaseSensitiveFileNames }
+            : {}),
+    };
+}
+/**
+ * A phase declaring an input must agree with every other declaring phase.
+ * Retaining declarations after proof loss makes that loss sticky across later
+ * merges; phases with no declaration do not invalidate an earlier witness.
+ */
+function mergeInputWitnesses(left, right, field, inputs) {
+    const leftInputs = new Set(left.hostInputs);
+    const rightInputs = new Set(right.hostInputs);
+    const output = Object.create(null);
+    for (const input of inputs) {
+        const inLeft = leftInputs.has(input);
+        const inRight = rightInputs.has(input);
+        const leftKnown = Object.hasOwn(left[field] ?? {}, input);
+        const rightKnown = Object.hasOwn(right[field] ?? {}, input);
+        if (inLeft && inRight) {
+            if (leftKnown &&
+                rightKnown &&
+                left[field][input] === right[field][input])
+                output[input] = left[field][input];
+        }
+        else if (inLeft && leftKnown)
+            output[input] = left[field][input];
+        else if (inRight && rightKnown)
+            output[input] = right[field][input];
+    }
+    return output;
+}
+//# sourceMappingURL=appendBuildOutput.js.map

package/lib/compiler/internal/build/appendBuildOutput.js.map

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

package/lib/compiler/internal/build/bufferResidentCheckEntryRequests.d.ts

@@ -0,0 +1,20 @@
+import { type ResidentCheckRequest } from "../ResidentCheckRequest";
+import type { ResidentCheckEntryPlan } from "./ResidentCheckEntryPlan";
+/**
+ * Retain changes separately for each resident check's configuration position.
+ * Duplicate entries may share a sidecar while still needing independent
+ * delivery; an earlier failure must not consume a later entry's pending edits.
+ * Existing path sets are merged and invalidation is sticky until consumption.
+ *
+ * @evidence contracts/common.md#principled-implementation Entry-indexed buffers preserve delivery to every configured check even when process keys coincide; set union and boolean OR retain all pending changes.
+ * @evidence contracts/common.md#clear-and-simple-design The outer loop selects resident entries and one private merger owns canonical request construction; process sharing remains separate from delivery ownership.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Buffering follows configured positions rather than deduplicating plugin executions to hide failures; inputs are not patched or mutated.
+ * @evidence contracts/common.md#meaningful-documentation The native comment explains duplicate-entry delivery, failure effects and sticky invalidation with separate prose and acknowledgment blocks.
+ * @evidence contracts/performance.md#efficient-algorithms Each resident entry scans its previous and incoming path lists into Sets and sorts the distinct spellings. Work includes string hashing and sort comparisons; temporary space scales with scanned references and unique paths, repeated separately for each configured delivery position.
+ *
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This buffer preserves delivery data rather than coordinating shared computation; each configured effectful check still runs separately when due.
+ *
+ * @evidence contracts/performance.md#bound-retention-and-release-resources The caller owns the pending map, with one slot per configured resident entry; consumption or session reset releases it, while unique paths can grow without a bound if an earlier check keeps failing.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation This merger compares supplied path strings as delivery data without interpreting filesystem identity, case policy or native separators; the request adapter and native consumer own those boundaries.
+ */
+export declare function bufferResidentCheckEntryRequests(pending: Map<number, ResidentCheckRequest>, checks: readonly ResidentCheckEntryPlan[], request: ResidentCheckRequest): void;

package/lib/compiler/internal/build/bufferResidentCheckEntryRequests.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bufferResidentCheckEntryRequests = bufferResidentCheckEntryRequests;
+/**
+ * Retain changes separately for each resident check's configuration position.
+ * Duplicate entries may share a sidecar while still needing independent
+ * delivery; an earlier failure must not consume a later entry's pending edits.
+ * Existing path sets are merged and invalidation is sticky until consumption.
+ *
+ * @evidence contracts/common.md#principled-implementation Entry-indexed buffers preserve delivery to every configured check even when process keys coincide; set union and boolean OR retain all pending changes.
+ * @evidence contracts/common.md#clear-and-simple-design The outer loop selects resident entries and one private merger owns canonical request construction; process sharing remains separate from delivery ownership.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Buffering follows configured positions rather than deduplicating plugin executions to hide failures; inputs are not patched or mutated.
+ * @evidence contracts/common.md#meaningful-documentation The native comment explains duplicate-entry delivery, failure effects and sticky invalidation with separate prose and acknowledgment blocks.
+ * @evidence contracts/performance.md#efficient-algorithms Each resident entry scans its previous and incoming path lists into Sets and sorts the distinct spellings. Work includes string hashing and sort comparisons; temporary space scales with scanned references and unique paths, repeated separately for each configured delivery position.
+ *
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This buffer preserves delivery data rather than coordinating shared computation; each configured effectful check still runs separately when due.
+ *
+ * @evidence contracts/performance.md#bound-retention-and-release-resources The caller owns the pending map, with one slot per configured resident entry; consumption or session reset releases it, while unique paths can grow without a bound if an earlier check keeps failing.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation This merger compares supplied path strings as delivery data without interpreting filesystem identity, case policy or native separators; the request adapter and native consumer own those boundaries.
+ */
+function bufferResidentCheckEntryRequests(pending, checks, request) {
+    for (const check of checks) {
+        if (check.key === undefined)
+            continue;
+        pending.set(check.entryIndex, mergeResidentCheckRequests(pending.get(check.entryIndex), request));
+    }
+}
+function mergeResidentCheckRequests(previous, current) {
+    const merge = (left, right) => [...new Set([...(left ?? []), ...(right ?? [])])].sort();
+    const changed = merge(previous?.changed, current.changed);
+    const external = merge(previous?.external, current.external);
+    return {
+        ...(changed.length === 0 ? {} : { changed }),
+        ...(external.length === 0 ? {} : { external }),
+        ...(previous?.invalidate === true || current.invalidate === true
+            ? { invalidate: true }
+            : {}),
+    };
+}
+//# sourceMappingURL=bufferResidentCheckEntryRequests.js.map

package/lib/compiler/internal/build/bufferResidentCheckEntryRequests.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bufferResidentCheckEntryRequests.js","sourceRoot":"","sources":["../../../../src/compiler/internal/build/bufferResidentCheckEntryRequests.ts"],"names":[],"mappings":";;;AAGA;;;;;;;;;;;;;;;;GAgBG;AACH,0CACE,OAA0C,EAC1C,MAAyC,EACzC,OAA6B;IAE7B,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QAC3B,IAAI,KAAK,CAAC,GAAG,KAAK,SAAS;YAAE,SAAS;QACtC,OAAO,CAAC,GAAG,CACT,KAAK,CAAC,UAAU,EAChB,0BAA0B,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC,CACnE,CAAC;IACJ,CAAC;AACH,CAAC;AAED,SAAS,0BAA0B,CACjC,QAA0C,EAC1C,OAA6B;IAE7B,MAAM,KAAK,GAAG,CACZ,IAAmC,EACnC,KAAoC,EAC1B,EAAE,CAAC,CAAC,GAAG,IAAI,GAAG,CAAC,CAAC,GAAG,CAAC,IAAI,IAAI,EAAE,CAAC,EAAE,GAAG,CAAC,KAAK,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;IACxE,MAAM,OAAO,GAAG,KAAK,CAAC,QAAQ,EAAE,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC;IAC1D,MAAM,QAAQ,GAAG,KAAK,CAAC,QAAQ,EAAE,QAAQ,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC;IAC7D,OAAO;QACL,GAAG,CAAC,OAAO,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC;QAC5C,GAAG,CAAC,QAAQ,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC;QAC9C,GAAG,CAAC,QAAQ,EAAE,UAAU,KAAK,IAAI,IAAI,OAAO,CAAC,UAAU,KAAK,IAAI;YAC9D,CAAC,CAAC,EAAE,UAAU,EAAE,IAAI,EAAE;YACtB,CAAC,CAAC,EAAE,CAAC;KACR,CAAC;AACJ,CAAC"}

package/lib/compiler/internal/build/createProcessDiagnostic.d.ts

@@ -0,0 +1,19 @@
+import type { ITtscCompilerDiagnostic } from "../../../structures/ITtscCompilerDiagnostic";
+import type { TtscBuildResult } from "../../../structures/internal/TtscBuildResult";
+/**
+ * Synthesize one structured diagnostic from a non-zero process result that
+ * produced no parsable diagnostics. A truthy stderr string is selected before
+ * stdout and then trimmed; an empty trimmed selection falls back to exit
+ * status. Public API mapping and plugin-failure recovery share this policy,
+ * which does not preserve every captured byte or both streams.
+ *
+ * @evidence contracts/common.md#principled-implementation A process-level error has no source file and uses TTSC_PROCESS; captured stderr takes precedence over stdout, with actual exit status as the empty-output fallback.
+ * @evidence contracts/common.md#clear-and-simple-design One adapter supplies the same process-failure representation to API mapping and plugin fallback rather than duplicating their message policy.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The stable process diagnostic code is a product discriminant; message content comes from the real result rather than a fixture-specific synthetic compiler error.
+ * @evidence contracts/common.md#meaningful-documentation Native documentation gives the intended nonzero, unparsed-result premise and explains why callers share this mapping.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The returned diagnostic transfers its selected message to the caller; this adapter acquires no handle, task or persistent state.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms This single-result adapter delegates string trimming and constructs a fixed-shape diagnostic. Work depends on selected text length, but it selects no independent growing-population algorithm.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work The supplied result is current input; this adapter owns no stable producer capture or cross-call cache.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation Captured streams and status are supplied data, file is null, and this adapter performs no native path, filesystem or process operation.
+ */
+export declare function createProcessDiagnostic(result: TtscBuildResult): ITtscCompilerDiagnostic;

package/lib/compiler/internal/build/createProcessDiagnostic.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createProcessDiagnostic = createProcessDiagnostic;
+/**
+ * Synthesize one structured diagnostic from a non-zero process result that
+ * produced no parsable diagnostics. A truthy stderr string is selected before
+ * stdout and then trimmed; an empty trimmed selection falls back to exit
+ * status. Public API mapping and plugin-failure recovery share this policy,
+ * which does not preserve every captured byte or both streams.
+ *
+ * @evidence contracts/common.md#principled-implementation A process-level error has no source file and uses TTSC_PROCESS; captured stderr takes precedence over stdout, with actual exit status as the empty-output fallback.
+ * @evidence contracts/common.md#clear-and-simple-design One adapter supplies the same process-failure representation to API mapping and plugin fallback rather than duplicating their message policy.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The stable process diagnostic code is a product discriminant; message content comes from the real result rather than a fixture-specific synthetic compiler error.
+ * @evidence contracts/common.md#meaningful-documentation Native documentation gives the intended nonzero, unparsed-result premise and explains why callers share this mapping.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The returned diagnostic transfers its selected message to the caller; this adapter acquires no handle, task or persistent state.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms This single-result adapter delegates string trimming and constructs a fixed-shape diagnostic. Work depends on selected text length, but it selects no independent growing-population algorithm.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work The supplied result is current input; this adapter owns no stable producer capture or cross-call cache.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation Captured streams and status are supplied data, file is null, and this adapter performs no native path, filesystem or process operation.
+ */
+function createProcessDiagnostic(result) {
+    const messageText = (result.stderr || result.stdout).trim() ||
+        `ttsc exited with status ${result.status}`;
+    return {
+        category: "error",
+        code: "TTSC_PROCESS",
+        file: null,
+        messageText,
+    };
+}
+//# sourceMappingURL=createProcessDiagnostic.js.map

package/lib/compiler/internal/build/createProcessDiagnostic.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createProcessDiagnostic.js","sourceRoot":"","sources":["../../../../src/compiler/internal/build/createProcessDiagnostic.ts"],"names":[],"mappings":";;;AAGA;;;;;;;;;;;;;;;GAeG;AACH,iCACE,MAAuB;IAEvB,MAAM,WAAW,GACf,CAAC,MAAM,CAAC,MAAM,IAAI,MAAM,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE;QACvC,2BAA2B,MAAM,CAAC,MAAM,EAAE,CAAC;IAC7C,OAAO;QACL,QAAQ,EAAE,OAAO;QACjB,IAAI,EAAE,cAAc;QACpB,IAAI,EAAE,IAAI;QACV,WAAW;KACZ,CAAC;AACJ,CAAC"}

package/lib/compiler/internal/build/isAbsoluteLocalProjectInputPath.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Whether a published project-input spelling fits the selected native absolute
+ * filesystem namespace: free of NUL and, on Windows, outside device namespaces.
+ * This does not establish existence, access or actual watcher support. UNC
+ * shares may denote network storage; local here means native path syntax, not a
+ * URL.
+ *
+ * On Windows that admits drive paths, extended-length drive paths, and UNC
+ * shares (including the `\\?\UNC\` form), and rejects device namespaces such as
+ * `\\.\pipe\...`, which name no file a watcher could observe.
+ *
+ * @param platform Path rules to apply; defaults to the host platform.
+ * @evidence contracts/common.md#principled-implementation POSIX absolute syntax and explicit Windows drive/UNC recognizers distinguish syntactically admissible native paths from relative and Windows device namespaces; this is not an existence, file-kind or watch-capability check.
+ * @evidence contracts/common.md#clear-and-simple-design Platform selection precedes Windows namespace recognition, with UNC volume validation kept in small private helpers.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Namespace rules follow path syntax and do not whitelist projects or pretend device handles are ordinary files.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs name admitted Windows forms, rejected devices and the injectable platform parameter.
+ * @evidence contracts/portability.md#os-neutral-implementation Explicit platform syntax uses path.posix or drive/UNC rules independent of the executing host; it does not infer existence, case policy or watcher support from the platform label.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Normalized/sliced path strings are temporary and can scale with the supplied spelling; no path history, descriptor or task is retained after return.
+ * @evidence contracts/performance.md#efficient-algorithms NUL detection scans input text; Windows additionally replaces separators and can slice/lowercase extended text before drive/UNC and volume-segment regex checks. Work and temporary strings scale with path bytes, with short-circuit branches avoiding later checks; no native I/O is performed.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This call-local namespace classifier coordinates no retained or in-flight producer; native identity or watch-capability reuse belongs to its callers.
+ */
+export declare function isAbsoluteLocalProjectInputPath(location: string, platform?: NodeJS.Platform): boolean;

package/lib/compiler/internal/build/isAbsoluteLocalProjectInputPath.js

@@ -0,0 +1,59 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAbsoluteLocalProjectInputPath = isAbsoluteLocalProjectInputPath;
+const node_path_1 = __importDefault(require("node:path"));
+/**
+ * Whether a published project-input spelling fits the selected native absolute
+ * filesystem namespace: free of NUL and, on Windows, outside device namespaces.
+ * This does not establish existence, access or actual watcher support. UNC
+ * shares may denote network storage; local here means native path syntax, not a
+ * URL.
+ *
+ * On Windows that admits drive paths, extended-length drive paths, and UNC
+ * shares (including the `\\?\UNC\` form), and rejects device namespaces such as
+ * `\\.\pipe\...`, which name no file a watcher could observe.
+ *
+ * @param platform Path rules to apply; defaults to the host platform.
+ * @evidence contracts/common.md#principled-implementation POSIX absolute syntax and explicit Windows drive/UNC recognizers distinguish syntactically admissible native paths from relative and Windows device namespaces; this is not an existence, file-kind or watch-capability check.
+ * @evidence contracts/common.md#clear-and-simple-design Platform selection precedes Windows namespace recognition, with UNC volume validation kept in small private helpers.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Namespace rules follow path syntax and do not whitelist projects or pretend device handles are ordinary files.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs name admitted Windows forms, rejected devices and the injectable platform parameter.
+ * @evidence contracts/portability.md#os-neutral-implementation Explicit platform syntax uses path.posix or drive/UNC rules independent of the executing host; it does not infer existence, case policy or watcher support from the platform label.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Normalized/sliced path strings are temporary and can scale with the supplied spelling; no path history, descriptor or task is retained after return.
+ * @evidence contracts/performance.md#efficient-algorithms NUL detection scans input text; Windows additionally replaces separators and can slice/lowercase extended text before drive/UNC and volume-segment regex checks. Work and temporary strings scale with path bytes, with short-circuit branches avoiding later checks; no native I/O is performed.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This call-local namespace classifier coordinates no retained or in-flight producer; native identity or watch-capability reuse belongs to its callers.
+ */
+function isAbsoluteLocalProjectInputPath(location, platform = process.platform) {
+    if (location.includes("\0"))
+        return false;
+    if (platform !== "win32")
+        return node_path_1.default.posix.isAbsolute(location);
+    const normalized = location.replaceAll("/", "\\");
+    if (/^[A-Za-z]:\\/.test(normalized))
+        return true;
+    if (normalized.startsWith("\\\\?\\")) {
+        const extended = normalized.slice(4);
+        if (/^[A-Za-z]:\\/.test(extended))
+            return true;
+        if (extended.toLowerCase().startsWith("unc\\")) {
+            return isWindowsUncProjectInputPath(`\\\\${extended.slice(4)}`);
+        }
+        return false;
+    }
+    if (normalized.startsWith("\\\\.\\"))
+        return false;
+    return isWindowsUncProjectInputPath(normalized);
+}
+function isWindowsUncProjectInputPath(location) {
+    const matched = /^\\\\([^\\]+)\\([^\\]+)(?:\\|$)/.exec(location);
+    return (matched !== null &&
+        isWindowsUncVolumeSegment(matched[1]) &&
+        isWindowsUncVolumeSegment(matched[2]));
+}
+function isWindowsUncVolumeSegment(segment) {
+    return segment !== "." && segment !== ".." && !/[\0<>:"/\\|?*]/.test(segment);
+}
+//# sourceMappingURL=isAbsoluteLocalProjectInputPath.js.map

package/lib/compiler/internal/build/isAbsoluteLocalProjectInputPath.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isAbsoluteLocalProjectInputPath.js","sourceRoot":"","sources":["../../../../src/compiler/internal/build/isAbsoluteLocalProjectInputPath.ts"],"names":[],"mappings":";;;;;;AAAA,0DAA6B;AAE7B;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,yCACE,QAAgB,EAChB,QAAQ,GAAoB,OAAO,CAAC,QAAQ;IAE5C,IAAI,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC;QAAE,OAAO,KAAK,CAAC;IAC1C,IAAI,QAAQ,KAAK,OAAO;QAAE,OAAO,mBAAI,CAAC,KAAK,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC;IACjE,MAAM,UAAU,GAAG,QAAQ,CAAC,UAAU,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;IAClD,IAAI,cAAc,CAAC,IAAI,CAAC,UAAU,CAAC;QAAE,OAAO,IAAI,CAAC;IACjD,IAAI,UAAU,CAAC,UAAU,CAAC,SAAS,CAAC,EAAE,CAAC;QACrC,MAAM,QAAQ,GAAG,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QACrC,IAAI,cAAc,CAAC,IAAI,CAAC,QAAQ,CAAC;YAAE,OAAO,IAAI,CAAC;QAC/C,IAAI,QAAQ,CAAC,WAAW,EAAE,CAAC,UAAU,CAAC,OAAO,CAAC,EAAE,CAAC;YAC/C,OAAO,4BAA4B,CAAC,OAAO,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;QAClE,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IACD,IAAI,UAAU,CAAC,UAAU,CAAC,SAAS,CAAC;QAAE,OAAO,KAAK,CAAC;IACnD,OAAO,4BAA4B,CAAC,UAAU,CAAC,CAAC;AAClD,CAAC;AAED,SAAS,4BAA4B,CAAC,QAAgB;IACpD,MAAM,OAAO,GAAG,iCAAiC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IACjE,OAAO,CACL,OAAO,KAAK,IAAI;QAChB,yBAAyB,CAAC,OAAO,CAAC,CAAC,CAAE,CAAC;QACtC,yBAAyB,CAAC,OAAO,CAAC,CAAC,CAAE,CAAC,CACvC,CAAC;AACJ,CAAC;AAED,SAAS,yBAAyB,CAAC,OAAe;IAChD,OAAO,OAAO,KAAK,GAAG,IAAI,OAAO,KAAK,IAAI,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;AAChF,CAAC"}

package/lib/compiler/internal/build/mergeProjectInputSnapshots.d.ts

@@ -0,0 +1,28 @@
+import { type ProjectInputPathIdentityContext } from "../../../internal/pathIdentity/ProjectInputPathIdentityContext";
+import type { ITtscProjectInputSnapshot } from "../../../structures/internal/ITtscProjectInputSnapshot";
+/**
+ * Merge the project-input snapshots of several plugins into one.
+ *
+ * Every snapshot must be anchored at the selected project root; a plugin that
+ * resolved a different root is an error rather than a silent union. Entries are
+ * deduplicated by the resolver's native identity keys. Aliases sharing an
+ * observed target key collapse; unknown/missing identities preserve their
+ * resolver distinctions rather than certifying every hard-link/inode alias. The
+ * spellings the plugins actually published survive under `declared` whenever
+ * they differ from the normalized ones, because a watcher has to observe a
+ * symlink itself, not only the file it currently points at.
+ *
+ * @param fallbackRoot The selected project root every snapshot must share.
+ * @param identities Identity resolver for this merge; one is created when
+ *   omitted.
+ * @evidence contracts/common.md#principled-implementation Identity keys merge physical targets while separate declared spellings retain every alias a watcher must observe; incompatible project roots throw.
+ * @evidence contracts/common.md#clear-and-simple-design Four parallel identity maps represent the four snapshot categories; one spelling helper handles alias membership without changing their distinct meanings.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Alias retention follows filesystem identity and the watch contract, rather than replacing filesystem methods or recognizing particular projects.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain root rejection, physical deduplication and why declared aliases survive; parameter documentation is separated from acknowledgments.
+ * @evidence contracts/portability.md#os-neutral-implementation The supplied identity context owns filesystem capabilities; node:path resolves native declarations and only glob output changes separators to protocol slashes.
+ * @evidence contracts/performance.md#efficient-algorithms Declarations use map/Set membership and one memoized native identity context, including delegated filesystem capability/ancestor observations. Path resolution/normalization and canonical comparisons have text costs. Unique entries and all retained declared aliases are separately flattened/sorted, so counts and bytes of both populations drive time/storage, not only unique identities.
+ * @evidence contracts/performance.md#reuse-equivalent-work One identity context memoizes resolution across roots and repeated declarations in this merge; its caller controls reuse beyond this transaction and must invalidate changed filesystem observations.
+ *
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Maps, Sets and a default identity memo are call-local; returned snapshot arrays transfer to the caller. A supplied identity context may outlive this merge under its caller's invalidation policy; no independent descriptor, watcher or historical snapshot is retained by this function.
+ */
+export declare function mergeProjectInputSnapshots(fallbackRoot: string, snapshots: readonly ITtscProjectInputSnapshot[], identities?: ProjectInputPathIdentityContext): ITtscProjectInputSnapshot;

package/lib/compiler/internal/build/mergeProjectInputSnapshots.js

@@ -0,0 +1,121 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeProjectInputSnapshots = mergeProjectInputSnapshots;
+const node_path_1 = __importDefault(require("node:path"));
+const createProjectInputPathIdentityContext_1 = require("../../../internal/pathIdentity/createProjectInputPathIdentityContext");
+/**
+ * Merge the project-input snapshots of several plugins into one.
+ *
+ * Every snapshot must be anchored at the selected project root; a plugin that
+ * resolved a different root is an error rather than a silent union. Entries are
+ * deduplicated by the resolver's native identity keys. Aliases sharing an
+ * observed target key collapse; unknown/missing identities preserve their
+ * resolver distinctions rather than certifying every hard-link/inode alias. The
+ * spellings the plugins actually published survive under `declared` whenever
+ * they differ from the normalized ones, because a watcher has to observe a
+ * symlink itself, not only the file it currently points at.
+ *
+ * @param fallbackRoot The selected project root every snapshot must share.
+ * @param identities Identity resolver for this merge; one is created when
+ *   omitted.
+ * @evidence contracts/common.md#principled-implementation Identity keys merge physical targets while separate declared spellings retain every alias a watcher must observe; incompatible project roots throw.
+ * @evidence contracts/common.md#clear-and-simple-design Four parallel identity maps represent the four snapshot categories; one spelling helper handles alias membership without changing their distinct meanings.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Alias retention follows filesystem identity and the watch contract, rather than replacing filesystem methods or recognizing particular projects.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain root rejection, physical deduplication and why declared aliases survive; parameter documentation is separated from acknowledgments.
+ * @evidence contracts/portability.md#os-neutral-implementation The supplied identity context owns filesystem capabilities; node:path resolves native declarations and only glob output changes separators to protocol slashes.
+ * @evidence contracts/performance.md#efficient-algorithms Declarations use map/Set membership and one memoized native identity context, including delegated filesystem capability/ancestor observations. Path resolution/normalization and canonical comparisons have text costs. Unique entries and all retained declared aliases are separately flattened/sorted, so counts and bytes of both populations drive time/storage, not only unique identities.
+ * @evidence contracts/performance.md#reuse-equivalent-work One identity context memoizes resolution across roots and repeated declarations in this merge; its caller controls reuse beyond this transaction and must invalidate changed filesystem observations.
+ *
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Maps, Sets and a default identity memo are call-local; returned snapshot arrays transfer to the caller. A supplied identity context may outlive this merge under its caller's invalidation policy; no independent descriptor, watcher or historical snapshot is retained by this function.
+ */
+function mergeProjectInputSnapshots(fallbackRoot, snapshots, identities = (0, createProjectInputPathIdentityContext_1.createProjectInputPathIdentityContext)()) {
+    const files = new Map();
+    const globs = new Map();
+    const reloadDirectories = new Map();
+    const reloadFiles = new Map();
+    // Deduplicated on the same identity keys, but holding what the contributors
+    // wrote. Normalization resolves a declaration through its symlinks, which is
+    // right for every comparison and wrong for the watcher that has to observe
+    // the link itself being retargeted.
+    const declaredFiles = new Map();
+    const declaredGlobs = new Map();
+    const declaredReloadDirectories = new Map();
+    const declaredReloadFiles = new Map();
+    const rootIdentity = identities.resolve(fallbackRoot);
+    for (const snapshot of snapshots) {
+        const candidateRoot = identities.resolve(snapshot.root);
+        if (rootIdentity.key !== candidateRoot.key) {
+            throw new Error(`ttsc.project-inputs: plugin root ${candidateRoot.path} differs from the selected project root ${rootIdentity.path}`);
+        }
+        for (const file of snapshot.files) {
+            const identity = identities.resolve(file);
+            files.set(identity.key, identity.path);
+            retainDeclaredSpelling(declaredFiles, identity.key, node_path_1.default.resolve(file));
+        }
+        for (const glob of snapshot.globs) {
+            const identity = identities.resolve(glob);
+            globs.set(identity.key, identity.path.split(node_path_1.default.sep).join("/"));
+            retainDeclaredSpelling(declaredGlobs, identity.key, node_path_1.default.resolve(glob).split(node_path_1.default.sep).join("/"));
+        }
+        for (const reloadFile of snapshot.reloadFiles ?? []) {
+            const identity = identities.resolve(reloadFile);
+            reloadFiles.set(identity.key, identity.path);
+            retainDeclaredSpelling(declaredReloadFiles, identity.key, node_path_1.default.resolve(reloadFile));
+        }
+        for (const reloadDirectory of snapshot.reloadDirectories ?? []) {
+            const identity = identities.resolve(reloadDirectory);
+            reloadDirectories.set(identity.key, identity.path);
+            retainDeclaredSpelling(declaredReloadDirectories, identity.key, node_path_1.default.resolve(reloadDirectory));
+        }
+    }
+    const normalized = {
+        root: rootIdentity.path,
+        files: [...files.values()].sort(),
+        globs: [...globs.values()].sort(),
+        reloadDirectories: [...reloadDirectories.values()].sort(),
+        reloadFiles: [...reloadFiles.values()].sort(),
+    };
+    const declared = {
+        files: [...declaredFiles.values()].flatMap((values) => [...values]).sort(),
+        globs: [...declaredGlobs.values()].flatMap((values) => [...values]).sort(),
+        reloadDirectories: [...declaredReloadDirectories.values()]
+            .flatMap((values) => [...values])
+            .sort(),
+        reloadFiles: [...declaredReloadFiles.values()]
+            .flatMap((values) => [...values])
+            .sort(),
+    };
+    // Carried only when it says something the normalized arrays do not. A tree
+    // with no alias on any declaration produces the same four lists, and a
+    // consumer that has to scan both would pay twice for one population.
+    return arraysEqual(declared.files, normalized.files) &&
+        arraysEqual(declared.globs, normalized.globs) &&
+        arraysEqual(declared.reloadDirectories, normalized.reloadDirectories) &&
+        arraysEqual(declared.reloadFiles, normalized.reloadFiles)
+        ? normalized
+        : { ...normalized, declared };
+}
+function arraysEqual(left, right) {
+    return (left.length === right.length && left.every((item, i) => item === right[i]));
+}
+/**
+ * Keep every declared spelling of one identity, ordered without regard to which
+ * producer ran first.
+ *
+ * Two contributors can name the same file through different aliases, and each
+ * alias is a path a watcher has to observe: keeping only one of them would
+ * discard the link whose retarget the other spelling exists to catch. Insertion
+ * order is not canonical, so the caller sorts the flattened result.
+ */
+function retainDeclaredSpelling(target, key, declared) {
+    const previous = target.get(key);
+    if (previous === undefined) {
+        target.set(key, new Set([declared]));
+        return;
+    }
+    previous.add(declared);
+}
+//# sourceMappingURL=mergeProjectInputSnapshots.js.map

package/lib/compiler/internal/build/mergeProjectInputSnapshots.js.map

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

package/lib/compiler/internal/build/normalizeBuildOutput.d.ts

@@ -0,0 +1,29 @@
+import type { ITtscCompilerDiagnostic } from "../../../structures/ITtscCompilerDiagnostic";
+import type { TtscBuildResult } from "../../../structures/internal/TtscBuildResult";
+/**
+ * Normalise a raw spawn result into a `TtscBuildResult`.
+ *
+ * When `diagnostics` is absent they are parsed from the text output. When the
+ * process exited non-zero but stderr is empty and stdout is non-empty, stdout
+ * is moved to stderr so the error is visible to callers who only check stderr.
+ * All other result metadata, including emit provenance, is preserved.
+ *
+ * @evidence contracts/common.md#principled-implementation Explicit diagnostics take precedence over text parsing; failure-output relocation preserves status and emit-provenance metadata while making captured error text visible.
+ * @evidence contracts/common.md#clear-and-simple-design Output normalization and optional parsing share one entry point; a private parser owns summary skipping and indented message continuation.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Parsed compiler formats and actual process status determine results; unmatched text is not fabricated into a successful diagnostic record.
+ * @evidence contracts/common.md#meaningful-documentation Native prose explains absent diagnostics and the failure-output relocation; the private parser explains continuation and summary handling.
+ * @evidence contracts/portability.md#os-neutral-implementation Diagnostic filenames use the native path normalizer with optional compiler cwd; CRLF and LF output are both recognized without case-policy guesses.
+ * @evidence contracts/performance.md#efficient-algorithms Absent diagnostics require ANSI stripping and line splitting followed by format matches on each line. Continuation chunks are joined once per diagnostic instead of repeatedly concatenating a growing message; temporary lines, chunks and records scale with captured output. Supplied arrays bypass this work.
+ * @evidence contracts/performance.md#reuse-equivalent-work Preparsed diagnostics are reused directly instead of reconstructing the same records from stdout and stderr.
+ *
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources This adapter returns data without owning a process, persistent cache or retained history.
+ */
+export declare function normalizeBuildOutput(result: PartialBuildResult, cwd?: string): TtscBuildResult;
+/**
+ * `TtscBuildResult` with `diagnostics` made optional. Used internally when
+ * diagnostics are parsed lazily from stdout/stderr by `normalizeBuildOutput`.
+ */
+type PartialBuildResult = Omit<TtscBuildResult, "diagnostics"> & {
+    diagnostics?: ITtscCompilerDiagnostic[];
+};
+export {};