ttsc 0.4.4-dev.20260426 → 0.5.0-dev.20260429

package/lib/api.js

@@ -107,6 +107,29 @@ function outputText(value) {
     }
     return typeof value === "string" ? value : value.toString("utf8");
 }
+function hasCapability(plugin, capability) {
+    return plugin.backend.capabilities?.includes(capability) === true;
+}
+function isOutputPlugin(plugin) {
+    return hasCapability(plugin, "output");
+}
+function isCheckOnlyPlugin(plugin) {
+    const capabilities = plugin.backend.capabilities ?? [];
+    return (capabilities.length > 0 &&
+        capabilities.every((capability) => capability === "check"));
+}
+function isCompilerPlugin(plugin) {
+    return !isOutputPlugin(plugin) && !isCheckOnlyPlugin(plugin);
+}
+function outputPlugins(plugins) {
+    return plugins.filter(isOutputPlugin);
+}
+function checkOnlyPlugins(plugins) {
+    return plugins.filter(isCheckOnlyPlugin);
+}
+function compilerPlugins(plugins) {
+    return plugins.filter(isCompilerPlugin);
+}
 /**
  * Transform a single .ts file and return the rewritten JS as a string.
  *
@@ -122,14 +145,8 @@ function transform(options) {
     const sourceFile = realpathIfExists(path.isAbsolute(options.file)
         ? options.file
         : path.resolve(options.cwd ?? process.cwd(), options.file));
-    if (execution.sourcePlugins.length > 0) {
-        return transformWithSourceTransforms(options, execution, sourceFile);
-    }
-    if (execution.nativeBinary) {
-        return transformWithNativeBinary(options, execution, sourceFile);
-    }
-    if (execution.nativeMode !== "none") {
-        throw new Error(`ttsc.transform: native rewrite mode "${execution.nativeMode}" requires a plugin-provided version-matched binary`);
+    if (execution.nativePlugins.length > 0) {
+        return transformWithNativePlugins(options, execution, sourceFile);
     }
     const tempOutDir = fs.mkdtempSync(path.join(os.tmpdir(), "ttsc-transform-"));
     try {
@@ -150,14 +167,7 @@ function transform(options) {
         if (!emitted) {
             throw new Error(`ttsc.transform: no output produced for ${sourceFile}`);
         }
-        const transformed = finalizeTransformText(execution.outputPlugins, {
-            command: "transform",
-            compilerOptions: execution.compilerOptions,
-            cwd: execution.cwd,
-            projectRoot: execution.projectRoot,
-            sourceFile,
-            tsconfig: execution.tsconfig,
-        }, fs.readFileSync(emitted, "utf8"));
+        const transformed = fs.readFileSync(emitted, "utf8");
         if (options.out) {
             fs.mkdirSync(path.dirname(options.out), { recursive: true });
             fs.writeFileSync(options.out, transformed, "utf8");
@@ -168,91 +178,65 @@ function transform(options) {
         fs.rmSync(tempOutDir, { recursive: true, force: true });
     }
 }
-function transformWithNativeBinary(options, execution, sourceFile) {
-    const args = [
-        "transform",
-        "--file=" + sourceFile,
-        "--tsconfig=" + execution.tsconfig,
-        "--rewrite-mode=" + execution.nativeMode,
-    ];
-    const res = spawnBinary(execution.nativeBinary, args, {
-        cwd: options.cwd,
-        env: mergeEnv(options.env),
-        encoding: "utf8",
-    });
-    if (res.error) {
-        throw new Error("ttsc.transform: failed to spawn " +
-            execution.nativeBinary +
-            ": " +
-            res.error.message);
+function transformWithNativePlugins(options, execution, sourceFile) {
+    const checked = runNativeCheckPlugins(options, execution);
+    if (checked.status !== 0) {
+        throw new Error("ttsc.transform exited " + checked.status + "\n" + checked.stderr);
     }
-    if (res.status !== 0) {
-        throw new Error("ttsc.transform exited " + res.status + "\n" + (res.stderr || ""));
-    }
-    const transformed = finalizeTransformText(execution.outputPlugins, {
-        command: "transform",
-        compilerOptions: execution.compilerOptions,
-        cwd: execution.cwd,
-        projectRoot: execution.projectRoot,
-        sourceFile,
-        tsconfig: execution.tsconfig,
-    }, outputText(res.stdout));
-    if (options.out) {
-        fs.mkdirSync(path.dirname(options.out), { recursive: true });
-        fs.writeFileSync(options.out, transformed, "utf8");
-    }
-    return transformed;
-}
-function transformWithSourceTransforms(options, execution, sourceFile) {
-    if (execution.nativeBinary || execution.nativeMode !== "none") {
-        throw new Error("ttsc.transform: transformSource cannot be combined with native rewrite mode yet");
-    }
-    const materialized = materializeSourceTransformedProject(execution, "transform", sourceFile);
-    const tempOutDir = path.join(materialized.root, ".ttsc-transform-out");
+    const compilers = compilerPlugins(execution.nativePlugins);
+    const outputs = outputPlugins(execution.nativePlugins);
+    const tempOutDir = fs.mkdtempSync(path.join(os.tmpdir(), "ttsc-transform-"));
     try {
-        const tempSourceFile = toMaterializedPath(sourceFile, materialized);
-        const result = build({
-            ...options,
-            cwd: materialized.root,
-            emit: true,
-            forceListEmittedFiles: true,
-            outDir: tempOutDir,
-            plugins: false,
-            tsconfig: materialized.tsconfig,
-        });
-        if (result.status !== 0) {
-            throw new Error("ttsc.transform exited " +
-                result.status +
-                "\n" +
-                (result.stderr || result.stdout));
+        let emitted = null;
+        if (compilers.length !== 0) {
+            assertSingleCompilerHost(compilers);
+            emitted = path.join(tempOutDir, "transform.js");
+            const transformed = runNativeCompilerTransform(options, execution, sourceFile, emitted, compilers);
+            if (transformed.status !== 0) {
+                throw new Error("ttsc.transform exited " +
+                    transformed.status +
+                    "\n" +
+                    transformed.stderr);
+            }
         }
-        const emitted = findEmittedFile(tempOutDir, materialized.root, tempSourceFile);
-        if (!emitted) {
-            throw new Error(`ttsc.transform: no output produced for ${sourceFile}`);
+        else {
+            const result = build({
+                ...options,
+                emit: true,
+                outDir: tempOutDir,
+                plugins: false,
+                skipDiagnosticsCheck: checkOnlyPlugins(execution.nativePlugins).length !== 0,
+                tsconfig: execution.tsconfig,
+            });
+            if (result.status !== 0) {
+                throw new Error("ttsc.transform exited " +
+                    result.status +
+                    "\n" +
+                    (result.stderr || result.stdout));
+            }
+            emitted = findEmittedFile(tempOutDir, execution.projectRoot, sourceFile);
+            if (!emitted) {
+                throw new Error(`ttsc.transform: no output produced for ${sourceFile}`);
+            }
         }
-        let transformed = finalizeTransformText(execution.outputPlugins, {
-            command: "transform",
-            compilerOptions: execution.compilerOptions,
-            cwd: execution.cwd,
-            projectRoot: execution.projectRoot,
-            sourceFile,
-            tsconfig: execution.tsconfig,
-        }, fs.readFileSync(emitted, "utf8"));
-        if (options.out) {
-            const mapFile = `${emitted}.map`;
-            if (fs.existsSync(mapFile)) {
-                const outMap = `${options.out}.map`;
-                fs.mkdirSync(path.dirname(outMap), { recursive: true });
-                fs.writeFileSync(outMap, patchSourceMapText(fs.readFileSync(mapFile, "utf8"), materialized, outMap, mapFile), "utf8");
-                transformed = rewriteSourceMapReference(transformed, path.basename(outMap));
+        for (const plugin of outputs) {
+            const result = runNativeOutputPlugin(options, execution, plugin, emitted);
+            if (result.status !== 0) {
+                throw new Error("ttsc.transform exited " +
+                    result.status +
+                    "\n" +
+                    (result.stderr || result.stdout));
             }
+        }
+        const transformed = fs.readFileSync(emitted, "utf8");
+        if (options.out) {
             fs.mkdirSync(path.dirname(options.out), { recursive: true });
             fs.writeFileSync(options.out, transformed, "utf8");
         }
         return transformed;
     }
     finally {
-        fs.rmSync(materialized.root, { recursive: true, force: true });
+        fs.rmSync(tempOutDir, { recursive: true, force: true });
     }
 }
 function realpathIfExists(file) {
@@ -270,19 +254,47 @@ function realpathIfExists(file) {
  */
 function build(options = {}) {
     const execution = resolveExecutionContext(options);
-    if (execution.sourcePlugins.length > 0) {
-        return buildWithSourceTransforms(options, execution);
-    }
-    if (execution.nativeBinary) {
-        return buildWithNativeBinary(options, execution);
-    }
-    if (execution.nativeMode !== "none") {
-        return {
-            status: 2,
-            stdout: "",
-            stderr: `ttsc.build: native rewrite mode "${execution.nativeMode}" requires ` +
-                "a version-matched sidecar build; project builds use the consuming project's @typescript/native-preview by default\n",
-        };
+    if (execution.nativePlugins.length > 0) {
+        const compilers = compilerPlugins(execution.nativePlugins);
+        const outputs = outputPlugins(execution.nativePlugins);
+        const checked = runNativeCheckPlugins(options, execution);
+        if (checked.status !== 0) {
+            return checked;
+        }
+        if (options.emit === false) {
+            if (compilers.length !== 0) {
+                assertSingleCompilerHost(compilers);
+                return appendBuildOutput(checked, buildWithNativeCompilerPlugins(options, execution, compilers));
+            }
+            if (checked.stdout !== "" || checked.stderr !== "") {
+                return checked;
+            }
+            return runTsgo(execution, ["--noEmit"], options);
+        }
+        let result;
+        if (compilers.length !== 0) {
+            assertSingleCompilerHost(compilers);
+            result = appendBuildOutput(checked, buildWithNativeCompilerPlugins(options, execution, compilers));
+        }
+        else {
+            if (checked.stdout === "" &&
+                checked.stderr === "" &&
+                options.skipDiagnosticsCheck !== true) {
+                const tsgoChecked = runTsgo(execution, ["--noEmit"], options);
+                if (tsgoChecked.status !== 0) {
+                    return tsgoChecked;
+                }
+            }
+            const args = createTsgoBuildArgs(execution, options, {
+                listEmittedFiles: outputs.length !== 0 || options.forceListEmittedFiles === true,
+            });
+            const emitted = runTsgoBuild(execution, options, args);
+            result = appendBuildOutput(checked, emitted);
+        }
+        if (result.status !== 0 || outputs.length === 0) {
+            return result;
+        }
+        return appendBuildOutput(result, applyOutputPlugins(options, execution, result.emittedFiles ?? [], outputs));
     }
     if (options.emit !== false && options.skipDiagnosticsCheck !== true) {
         const checked = runTsgo(execution, ["--noEmit"], options);
@@ -291,84 +303,12 @@ function build(options = {}) {
         }
     }
     const args = createTsgoBuildArgs(execution, options, {
-        listEmittedFiles: options.emit !== false &&
-            (execution.outputPlugins.length > 0 || options.forceListEmittedFiles === true),
-    });
-    const res = spawnBinary(execution.tsgo.binary, args, {
-        cwd: execution.projectRoot,
-        env: mergeEnv(options.env),
-        encoding: "utf8",
+        listEmittedFiles: options.emit !== false && options.forceListEmittedFiles === true,
     });
-    if (res.error) {
-        throw new Error("ttsc.build: failed to spawn " +
-            execution.tsgo.binary +
-            ": " +
-            res.error.message);
-    }
-    const result = {
-        status: res.status ?? 1,
-        stdout: outputText(res.stdout),
-        stderr: outputText(res.stderr),
-    };
-    const emittedFiles = parseEmittedFiles(result.stdout);
-    if (emittedFiles.length !== 0) {
-        result.stdout = stripEmittedFileLines(result.stdout);
-    }
-    if (result.status === 0 && options.emit !== false && execution.outputPlugins.length > 0) {
-        applyBuildPlugins(execution.outputPlugins, execution, emittedFiles);
-    }
-    return normalizeFailedDiagnostics({ ...result, emittedFiles });
+    return runTsgoBuild(execution, options, args);
 }
-function buildWithNativeBinary(options, execution) {
-    const args = createNativeBuildArgs(execution, options);
-    const res = spawnBinary(execution.nativeBinary, args, {
-        cwd: execution.projectRoot,
-        env: mergeEnv(options.env),
-        encoding: "utf8",
-    });
-    if (res.error) {
-        throw new Error("ttsc.build: failed to spawn " +
-            execution.nativeBinary +
-            ": " +
-            res.error.message);
-    }
-    return normalizeFailedDiagnostics({
-        status: res.status ?? 1,
-        stdout: outputText(res.stdout),
-        stderr: outputText(res.stderr),
-    });
-}
-function buildWithSourceTransforms(options, execution) {
-    if (execution.nativeBinary || execution.nativeMode !== "none") {
-        return {
-            status: 2,
-            stdout: "",
-            stderr: "ttsc.build: transformSource cannot be combined with native rewrite mode yet\n",
-        };
-    }
-    const materialized = materializeSourceTransformedProject(execution, "build");
-    try {
-        const outDir = mapOutDirToMaterializedProject(options.outDir, execution, materialized);
-        const result = build({
-            ...options,
-            cwd: materialized.root,
-            forceListEmittedFiles: true,
-            outDir,
-            plugins: false,
-            tsconfig: materialized.tsconfig,
-        });
-        if (result.status === 0 && options.emit !== false) {
-            const copied = copyMaterializedEmittedFiles(materialized, result.emittedFiles ?? []);
-            result.emittedFiles = copied;
-            if (execution.outputPlugins.length > 0) {
-                applyBuildPlugins(execution.outputPlugins, execution, copied);
-            }
-        }
-        return result;
-    }
-    finally {
-        fs.rmSync(materialized.root, { recursive: true, force: true });
-    }
+function buildWithNativeCompilerPlugins(options, execution, plugins) {
+    return runNativePluginCommand(plugins[0], createNativeBuildArgs(execution, options, plugins), options, execution, "ttsc.build");
 }
 /**
  * Run `ttsc check` (build without emit) — CI gate / pre-commit hook use.
@@ -392,6 +332,29 @@ function runTsgo(execution, extraArgs, options) {
         stderr: outputText(res.stderr),
     });
 }
+function runTsgoBuild(execution, options, args) {
+    const res = spawnBinary(execution.tsgo.binary, args, {
+        cwd: execution.projectRoot,
+        env: mergeEnv(options.env),
+        encoding: "utf8",
+    });
+    if (res.error) {
+        throw new Error("ttsc.build: failed to spawn " +
+            execution.tsgo.binary +
+            ": " +
+            res.error.message);
+    }
+    const result = {
+        status: res.status ?? 1,
+        stdout: outputText(res.stdout),
+        stderr: outputText(res.stderr),
+    };
+    const emittedFiles = parseEmittedFiles(result.stdout);
+    if (emittedFiles.length !== 0) {
+        result.stdout = stripEmittedFileLines(result.stdout);
+    }
+    return normalizeFailedDiagnostics({ ...result, emittedFiles });
+}
 function createTsgoBuildArgs(execution, options, flags) {
     const args = ["-p", execution.tsconfig];
     if (options.emit === true) {
@@ -408,11 +371,12 @@ function createTsgoBuildArgs(execution, options, flags) {
     }
     return args;
 }
-function createNativeBuildArgs(execution, options) {
+function createNativeBuildArgs(execution, options, plugins) {
     const args = [
         options.emit === false ? "check" : "build",
         "--tsconfig=" + execution.tsconfig,
-        "--rewrite-mode=" + execution.nativeMode,
+        "--rewrite-mode=" + (options.rewriteMode ?? plugins[0]?.backend.mode ?? "none"),
+        "--plugins-json=" + serializeNativePlugins(plugins),
         "--cwd=" + execution.projectRoot,
     ];
     if (options.emit === true) {
@@ -432,6 +396,132 @@ function createNativeBuildArgs(execution, options) {
     }
     return args;
 }
+function createNativeCheckArgs(execution, options, plugin) {
+    const args = [
+        "check",
+        "--tsconfig=" + execution.tsconfig,
+        "--rewrite-mode=" + (options.rewriteMode ?? plugin.backend.mode),
+        "--plugins-json=" + serializeNativePlugins(execution.nativePlugins),
+        "--cwd=" + execution.projectRoot,
+    ];
+    if ("outDir" in options && options.outDir) {
+        args.push("--outDir=" + path.resolve(execution.cwd, options.outDir));
+    }
+    if ("quiet" in options && options.quiet === false) {
+        args.push("--verbose");
+    }
+    else if ("quiet" in options && options.quiet === true) {
+        args.push("--quiet");
+    }
+    return args;
+}
+function createNativeOutputArgs(execution, options, plugin, file) {
+    const args = [
+        "output",
+        "--file=" + file,
+        "--tsconfig=" + execution.tsconfig,
+        "--rewrite-mode=" + (options.rewriteMode ?? plugin.backend.mode),
+        "--plugins-json=" + serializeNativePlugins(execution.nativePlugins),
+        "--cwd=" + execution.projectRoot,
+    ];
+    if ("outDir" in options && options.outDir) {
+        args.push("--outDir=" + path.resolve(execution.cwd, options.outDir));
+    }
+    return args;
+}
+function createNativeTransformArgs(execution, options, sourceFile, out, plugins) {
+    return [
+        "transform",
+        "--file=" + sourceFile,
+        "--out=" + out,
+        "--tsconfig=" + execution.tsconfig,
+        "--rewrite-mode=" + (options.rewriteMode ?? plugins[0]?.backend.mode ?? "none"),
+        "--plugins-json=" + serializeNativePlugins(plugins),
+    ];
+}
+function serializeNativePlugins(plugins) {
+    return JSON.stringify(plugins.map((plugin) => ({
+        config: plugin.config,
+        contractVersion: plugin.backend.contractVersion,
+        mode: plugin.backend.mode,
+        name: plugin.name,
+    })));
+}
+function runNativeCheckPlugins(options, execution) {
+    let out = { status: 0, stdout: "", stderr: "" };
+    for (const plugin of checkOnlyPlugins(execution.nativePlugins)) {
+        const result = runNativePluginCommand(plugin, createNativeCheckArgs(execution, options, plugin), options, execution, "ttsc.check");
+        out = appendBuildOutput(out, result);
+        if (result.status !== 0) {
+            return out;
+        }
+    }
+    return out;
+}
+function runNativeCompilerTransform(options, execution, sourceFile, out, plugins) {
+    return runNativePluginCommand(plugins[0], createNativeTransformArgs(execution, options, sourceFile, out, plugins), options, execution, "ttsc.transform");
+}
+function applyOutputPlugins(options, execution, emittedFiles, plugins) {
+    let out = { status: 0, stdout: "", stderr: "" };
+    for (const plugin of plugins) {
+        for (const file of emittedFiles) {
+            if (!fs.existsSync(file)) {
+                continue;
+            }
+            const result = runNativeOutputPlugin(options, execution, plugin, file);
+            out = appendBuildOutput(out, result);
+            if (result.status !== 0) {
+                return out;
+            }
+        }
+    }
+    return out;
+}
+function runNativeOutputPlugin(options, execution, plugin, file) {
+    return runNativePluginCommand(plugin, createNativeOutputArgs(execution, options, plugin, file), options, execution, "ttsc.output");
+}
+function runNativePluginCommand(plugin, args, options, execution, label) {
+    const binary = plugin.backend.binary;
+    if (!binary) {
+        return {
+            status: 2,
+            stdout: "",
+            stderr: `${label}: plugin "${plugin.name}" requires a version-matched binary\n`,
+        };
+    }
+    const res = spawnBinary(binary, args, {
+        cwd: execution.projectRoot,
+        env: mergeEnv(options.env),
+        encoding: "utf8",
+    });
+    if (res.error) {
+        throw new Error(`${label}: failed to spawn ${binary}: ${res.error.message}`);
+    }
+    return normalizeFailedDiagnostics({
+        status: res.status ?? 1,
+        stdout: outputText(res.stdout),
+        stderr: outputText(res.stderr),
+    });
+}
+function appendBuildOutput(left, right) {
+    return normalizeFailedDiagnostics({
+        emittedFiles: right.emittedFiles !== undefined ? right.emittedFiles : left.emittedFiles,
+        status: right.status !== 0 ? right.status : left.status,
+        stdout: left.stdout + right.stdout,
+        stderr: left.stderr + right.stderr,
+    });
+}
+function assertSingleCompilerHost(plugins) {
+    const binaries = [
+        ...new Set(plugins
+            .map((plugin) => plugin.backend.binary)
+            .filter((binary) => typeof binary === "string")),
+    ];
+    if (binaries.length > 1) {
+        throw new Error("ttsc: multiple compiler native backends cannot share one emit pass; " +
+            "use output-capability plugins for post-emit transforms");
+    }
+}
 /** Ask the binary for its version banner. Handy for user-agent strings. */
 function version(options = {}) {
     const tsgo = (0, tsgo_1.resolveTsgo)(options);
@@ -444,9 +534,9 @@ function version(options = {}) {
     return `ttsc ${readOwnPackageVersion()} (${outputText(res.stdout).trim()})`;
 }
 /**
- * Promise-facing variant of `transform()`. The plugin host keeps the transform
- * pipeline synchronous so plugin modules can stay dependency-free, but many
- * adapter surfaces still prefer a Promise-returning function.
+ * Promise-facing variant of `transform()`. The host path stays synchronous so
+ * plugin descriptors can stay dependency-free, but many adapter surfaces still
+ * prefer a Promise-returning function.
  */
 function transformAsync(options) {
     return Promise.resolve().then(() => transform(options));
@@ -469,47 +559,12 @@ function resolveExecutionContext(options) {
     return {
         compilerOptions: loaded.project.compilerOptions,
         cwd,
-        nativeBinary: loaded.nativeBinary ?? null,
-        nativeMode: options.rewriteMode ?? loaded.nativeMode,
-        outputPlugins: loaded.plugins.filter((plugin) => plugin.transformOutput),
+        nativePlugins: loaded.nativePlugins,
         projectRoot,
-        sourcePlugins: loaded.plugins.filter((plugin) => plugin.transformSource),
         tsgo,
         tsconfig,
     };
 }
-function finalizeTransformText(plugins, context, text) {
-    if (plugins.length === 0) {
-        return text;
-    }
-    return (0, plugin_1.applyPluginTransforms)(plugins, {
-        ...context,
-        code: text,
-    });
-}
-function applyBuildPlugins(plugins, execution, emittedFiles) {
-    if (plugins.length === 0) {
-        return;
-    }
-    for (const file of emittedFiles) {
-        if (!isJavaScriptOutput(file) || !fs.existsSync(file)) {
-            continue;
-        }
-        const current = fs.readFileSync(file, "utf8");
-        const next = (0, plugin_1.applyPluginTransforms)(plugins, {
-            code: current,
-            command: "build",
-            compilerOptions: execution.compilerOptions,
-            cwd: execution.cwd,
-            outputFile: file,
-            projectRoot: execution.projectRoot,
-            tsconfig: execution.tsconfig,
-        });
-        if (next !== current) {
-            fs.writeFileSync(file, next, "utf8");
-        }
-    }
-}
 function isJavaScriptOutput(file) {
     return /\.(?:[cm]?js)$/i.test(file);
 }
@@ -611,408 +666,4 @@ function readOwnPackageVersion() {
         return "0.0.0";
     }
 }
-function materializeSourceTransformedProject(execution, command, onlySourceFile) {
-    const root = fs.mkdtempSync(path.join(os.tmpdir(), "ttsc-source-"));
-    const materialized = {
-        mappers: new Map(),
-        originalRoot: execution.projectRoot,
-        root,
-        tsconfig: path.join(root, path.relative(execution.projectRoot, execution.tsconfig)),
-    };
-    copyProjectForSourceTransforms(execution.projectRoot, root, execution.compilerOptions);
-    const files = onlySourceFile
-        ? [toMaterializedPath(onlySourceFile, materialized)]
-        : listSourceTransformFiles(root);
-    for (const tempFile of files) {
-        if (!fs.existsSync(tempFile) || !fs.statSync(tempFile).isFile()) {
-            continue;
-        }
-        const originalFile = fromMaterializedPath(tempFile, materialized);
-        const current = fs.readFileSync(tempFile, "utf8");
-        const transformed = (0, plugin_1.applyPluginSourceTransformsWithMap)(execution.sourcePlugins, {
-            code: current,
-            command,
-            compilerOptions: execution.compilerOptions,
-            cwd: execution.cwd,
-            projectRoot: execution.projectRoot,
-            sourceFile: originalFile,
-            tsconfig: execution.tsconfig,
-        });
-        const next = transformed.code;
-        if (next !== current) {
-            fs.writeFileSync(tempFile, next, "utf8");
-        }
-        if (transformed.stages.length > 0) {
-            materialized.mappers.set(filepathKey(tempFile), {
-                finalCode: next,
-                originalCode: current,
-                stages: transformed.stages,
-            });
-        }
-    }
-    return materialized;
-}
-function copyProjectForSourceTransforms(source, target, compilerOptions) {
-    const excluded = new Set([".git", "node_modules"]);
-    const outDir = typeof compilerOptions.outDir === "string" ? compilerOptions.outDir : "";
-    const resolvedOutDir = outDir ? path.resolve(outDir) : "";
-    copyDirectoryFiltered(source, target, (entry) => {
-        if (excluded.has(path.basename(entry))) {
-            return false;
-        }
-        if (resolvedOutDir && isPathInside(entry, resolvedOutDir)) {
-            return false;
-        }
-        return true;
-    });
-    const nodeModules = path.join(source, "node_modules");
-    if (fs.existsSync(nodeModules)) {
-        const targetNodeModules = path.join(target, "node_modules");
-        try {
-            fs.symlinkSync(nodeModules, targetNodeModules, "junction");
-        }
-        catch {
-            copyDirectoryFiltered(nodeModules, targetNodeModules, () => true);
-        }
-    }
-}
-function copyDirectoryFiltered(source, target, shouldCopy) {
-    if (!shouldCopy(source)) {
-        return;
-    }
-    const stat = fs.lstatSync(source);
-    if (stat.isSymbolicLink()) {
-        const link = fs.readlinkSync(source);
-        fs.symlinkSync(link, target);
-        return;
-    }
-    if (stat.isDirectory()) {
-        fs.mkdirSync(target, { recursive: true });
-        for (const entry of fs.readdirSync(source)) {
-            copyDirectoryFiltered(path.join(source, entry), path.join(target, entry), shouldCopy);
-        }
-        return;
-    }
-    if (stat.isFile()) {
-        fs.mkdirSync(path.dirname(target), { recursive: true });
-        fs.copyFileSync(source, target);
-    }
-}
-function listSourceTransformFiles(root) {
-    const out = [];
-    const stack = [root];
-    while (stack.length !== 0) {
-        const current = stack.pop();
-        for (const entry of fs.readdirSync(current, { withFileTypes: true })) {
-            if (entry.name === "node_modules" || entry.name === ".git") {
-                continue;
-            }
-            const next = path.join(current, entry.name);
-            if (entry.isDirectory()) {
-                stack.push(next);
-            }
-            else if (entry.isFile() && isTransformableSource(next)) {
-                out.push(next);
-            }
-        }
-    }
-    return out;
-}
-function isTransformableSource(file) {
-    return /\.(?:[cm]?tsx?)$/i.test(file) && !/\.d\.[cm]?ts$/i.test(file);
-}
-function mapOutDirToMaterializedProject(outDir, execution, materialized) {
-    if (!outDir) {
-        return undefined;
-    }
-    const resolved = path.resolve(execution.cwd, outDir);
-    if (isPathInside(resolved, execution.projectRoot)) {
-        return toMaterializedPath(resolved, materialized);
-    }
-    return path.join(materialized.root, ".ttsc-out");
-}
-function copyMaterializedEmittedFiles(materialized, emittedFiles) {
-    const copied = [];
-    for (const emitted of emittedFiles) {
-        if (!isPathInside(emitted, materialized.root)) {
-            continue;
-        }
-        const target = fromMaterializedPath(emitted, materialized);
-        fs.mkdirSync(path.dirname(target), { recursive: true });
-        if (/\.map$/i.test(emitted)) {
-            fs.writeFileSync(target, patchSourceMapText(fs.readFileSync(emitted, "utf8"), materialized, target), "utf8");
-        }
-        else {
-            fs.copyFileSync(emitted, target);
-        }
-        copied.push(target);
-    }
-    return copied;
-}
-function toMaterializedPath(file, materialized) {
-    const relative = path.relative(materialized.originalRoot, file);
-    if (relative.startsWith("..") || path.isAbsolute(relative)) {
-        return file;
-    }
-    return path.join(materialized.root, relative);
-}
-function fromMaterializedPath(file, materialized) {
-    const relative = path.relative(materialized.root, file);
-    if (relative.startsWith("..") || path.isAbsolute(relative)) {
-        return file;
-    }
-    return path.join(materialized.originalRoot, relative);
-}
-function isPathInside(file, parent) {
-    const relative = path.relative(parent, file);
-    return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
-}
-function filepathKey(file) {
-    return path.resolve(file).replace(/\\/g, "/");
-}
-function patchSourceMapText(text, materialized, outputFile, tempOutputFile = toMaterializedPath(outputFile, materialized)) {
-    let map;
-    try {
-        map = JSON.parse(text);
-    }
-    catch {
-        return text;
-    }
-    if (!Array.isArray(map.sources)) {
-        return text;
-    }
-    const tempMapDir = path.dirname(tempOutputFile);
-    const originalMapDir = path.dirname(outputFile);
-    const nextSources = [];
-    const nextSourcesContent = Array.isArray(map.sourcesContent)
-        ? [...map.sourcesContent]
-        : undefined;
-    const sourceMappings = new Map();
-    map.sources.forEach((source, index) => {
-        const tempSource = path.isAbsolute(source)
-            ? source
-            : path.resolve(tempMapDir, source);
-        if (isPathInside(tempSource, materialized.root)) {
-            const originalSource = fromMaterializedPath(tempSource, materialized);
-            const mapper = materialized.mappers.get(filepathKey(tempSource));
-            if (mapper) {
-                sourceMappings.set(index, mapper);
-            }
-            nextSources.push(relativeSourceMapPath(originalMapDir, originalSource));
-            if (nextSourcesContent) {
-                try {
-                    nextSourcesContent[index] = fs.readFileSync(originalSource, "utf8");
-                }
-                catch {
-                    /* keep emitted sourcesContent */
-                }
-            }
-        }
-        else {
-            nextSources.push(source);
-        }
-    });
-    if (sourceMappings.size > 0 && typeof map.mappings === "string") {
-        map.mappings = remapSourceMapMappings(map.mappings, sourceMappings);
-    }
-    map.sources = nextSources;
-    if (nextSourcesContent) {
-        map.sourcesContent = nextSourcesContent;
-    }
-    delete map.sourceRoot;
-    return JSON.stringify(map);
-}
-function relativeSourceMapPath(fromDir, file) {
-    const relative = path.relative(fromDir, file).replace(/\\/g, "/");
-    return relative.startsWith(".") ? relative : `./${relative}`;
-}
-function rewriteSourceMapReference(code, mapFileName) {
-    const reference = `//# sourceMappingURL=${mapFileName}`;
-    if (/\/\/# sourceMappingURL=.*(?:\r?\n)?$/m.test(code)) {
-        return code.replace(/\/\/# sourceMappingURL=.*(?:\r?\n)?$/m, `${reference}\n`);
-    }
-    return code.endsWith("\n") ? `${code}${reference}\n` : `${code}\n${reference}\n`;
-}
-function remapSourceMapMappings(mappings, sourceMappings) {
-    const decoded = decodeMappings(mappings);
-    for (const line of decoded) {
-        for (const segment of line) {
-            if (segment.length < 4) {
-                continue;
-            }
-            const mapper = sourceMappings.get(segment[1]);
-            if (!mapper) {
-                continue;
-            }
-            const mapped = mapTransformedPositionToOriginal(mapper, {
-                column: segment[3],
-                line: segment[2],
-            });
-            segment[2] = mapped.line;
-            segment[3] = mapped.column;
-        }
-    }
-    return encodeMappings(decoded);
-}
-function mapTransformedPositionToOriginal(mapper, position) {
-    let offset = lineColumnToOffset(mapper.finalCode, position.line, position.column);
-    for (let index = mapper.stages.length - 1; index >= 0; index -= 1) {
-        offset = mapOffsetToPreviousStage(offset, mapper.stages[index]);
-    }
-    return offsetToLineColumn(mapper.originalCode, offset);
-}
-function mapOffsetToPreviousStage(offset, stage) {
-    let delta = 0;
-    for (const edit of stage.edits) {
-        if (offset < edit.newStart) {
-            return clampOffset(offset - delta, stage.before.length);
-        }
-        if (offset < edit.newEnd) {
-            return edit.start;
-        }
-        delta += edit.code.length - (edit.end - edit.start);
-    }
-    return clampOffset(offset - delta, stage.before.length);
-}
-function lineColumnToOffset(source, line, column) {
-    const starts = lineStarts(source);
-    const start = starts[Math.min(Math.max(line, 0), starts.length - 1)] ?? 0;
-    return clampOffset(start + Math.max(column, 0), source.length);
-}
-function offsetToLineColumn(source, offset) {
-    const starts = lineStarts(source);
-    const clamped = clampOffset(offset, source.length);
-    let low = 0;
-    let high = starts.length - 1;
-    while (low <= high) {
-        const mid = (low + high) >> 1;
-        const start = starts[mid];
-        const next = starts[mid + 1] ?? Number.POSITIVE_INFINITY;
-        if (clamped < start) {
-            high = mid - 1;
-        }
-        else if (clamped >= next) {
-            low = mid + 1;
-        }
-        else {
-            return { column: clamped - start, line: mid };
-        }
-    }
-    const last = starts.length - 1;
-    return { column: clamped - (starts[last] ?? 0), line: last };
-}
-function lineStarts(source) {
-    const starts = [0];
-    for (let index = 0; index < source.length; index += 1) {
-        const ch = source.charCodeAt(index);
-        if (ch === 13 /* \r */) {
-            if (source.charCodeAt(index + 1) === 10 /* \n */) {
-                index += 1;
-            }
-            starts.push(index + 1);
-        }
-        else if (ch === 10 /* \n */) {
-            starts.push(index + 1);
-        }
-    }
-    return starts;
-}
-function clampOffset(offset, length) {
-    return Math.min(Math.max(offset, 0), length);
-}
-const BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-const BASE64_VALUES = new Map([...BASE64_CHARS].map((char, index) => [char, index]));
-function decodeMappings(mappings) {
-    const lines = [];
-    let line = [];
-    let segment = [];
-    let index = 0;
-    const state = [0, 0, 0, 0, 0];
-    while (index < mappings.length) {
-        const char = mappings[index];
-        if (char === ";") {
-            if (segment.length > 0) {
-                line.push(segment);
-                segment = [];
-            }
-            lines.push(line);
-            line = [];
-            state[0] = 0;
-            index += 1;
-            continue;
-        }
-        if (char === ",") {
-            if (segment.length > 0) {
-                line.push(segment);
-                segment = [];
-            }
-            index += 1;
-            continue;
-        }
-        const read = readVlq(mappings, index);
-        index = read.next;
-        const field = segment.length;
-        state[field] = (state[field] ?? 0) + read.value;
-        segment.push(state[field]);
-    }
-    if (segment.length > 0) {
-        line.push(segment);
-    }
-    lines.push(line);
-    return lines;
-}
-function encodeMappings(lines) {
-    const state = [0, 0, 0, 0, 0];
-    return lines
-        .map((line) => {
-        state[0] = 0;
-        return line
-            .map((segment) => segment
-            .map((value, index) => {
-            const relative = value - (state[index] ?? 0);
-            state[index] = value;
-            return writeVlq(relative);
-        })
-            .join(""))
-            .join(",");
-    })
-        .join(";");
-}
-function readVlq(input, start) {
-    let index = start;
-    let shift = 0;
-    let value = 0;
-    while (index < input.length) {
-        const digit = BASE64_VALUES.get(input[index]);
-        if (digit === undefined) {
-            throw new Error(`ttsc: invalid source map VLQ digit ${input[index]}`);
-        }
-        index += 1;
-        const continuation = (digit & 32) !== 0;
-        value += (digit & 31) << shift;
-        shift += 5;
-        if (!continuation) {
-            const negative = (value & 1) === 1;
-            const decoded = value >> 1;
-            return { next: index, value: negative ? -decoded : decoded };
-        }
-    }
-    throw new Error("ttsc: unterminated source map VLQ segment");
-}
-function writeVlq(value) {
-    let vlq = Math.abs(value) << 1;
-    if (value < 0) {
-        vlq |= 1;
-    }
-    let out = "";
-    do {
-        let digit = vlq & 31;
-        vlq >>>= 5;
-        if (vlq > 0) {
-            digit |= 32;
-        }
-        out += BASE64_CHARS[digit];
-    } while (vlq > 0);
-    return out;
-}
 //# sourceMappingURL=api.js.map