ttsc 0.30.4 → 0.31.1

package/lib/plugin/internal/source/copiesPluginSourceEntry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"copiesPluginSourceEntry.js","sourceRoot":"","sources":["../../../../src/plugin/internal/source/copiesPluginSourceEntry.ts"],"names":[],"mappings":";;;;;;AAAA,sDAAyB;AACzB,0DAA6B;AAE7B,qDAAkD;AAElD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,iCACE,IAAY,EACZ,QAAgB;IAEhB,IAAI,mBAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,KAAK,mBAAI,CAAC,OAAO,CAAC,IAAI,CAAC;QAAE,OAAO,IAAI,CAAC;IAC/D,IAAI,IAAc,CAAC;IACnB,IAAI,CAAC;QACH,IAAI,GAAG,iBAAE,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;IAChC,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,KAAK,CAAC;IACf,CAAC;IACD,MAAM,IAAI,GAAG,mBAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;IACrC,IAAI,IAAI,CAAC,WAAW,EAAE;QAAE,OAAO,CAAC,+BAAc,CAAC,oBAAoB,CAAC,IAAI,CAAC,CAAC;IAC1E,OAAO,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,+BAAc,CAAC,oBAAoB,CAAC,IAAI,CAAC,CAAC;AACrE,CAAC"}

package/lib/plugin/internal/source/createExternalSourceSnapshotLayout.d.ts

@@ -0,0 +1,22 @@
+import path from "node:path";
+/**
+ * Plan private copies as translations of each volume's smallest source tree.
+ * Removing ancestors shared by every selected root preserves relative paths
+ * between external sources without carrying their unrelated absolute ancestry
+ * into native compiler working directories. Main-module placement is separate.
+ *
+ * All roots must be supplied together: adding another root can change the
+ * common ancestor. Compact volume ordinals distinguish drives and UNC shares
+ * only inside this private attempt; original paths remain source/key identity.
+ * Descendant depth and the private base can still exceed a native cwd limit.
+ *
+ * @evidence contracts/common.md#principled-implementation Each volume's longest common component prefix is removed uniformly, preserving relative component distances and overlapping roots; distinct volume authorities receive disjoint private namespaces.
+ * @evidence contracts/common.md#clear-and-simple-design One complete-population planning operation returns the original-to-private mapping before copying starts; it neither acquires a lease nor rewrites source inputs.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Component translation applies to every supplied root without consumer or length exceptions; it does not flatten modules, rewrite compiler arguments or read live original bytes in place of a snapshot.
+ * @evidence contracts/common.md#meaningful-documentation Native prose explains preserved geometry, complete-population ownership, volume ordinals and the remaining native cwd bound.
+ * @evidence contracts/portability.md#os-neutral-implementation The selected native path grammar supplies root parsing and separators; exact component comparison conservatively preserves spelling, including Windows case-sensitive directories and UNC authorities, without realpath or junction substitution.
+ * @evidence contracts/performance.md#efficient-algorithms Each source path is resolved and split once; common-prefix comparisons follow its component population, and volume authority names are sorted once to assign deterministic private ordinals. Returned path text contributes output work.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work A plan belongs to one complete supplied source population; it caches no filesystem or compiler observation.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources Maps and component arrays are call-local; only the path mapping transfers to the scratch owner, with no acquired handles or independent resource lifetime.
+ */
+export declare function createExternalSourceSnapshotLayout(privateRoot: string, directories: readonly string[], paths?: typeof path): Map<string, string>;

package/lib/plugin/internal/source/createExternalSourceSnapshotLayout.js

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createExternalSourceSnapshotLayout = createExternalSourceSnapshotLayout;
+const node_path_1 = __importDefault(require("node:path"));
+/**
+ * Plan private copies as translations of each volume's smallest source tree.
+ * Removing ancestors shared by every selected root preserves relative paths
+ * between external sources without carrying their unrelated absolute ancestry
+ * into native compiler working directories. Main-module placement is separate.
+ *
+ * All roots must be supplied together: adding another root can change the
+ * common ancestor. Compact volume ordinals distinguish drives and UNC shares
+ * only inside this private attempt; original paths remain source/key identity.
+ * Descendant depth and the private base can still exceed a native cwd limit.
+ *
+ * @evidence contracts/common.md#principled-implementation Each volume's longest common component prefix is removed uniformly, preserving relative component distances and overlapping roots; distinct volume authorities receive disjoint private namespaces.
+ * @evidence contracts/common.md#clear-and-simple-design One complete-population planning operation returns the original-to-private mapping before copying starts; it neither acquires a lease nor rewrites source inputs.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Component translation applies to every supplied root without consumer or length exceptions; it does not flatten modules, rewrite compiler arguments or read live original bytes in place of a snapshot.
+ * @evidence contracts/common.md#meaningful-documentation Native prose explains preserved geometry, complete-population ownership, volume ordinals and the remaining native cwd bound.
+ * @evidence contracts/portability.md#os-neutral-implementation The selected native path grammar supplies root parsing and separators; exact component comparison conservatively preserves spelling, including Windows case-sensitive directories and UNC authorities, without realpath or junction substitution.
+ * @evidence contracts/performance.md#efficient-algorithms Each source path is resolved and split once; common-prefix comparisons follow its component population, and volume authority names are sorted once to assign deterministic private ordinals. Returned path text contributes output work.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work A plan belongs to one complete supplied source population; it caches no filesystem or compiler observation.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources Maps and component arrays are call-local; only the path mapping transfers to the scratch owner, with no acquired handles or independent resource lifetime.
+ */
+function createExternalSourceSnapshotLayout(privateRoot, directories, paths = node_path_1.default) {
+    const volumes = new Map();
+    for (const directory of directories) {
+        const absolute = paths.resolve(directory);
+        const root = paths.parse(absolute).root;
+        const parts = absolute.slice(root.length).split(paths.sep).filter(Boolean);
+        const volume = volumes.get(root);
+        if (volume === undefined) {
+            volumes.set(root, {
+                common: [...parts],
+                sources: new Map([[absolute, parts]]),
+            });
+            continue;
+        }
+        volume.sources.set(absolute, parts);
+        let commonLength = 0;
+        while (commonLength < volume.common.length &&
+            commonLength < parts.length &&
+            volume.common[commonLength] === parts[commonLength])
+            ++commonLength;
+        volume.common.length = commonLength;
+    }
+    const copies = new Map();
+    const authorities = [...volumes.keys()].sort();
+    for (let ordinal = 0; ordinal < authorities.length; ++ordinal) {
+        const volume = volumes.get(authorities[ordinal]);
+        const destination = paths.join(privateRoot, ordinal.toString(36));
+        for (const [source, parts] of volume.sources)
+            copies.set(source, paths.join(destination, ...parts.slice(volume.common.length)));
+    }
+    return copies;
+}
+//# sourceMappingURL=createExternalSourceSnapshotLayout.js.map

package/lib/plugin/internal/source/createExternalSourceSnapshotLayout.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createExternalSourceSnapshotLayout.js","sourceRoot":"","sources":["../../../../src/plugin/internal/source/createExternalSourceSnapshotLayout.ts"],"names":[],"mappings":";;;;;;AAAA,0DAA6B;AAE7B;;;;;;;;;;;;;;;;;;;GAmBG;AACH,4CACE,WAAmB,EACnB,WAA8B,EAC9B,KAAK,GAAgB,mBAAI;IAEzB,MAAM,OAAO,GAAG,IAAI,GAAG,EAGpB,CAAC;IACJ,KAAK,MAAM,SAAS,IAAI,WAAW,EAAE,CAAC;QACpC,MAAM,QAAQ,GAAG,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;QAC1C,MAAM,IAAI,GAAG,KAAK,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC;QACxC,MAAM,KAAK,GAAG,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;QAC3E,MAAM,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QACjC,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;YACzB,OAAO,CAAC,GAAG,CAAC,IAAI,EAAE;gBAChB,MAAM,EAAE,CAAC,GAAG,KAAK,CAAC;gBAClB,OAAO,EAAE,IAAI,GAAG,CAAC,CAAC,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC,CAAC;aACtC,CAAC,CAAC;YACH,SAAS;QACX,CAAC;QACD,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;QACpC,IAAI,YAAY,GAAG,CAAC,CAAC;QACrB,OACE,YAAY,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM;YACnC,YAAY,GAAG,KAAK,CAAC,MAAM;YAC3B,MAAM,CAAC,MAAM,CAAC,YAAY,CAAC,KAAK,KAAK,CAAC,YAAY,CAAC;YAEnD,EAAE,YAAY,CAAC;QACjB,MAAM,CAAC,MAAM,CAAC,MAAM,GAAG,YAAY,CAAC;IACtC,CAAC;IACD,MAAM,MAAM,GAAG,IAAI,GAAG,EAAkB,CAAC;IACzC,MAAM,WAAW,GAAG,CAAC,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC;IAC/C,KAAK,IAAI,OAAO,GAAG,CAAC,EAAE,OAAO,GAAG,WAAW,CAAC,MAAM,EAAE,EAAE,OAAO,EAAE,CAAC;QAC9D,MAAM,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,WAAW,CAAC,OAAO,CAAE,CAAE,CAAC;QACnD,MAAM,WAAW,GAAG,KAAK,CAAC,IAAI,CAAC,WAAW,EAAE,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,CAAC;QAClE,KAAK,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO;YAC1C,MAAM,CAAC,GAAG,CACR,MAAM,EACN,KAAK,CAAC,IAAI,CAAC,WAAW,EAAE,GAAG,KAAK,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAC9D,CAAC;IACN,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC"}

package/lib/plugin/internal/source/ensureExecutableGoToolchain.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Attempt POSIX Go toolchain permission repair before metadata reads.
+ *
+ * Package managers can drop the execute bit of the bundled Go SDK. For the
+ * bundled toolchain (`normalizeBundledPermissions`) the `go` and `gofmt`
+ * regular binaries and observed regular files under ordinary `pkg/tool`
+ * directories are normalized to `0755`; for a toolchain the user selected, the
+ * owner-execute bit is added only when no execute bit is present, preserving
+ * other permission bits. Windows requires no POSIX permission repair. A
+ * nonregular main candidate stops repair, and nonregular secondary entries are
+ * skipped. Traversal/repair failures are tolerated; a later Go invocation may
+ * report a relevant native error but is not guaranteed to expose every skipped
+ * repair failure.
+ *
+ * @evidence contracts/common.md#principled-implementation Regular-file admission precedes chmod and a nonregular main candidate stops SDK repair. The caller's bundled-layout flag selects full normalization; selected files otherwise gain owner execution only when no execute bit exists. This is a path-based attempt, not an immutable ownership or race-free handle certificate.
+ * @evidence contracts/common.md#clear-and-simple-design Platform exit, SDK recognition and recursive tool discovery remain explicit; one private file operation owns the permission policy.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Permission repair serves packaged SDK installation behavior rather than an injected fixture bypass; native errors are tolerated and ordinary Go execution retains its own failure outcome instead of this helper fabricating success.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs distinguish owned and selected toolchains and explain the failure boundary rather than promising successful chmod.
+ * @evidence contracts/portability.md#os-neutral-implementation Windows bypasses POSIX permission bits; POSIX uses native stat/chmod and Node path APIs with explicit ownership-dependent modes.
+ * @evidence contracts/performance.md#efficient-algorithms Native path/existence/stat checks precede ordinary-directory enumeration. Selected entries are stat-kind checked and unchanged modes avoid chmod; recursive helper arrays append descendant references through ancestors, so enumeration count alone does not bound path/array work. Native lookup/text/listing buffers contribute cost without reading compiler content.
+ *
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Permission state must be read on the current installation; no cross-call validity cache is owned here.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The traversal holds only its temporary file list and synchronous filesystem operations acquire no retained handle.
+ */
+export declare function ensureExecutableGoToolchain(goBinary: string, normalizeBundledPermissions: boolean): void;

package/lib/plugin/internal/source/ensureExecutableGoToolchain.js

@@ -0,0 +1,96 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureExecutableGoToolchain = ensureExecutableGoToolchain;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const GoSourceInputs_1 = require("./GoSourceInputs");
+/**
+ * Attempt POSIX Go toolchain permission repair before metadata reads.
+ *
+ * Package managers can drop the execute bit of the bundled Go SDK. For the
+ * bundled toolchain (`normalizeBundledPermissions`) the `go` and `gofmt`
+ * regular binaries and observed regular files under ordinary `pkg/tool`
+ * directories are normalized to `0755`; for a toolchain the user selected, the
+ * owner-execute bit is added only when no execute bit is present, preserving
+ * other permission bits. Windows requires no POSIX permission repair. A
+ * nonregular main candidate stops repair, and nonregular secondary entries are
+ * skipped. Traversal/repair failures are tolerated; a later Go invocation may
+ * report a relevant native error but is not guaranteed to expose every skipped
+ * repair failure.
+ *
+ * @evidence contracts/common.md#principled-implementation Regular-file admission precedes chmod and a nonregular main candidate stops SDK repair. The caller's bundled-layout flag selects full normalization; selected files otherwise gain owner execution only when no execute bit exists. This is a path-based attempt, not an immutable ownership or race-free handle certificate.
+ * @evidence contracts/common.md#clear-and-simple-design Platform exit, SDK recognition and recursive tool discovery remain explicit; one private file operation owns the permission policy.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Permission repair serves packaged SDK installation behavior rather than an injected fixture bypass; native errors are tolerated and ordinary Go execution retains its own failure outcome instead of this helper fabricating success.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs distinguish owned and selected toolchains and explain the failure boundary rather than promising successful chmod.
+ * @evidence contracts/portability.md#os-neutral-implementation Windows bypasses POSIX permission bits; POSIX uses native stat/chmod and Node path APIs with explicit ownership-dependent modes.
+ * @evidence contracts/performance.md#efficient-algorithms Native path/existence/stat checks precede ordinary-directory enumeration. Selected entries are stat-kind checked and unchanged modes avoid chmod; recursive helper arrays append descendant references through ancestors, so enumeration count alone does not bound path/array work. Native lookup/text/listing buffers contribute cost without reading compiler content.
+ *
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Permission state must be read on the current installation; no cross-call validity cache is owned here.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The traversal holds only its temporary file list and synchronous filesystem operations acquire no retained handle.
+ */
+function ensureExecutableGoToolchain(goBinary, normalizeBundledPermissions) {
+    if (process.platform === "win32")
+        return;
+    if (!node_path_1.default.isAbsolute(goBinary) || !node_fs_1.default.existsSync(goBinary))
+        return;
+    try {
+        if (!ensureExecutableFile(goBinary, normalizeBundledPermissions))
+            return;
+        const goRoot = GoSourceInputs_1.GoSourceInputs.inferGoRoot(goBinary);
+        if (!goRoot)
+            return;
+        const gofmt = node_path_1.default.join(node_path_1.default.dirname(goBinary), "gofmt");
+        if (node_fs_1.default.existsSync(gofmt)) {
+            ensureExecutableFile(gofmt, normalizeBundledPermissions);
+        }
+        const toolDir = node_path_1.default.join(goRoot, "pkg", "tool");
+        if (!node_fs_1.default.existsSync(toolDir))
+            return;
+        for (const file of walkToolFiles(toolDir)) {
+            ensureExecutableFile(file, normalizeBundledPermissions);
+        }
+    }
+    catch {
+        // Let the subsequent go build spawn fail with the real OS error.
+    }
+}
+/** Normalize owned files or add only owner execution to a nonexecutable file. */
+function ensureExecutableFile(file, normalizeBundledPermissions) {
+    const stats = node_fs_1.default.statSync(file);
+    if (!stats.isFile())
+        return false;
+    const mode = stats.mode & 0o7777;
+    if (normalizeBundledPermissions) {
+        if (mode !== 0o755)
+            node_fs_1.default.chmodSync(file, 0o755);
+    }
+    else if ((mode & 0o111) === 0) {
+        node_fs_1.default.chmodSync(file, mode | 0o100);
+    }
+    return true;
+}
+function walkToolFiles(dir) {
+    const out = [];
+    let entries;
+    try {
+        entries = node_fs_1.default.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return out;
+    }
+    for (const entry of entries) {
+        const file = node_path_1.default.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            for (const entryToAppend of walkToolFiles(file))
+                out.push(entryToAppend);
+        }
+        else if (entry.isFile()) {
+            out.push(file);
+        }
+    }
+    return out;
+}
+//# sourceMappingURL=ensureExecutableGoToolchain.js.map

package/lib/plugin/internal/source/ensureExecutableGoToolchain.js.map

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

package/lib/plugin/internal/source/formatDuration.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Render a millisecond duration for lock diagnostics (`137ms`, `42s`, `9m 3s`).
+ *
+ * Total over every number: the lock state machine reports "released" instead of
+ * an Infinity age, and as defense in depth a non-finite input renders as `an
+ * unknown time` so no public diagnostic prints `Infinitym NaNs`.
+ *
+ * @evidence contracts/common.md#principled-implementation Finite durations are decomposed into milliseconds or whole seconds/minutes; negative short values clamp to zero and nonfinite values use an explicit unknown-duration message.
+ * @evidence contracts/common.md#clear-and-simple-design One numeric formatter owns all diagnostic duration spellings without a second lock-state representation.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The nonfinite branch addresses an unsupported numeric duration directly rather than preserving an infinite-age encoding beneath another lock wrapper.
+ * @evidence contracts/common.md#meaningful-documentation Native prose gives millisecond/second/minute examples and explains the unknown-time result.
+ *
+ * @evidenceExclude contracts/performance.md#efficient-algorithms This performs a fixed number of scalar arithmetic and formatting operations, with no workload-dependent algorithm choice.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work The function formats one diagnostic value and stores no shared computation.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Only the returned string survives the call; no retained resource is acquired.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation formatDuration computes from its arguments only; it opens no file, builds no path and calls no platform or process API.
+ */
+export declare function formatDuration(ms: number): string;

package/lib/plugin/internal/source/formatDuration.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatDuration = formatDuration;
+/**
+ * Render a millisecond duration for lock diagnostics (`137ms`, `42s`, `9m 3s`).
+ *
+ * Total over every number: the lock state machine reports "released" instead of
+ * an Infinity age, and as defense in depth a non-finite input renders as `an
+ * unknown time` so no public diagnostic prints `Infinitym NaNs`.
+ *
+ * @evidence contracts/common.md#principled-implementation Finite durations are decomposed into milliseconds or whole seconds/minutes; negative short values clamp to zero and nonfinite values use an explicit unknown-duration message.
+ * @evidence contracts/common.md#clear-and-simple-design One numeric formatter owns all diagnostic duration spellings without a second lock-state representation.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The nonfinite branch addresses an unsupported numeric duration directly rather than preserving an infinite-age encoding beneath another lock wrapper.
+ * @evidence contracts/common.md#meaningful-documentation Native prose gives millisecond/second/minute examples and explains the unknown-time result.
+ *
+ * @evidenceExclude contracts/performance.md#efficient-algorithms This performs a fixed number of scalar arithmetic and formatting operations, with no workload-dependent algorithm choice.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work The function formats one diagnostic value and stores no shared computation.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Only the returned string survives the call; no retained resource is acquired.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation formatDuration computes from its arguments only; it opens no file, builds no path and calls no platform or process API.
+ */
+function formatDuration(ms) {
+    if (!Number.isFinite(ms)) {
+        return "an unknown time";
+    }
+    if (ms < 1_000) {
+        return `${Math.max(0, Math.round(ms))}ms`;
+    }
+    const seconds = Math.floor(ms / 1_000);
+    const minutes = Math.floor(seconds / 60);
+    const remainder = seconds % 60;
+    if (minutes === 0) {
+        return `${seconds}s`;
+    }
+    return `${minutes}m ${remainder}s`;
+}
+//# sourceMappingURL=formatDuration.js.map

package/lib/plugin/internal/source/formatDuration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatDuration.js","sourceRoot":"","sources":["../../../../src/plugin/internal/source/formatDuration.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,wBAA+B,EAAU;IACvC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC,EAAE,CAAC;QACzB,OAAO,iBAAiB,CAAC;IAC3B,CAAC;IACD,IAAI,EAAE,GAAG,KAAK,EAAE,CAAC;QACf,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC;IAC5C,CAAC;IACD,MAAM,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,EAAE,GAAG,KAAK,CAAC,CAAC;IACvC,MAAM,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,GAAG,EAAE,CAAC,CAAC;IACzC,MAAM,SAAS,GAAG,OAAO,GAAG,EAAE,CAAC;IAC/B,IAAI,OAAO,KAAK,CAAC,EAAE,CAAC;QAClB,OAAO,GAAG,OAAO,GAAG,CAAC;IACvB,CAAC;IACD,OAAO,GAAG,OAAO,KAAK,SAAS,GAAG,CAAC;AACrC,CAAC"}

package/lib/plugin/internal/source/formatGoWorkPath.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Format an absolute filesystem path as a single `go.work`/`go.mod` token.
+ *
+ * The modfile grammar shared by `go.mod` and `go.work` (parsed by
+ * `golang.org/x/mod/modfile`) is whitespace-tokenized, so a `use`/`replace`
+ * path that contains a space — a home or project directory such as `/Users/John
+ * Smith/...` or `C:\Users\John Smith\...` — must be emitted as a quoted string
+ * or `go` cannot parse the generated `go.work`. Normalize Windows separators to
+ * `/` (the workspace convention) and then delegate to
+ * {@link autoQuoteGoModToken}, with its runtime Unicode-table and valid-scalar
+ * decoding limits. This does not validate a physical path or malformed UTF-16.
+ *
+ * Separator normalization is itself a quoting trigger. A Windows UNC
+ * (`\\server\share\...`) or extended-length (`\\?\C:\...`) path normalizes into
+ * a token that starts with `//`, and the modfile lexer reads `//` as a line
+ * comment wherever it appears. Emitted bare, such a token turns its whole
+ * `use`/`replace` line into a comment: `go` exits 0, reports nothing, and the
+ * overlay module simply disappears from the workspace.
+ *
+ * On POSIX, a backslash can be part of a filename. Preserve it there so the
+ * workspace token continues to name the directory the caller supplied. The
+ * explicit platform argument permits callers to format a declared path grammar;
+ * ordinary workspace callers retain the current host by default.
+ *
+ * @evidence contracts/common.md#principled-implementation Windows separator normalization precedes Go's token formatter so UNC and extended-length spellings containing a comment opener are quoted rather than dropped from the workspace; POSIX backslashes retain their filename meaning.
+ * @evidence contracts/common.md#clear-and-simple-design Path protocol spelling and token quoting are two explicit steps, sharing the same Go-style token formatter and its documented Unicode limits as other modfile values.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Quoting responds to Go's actual lexer, including comment openers, rather than a growing list of known project path exceptions.
+ * @evidence contracts/common.md#meaningful-documentation The native paragraphs explain space, UNC and extended-length paths, why a bare slash pair loses a workspace entry, and why POSIX backslashes are preserved.
+ * @evidence contracts/portability.md#os-neutral-implementation The host path grammar selects separator conversion: Windows backslashes become Go workspace slashes, including UNC paths, while POSIX backslashes remain literal filename characters.
+ * @evidence contracts/performance.md#efficient-algorithms At most one separator pass and the token formatter's linear quote passes make time and temporary string space proportional to path length.
+ *
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This converts one supplied path token and owns no shared resolution or build computation.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Only its returned token survives; no filesystem handle or process is acquired.
+ */
+export declare function formatGoWorkPath(p: string, platform?: NodeJS.Platform): string;

package/lib/plugin/internal/source/formatGoWorkPath.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatGoWorkPath = formatGoWorkPath;
+const autoQuoteGoModToken_1 = require("./autoQuoteGoModToken");
+/**
+ * Format an absolute filesystem path as a single `go.work`/`go.mod` token.
+ *
+ * The modfile grammar shared by `go.mod` and `go.work` (parsed by
+ * `golang.org/x/mod/modfile`) is whitespace-tokenized, so a `use`/`replace`
+ * path that contains a space — a home or project directory such as `/Users/John
+ * Smith/...` or `C:\Users\John Smith\...` — must be emitted as a quoted string
+ * or `go` cannot parse the generated `go.work`. Normalize Windows separators to
+ * `/` (the workspace convention) and then delegate to
+ * {@link autoQuoteGoModToken}, with its runtime Unicode-table and valid-scalar
+ * decoding limits. This does not validate a physical path or malformed UTF-16.
+ *
+ * Separator normalization is itself a quoting trigger. A Windows UNC
+ * (`\\server\share\...`) or extended-length (`\\?\C:\...`) path normalizes into
+ * a token that starts with `//`, and the modfile lexer reads `//` as a line
+ * comment wherever it appears. Emitted bare, such a token turns its whole
+ * `use`/`replace` line into a comment: `go` exits 0, reports nothing, and the
+ * overlay module simply disappears from the workspace.
+ *
+ * On POSIX, a backslash can be part of a filename. Preserve it there so the
+ * workspace token continues to name the directory the caller supplied. The
+ * explicit platform argument permits callers to format a declared path grammar;
+ * ordinary workspace callers retain the current host by default.
+ *
+ * @evidence contracts/common.md#principled-implementation Windows separator normalization precedes Go's token formatter so UNC and extended-length spellings containing a comment opener are quoted rather than dropped from the workspace; POSIX backslashes retain their filename meaning.
+ * @evidence contracts/common.md#clear-and-simple-design Path protocol spelling and token quoting are two explicit steps, sharing the same Go-style token formatter and its documented Unicode limits as other modfile values.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Quoting responds to Go's actual lexer, including comment openers, rather than a growing list of known project path exceptions.
+ * @evidence contracts/common.md#meaningful-documentation The native paragraphs explain space, UNC and extended-length paths, why a bare slash pair loses a workspace entry, and why POSIX backslashes are preserved.
+ * @evidence contracts/portability.md#os-neutral-implementation The host path grammar selects separator conversion: Windows backslashes become Go workspace slashes, including UNC paths, while POSIX backslashes remain literal filename characters.
+ * @evidence contracts/performance.md#efficient-algorithms At most one separator pass and the token formatter's linear quote passes make time and temporary string space proportional to path length.
+ *
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This converts one supplied path token and owns no shared resolution or build computation.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Only its returned token survives; no filesystem handle or process is acquired.
+ */
+function formatGoWorkPath(p, platform = process.platform) {
+    return (0, autoQuoteGoModToken_1.autoQuoteGoModToken)(platform === "win32" ? p.replace(/\\/g, "/") : p);
+}
+//# sourceMappingURL=formatGoWorkPath.js.map

package/lib/plugin/internal/source/formatGoWorkPath.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatGoWorkPath.js","sourceRoot":"","sources":["../../../../src/plugin/internal/source/formatGoWorkPath.ts"],"names":[],"mappings":";;;AAAA,+DAA4D;AAE5D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,0BACE,CAAS,EACT,QAAQ,GAAoB,OAAO,CAAC,QAAQ;IAE5C,OAAO,IAAA,yCAAmB,EAAC,QAAQ,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AAC/E,CAAC"}

package/lib/plugin/internal/source/hashPluginBuildEnvironment.d.ts

@@ -0,0 +1,47 @@
+import { PluginBuildEnvironmentWitness } from "./PluginBuildEnvironmentWitness";
+import type { SourceBuildFilesystemOperations } from "./SourceBuildFilesystemOperations";
+/**
+ * Hash the environment a plugin build is keyed on into `hash`: the Go
+ * compiler's identity (its `go version` and the bytes of the binary), the Go
+ * build environment `go env` reports for the build's directory (target, build
+ * tags, cgo, FIPS, the C toolchain's commands by content, and GOROOT by
+ * content), and the external toolchain environment cgo reads. Fixed
+ * source-build flags enter this same identity, so its binary key and reported
+ * source state both distinguish the artifact policy used by native
+ * compilation.
+ *
+ * The declared source/build identity uses these selected observations, so both
+ * the plugin cache key (`computeCacheKey`) and the state a transform reports
+ * for each source directory (`pluginSourceState`) take it from here, one rule
+ * for the build and consumers comparing that selected identity. Failed Go env
+ * queries or normalization can fall back to available effective environment
+ * values; this is not proof that every Go-reported setting was observed.
+ * Command tokens are inspected against the current process cwd and executable
+ * search environment; programs a launcher selects by other means remain outside
+ * the named-token observation. Native reads and metadata-qualified memos are
+ * sequential, not an atomic toolchain snapshot.
+ *
+ * @param hash What the environment's framed values enter: the key's hash, or
+ *   one that digests the environment alone, or both at once.
+ * @param goBinary The Go tool the build runs, resolved for `directory`
+ *   (`GoToolResolution.resolveGoToolForBuild`), or `undefined` to key on the
+ *   environment's own values alone.
+ * @param directory The directory the build runs `go` in.
+ * @param env The build's effective environment.
+ * @param filesystem Reads GOROOT's files for its content identity.
+ * @param witness Receives every path whose state the reading depends on and no
+ *   variable carries: the Go tool, the Go environment file `go env -w` writes,
+ *   the executables the C toolchain commands name, and GOROOT. A consumer that
+ *   keeps the reading compares their metadata before reusing it.
+ * @evidence contracts/common.md#principled-implementation Fixed artifact flags, observed compiler bytes/version, selected reported-or-fallback build values, named command executables and selected SDK files enter the same framed identity used by source-state reporting. Fallback values and metadata-qualified reuse are explicit premises, not complete observation of arbitrary toolchain inputs.
+ * @evidence contracts/common.md#clear-and-simple-design Private helpers separate compiler identity, Go-reported settings, external variables and SDK content while sharing one hash sink and optional pre-read witness.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Cache signatures include real identity/change metadata and effective invocation context; failed SDK witnessing refuses reuse rather than accepting a VERSION-only proxy.
+ * @evidence contracts/common.md#meaningful-documentation Native documentation names the input classes and witness purpose; private comments explain context-sensitive compiler memoization and SDK exclusions without treating a passing check as proof.
+ * @evidence contracts/portability.md#os-neutral-implementation Node path/stat/process APIs resolve native tool identities; platform-specific executable suffixes and environment lookup are isolated in GoToolResolution, and Go supplies its own effective build settings.
+ * @evidence contracts/performance.md#efficient-algorithms SDK traversal sorts reached entry names and selected file paths, performs native stat/realpath/link queries and serializes topology/metadata/path text. Matching manifests share aggregate hashes; changes read full selected files via the caller adapter, retaining file buffers with population/topology data. Compiler misses capture at most three complete version/byte readings when native metadata moves during a reading; only a stable attempt enters the memo. Go env can run up to three times for its file witness, and command tokens can each perform executable searches/full reads. Environment sorting/framing and command substring parsing also process name/value/command bytes; E/D/F/B alone do not capture native lookup or text comparison costs.
+ * @evidence contracts/performance.md#reuse-equivalent-work Compiler memo identity includes selected path/file metadata and invocation cwd/environment; SDK aggregate reuse requires matching complete ordered metadata/topology. Both rely on native metadata distinguishability and sequential observation premises, not independently rehashed content on each hit. Physical directories expand once per selection policy while aliases retain edges; optional caller witnesses receive reached selected dependencies.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources Compiler, Go-environment-path and SDK maps retain historical distinct tool/context/root keys without eviction. SDK population/topology and full individual file reads contribute transient bytes; synchronous probes delegate process/capture lifetime to their owner and do not certify arbitrary descendants are gone. No independent entry/record/file/output byte ceiling is imposed here.
+ */
+export declare function hashPluginBuildEnvironment(hash: {
+    update(data: string): unknown;
+}, goBinary: string | undefined, directory: string, env: NodeJS.ProcessEnv, filesystem: SourceBuildFilesystemOperations, witness?: PluginBuildEnvironmentWitness.Record): void;