@decohere/forge 0.0.1-dev.112 → 0.0.1-dev.113

package/commonjs/src/services/type-emitter.js

@@ -24,11 +24,10 @@ _export(exports, {
 });
 const _caching = require("@decohere/nexus/caching");
 const _diagnostics = require("@decohere/nexus/diagnostics");
-const _extensibility = require("@decohere/nexus/extensibility");
 const _io = require("@decohere/nexus/io");
 require("../extensions/project.extensions.js");
-const _cachesoutputsmixin = require("../mixins/caches-outputs.mixin.js");
-const _incrementaltransformmixin = require("../mixins/incremental-transform.mixin.js");
+const _incrementalwatch = require("./incremental-watch.js");
+const _outputcache = require("./output-cache.js");
 const _tsprogramhost = require("./ts-program-host.js");
 const _typeemissionprogram = require("./type-emission-program.js");
 const _buildtargettype = require("../types/build-target.type.js");
@@ -55,12 +54,20 @@ const REQUIRED_TYPE_EMITTER_OPTIONS = {
 const REQUIRED_TYPE_CHECK_OPTIONS = {
     noEmit: true
 };
-class TypeEmitter extends (0, _extensibility.mixwith)(_cachesoutputsmixin.CachesOutputs, _incrementaltransformmixin.IncrementalTransform) {
+class TypeEmitter {
     buildTargets = [
         _buildtargettype.BuildTargets.types
     ];
     /** Prepared programs from init(), consumed once by the next transformProject() call. */ #programs;
     #host = new _tsprogramhost.TsProgramHost();
+    #outputs = new _outputcache.OutputCache();
+    #incremental = new _incrementalwatch.IncrementalWatch();
+    get incrementalTransform$() {
+        return this.#incremental.results$;
+    }
+    watch(workspace) {
+        this.#incremental.watch(workspace, (evt)=>this.onIncrementalFileEvent(evt));
+    }
     /**
 	 * Phase 1: fetch files, create TypeScript programs sequentially.
 	 * Called before transformProject() so that the heavy createProgram work
@@ -79,7 +86,7 @@ class TypeEmitter extends (0, _extensibility.mixwith)(_cachesoutputsmixin.Caches
             return [];
         }
         const responses = (await Promise.all(programs.map((program)=>program.emit(filter, onOutput)))).flat();
-        this.cacheOutputs(responses);
+        this.#outputs.record(responses);
         return responses;
     }
     /**
@@ -133,7 +140,7 @@ class TypeEmitter extends (0, _extensibility.mixwith)(_cachesoutputsmixin.Caches
     async onIncrementalFileEvent(evt) {
         const { file, project } = evt;
         if (evt.eventName === _io.io.WatchEvents.unlink) {
-            this.deleteCachedOutputs(file.fullPath);
+            this.#outputs.delete(file.fullPath);
             return [];
         }
         if (!project.isSourceFile(file)) {

package/commonjs/src/types/transform-response.model.js

@@ -2,25 +2,12 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: Object.getOwnPropertyDescriptor(all, name).get
-    });
-}
-_export(exports, {
-    get TransformOutcomes () {
-        return TransformOutcomes;
-    },
-    get TransformResponse () {
+Object.defineProperty(exports, "TransformResponse", {
+    enumerable: true,
+    get: function() {
         return TransformResponse;
     }
 });
-const TransformOutcomes = {
-    success: "success",
-    failure: "failure",
-    skipped: "skipped"
-};
 class TransformResponse {
     static Success(data) {
         return new TransformResponse({

package/commonjs/src/vitest/forge-build.plugin.js

@@ -24,11 +24,6 @@ function _interop_require_default(obj) {
 // Above fatal (60) so all standard levels are nooped when logLevel is "silent"
 const SILENT_LEVEL = 999;
 const PLUGIN_NAME = "forge-vitest-source";
-const TS_EXTENSIONS = [
-    ".ts",
-    ".tsx",
-    ".mts"
-];
 function forgeBuild(options) {
     const buildConfig = options?.buildConfig ?? "debug";
     const workspaceRoot = options?.workspaceRoot ?? process.cwd();
@@ -77,11 +72,10 @@ function forgeBuild(options) {
             logger.debug("Plugin loaded");
         },
         resolveId (source, importer) {
-            if (importer != null && source.endsWith(".js") && source.startsWith(".")) {
-                const importerDirectory = _nodepath.default.dirname(importer);
-                const withoutExtension = source.slice(0, -3);
-                const candidates = TS_EXTENSIONS.map((ext)=>_nodepath.default.resolve(importerDirectory, `${withoutExtension}${ext}`));
-                return candidates.find((c)=>(0, _nodefs.existsSync)(c)) ?? null;
+            // `./a.js` is `a.ts` or `a.tsx`, `./a.mjs` is `a.mts`, `./a.cjs` is `a.cts` (#518).
+            if (importer != null && /\.[mc]?jsx?$/.test(source) && source.startsWith(".")) {
+                const written = _nodepath.default.resolve(_nodepath.default.dirname(importer), source);
+                return _mesh.sourceExtensions.candidates(written).find((c)=>(0, _nodefs.existsSync)(c)) ?? null;
             }
             return null;
         },

package/es6/src/actions/index.js

@@ -7,6 +7,7 @@ export * from "./dependency-sync.action.js";
 export * from "./docker.action.js";
 export * from "./link.action.js";
 export * from "./package.action.js";
+export * from "./paths.action.js";
 export * from "./publish.action.js";
 export * from "./sync-lock-file.action.js";
 export * from "./tag.action.js";

package/es6/src/actions/paths.action.js

@@ -0,0 +1,86 @@
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+import { existsSync } from "node:fs";
+import { readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { injectable } from "@decohere/crucible/decorators";
+import { packageAliases, Workspace } from "@decohere/mesh";
+import { ActionResponse } from "@decohere/nexus/cli";
+import { scribe } from "@decohere/scribe";
+export const PATHS_FILE = "tsconfig.paths.json";
+export class Paths {
+    workspace;
+    #logger = scribe.logger(Paths.name);
+    constructor(workspace){
+        this.workspace = workspace;
+    }
+    async run(options) {
+        const file = path.join(this.workspace.rootDir, PATHS_FILE);
+        const content = Paths.render(this.workspace);
+        const current = existsSync(file) ? await readFile(file, "utf8") : null;
+        const changed = current !== content;
+        if (options.check) {
+            if (!changed) {
+                return ActionResponse.Success(Paths.name, [
+                    {
+                        file,
+                        changed,
+                        succeeded: true
+                    }
+                ]);
+            }
+            const error = `${PATHS_FILE} is out of date. Run \`forge paths\` to update it.`;
+            this.#logger.error(error);
+            return ActionResponse.Error(Paths.name, [
+                {
+                    file,
+                    changed,
+                    succeeded: false,
+                    error
+                }
+            ]);
+        }
+        if (changed) {
+            await writeFile(file, content);
+            this.#logger.info(`Wrote ${PATHS_FILE}`);
+        }
+        return ActionResponse.Success(Paths.name, [
+            {
+                file,
+                changed,
+                succeeded: true
+            }
+        ]);
+    }
+    /** The file's content: convention and exported subpaths only, never the tsconfig's own paths. */ static render(workspace) {
+        const rootDir = path.resolve(workspace.rootDir);
+        const { paths } = packageAliases.build(workspace.getProjects("debug"), {
+            baseUrl: rootDir
+        });
+        const sorted = Object.fromEntries(Object.keys(paths).sort().map((key)=>[
+                key,
+                (paths[key] ?? []).map((target)=>`./${target}`)
+            ]));
+        const json = {
+            $comment: "Generated by `forge paths` from the workspace packages. Do not edit.",
+            compilerOptions: {
+                paths: sorted
+            }
+        };
+        return `${JSON.stringify(json, null, 2)}\n`;
+    }
+}
+Paths = _ts_decorate([
+    injectable(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof Workspace === "undefined" ? Object : Workspace
+    ])
+], Paths);

package/es6/src/commands/index.js

@@ -4,6 +4,7 @@ export * from "./docker.command.js";
 export * from "./forge.command.js";
 export * from "./link.command.js";
 export * from "./package.command.js";
+export * from "./paths.command.js";
 export * from "./publish.command.js";
 export * from "./tag.command.js";
 export * from "./typecheck.command.js";

package/es6/src/commands/paths.command.js

@@ -0,0 +1,14 @@
+import { DecohereCommand } from "@decohere/nexus/cli";
+import { Paths } from "../actions/paths.action.js";
+export class PathsCommand extends DecohereCommand {
+    get actions() {
+        return [
+            Paths
+        ];
+    }
+    constructor(name){
+        super(name);
+        this.description("Write tsconfig.paths.json: tsconfig paths for the workspace packages and their exported subpaths");
+        this.option("--check", "Fail if tsconfig.paths.json is missing or out of date", false);
+    }
+}

package/es6/src/extensions/project.extensions.js

@@ -37,7 +37,7 @@ export class ProjectExtensions {
     }
     static swcConfigPaths(project) {
         return [
-            path.join(project.projectDirectory, SWC_CONFIG),
+            path.join(project.projectRoot, SWC_CONFIG),
             path.join(project.rootDir, SWC_CONFIG)
         ];
     }

package/es6/src/factories/swc-config.factory.js

@@ -58,9 +58,18 @@ export class SwcConfigFactory {
             mergeArrays: false
         }, defaultOptions, options, userConfig ?? {});
     }
-    /** Stamps a per-file filename onto a pre-built base config. */ createFileConfig(file, baseConfig) {
+    /** Stamps a per-file filename onto a pre-built base config; `.tsx` also turns on JSX (#518). */ createFileConfig(file, baseConfig) {
+        const tsx = file.fullPath.endsWith(".tsx");
+        const jsc = tsx && baseConfig.jsc?.parser?.syntax === "typescript" ? {
+            ...baseConfig.jsc,
+            parser: {
+                ...baseConfig.jsc.parser,
+                tsx: true
+            }
+        } : baseConfig.jsc;
         const config = {
             ...baseConfig,
+            jsc,
             filename: file.fullPath
         };
         this.validate(config);

package/es6/src/forge.module.js

@@ -25,6 +25,7 @@ export class ForgeModule extends ModuleManifest {
         reportDependencies: Actions.ReportDependencies,
         version: Actions.Version,
         tag: Actions.Tag,
+        paths: Actions.Paths,
         typecheck: Actions.TypeCheck,
         commitFiles: Actions.CommitFiles,
         link: Actions.Link,
@@ -38,6 +39,7 @@ export class ForgeModule extends ModuleManifest {
         package: Commands.PackageCommand,
         version: Commands.VersionCommand,
         tag: Commands.TagCommand,
+        paths: Commands.PathsCommand,
         typecheck: Commands.TypeCheckCommand,
         link: Commands.LinkCommand,
         unlink: Commands.UnlinkCommand

package/es6/src/index.js

@@ -2,5 +2,6 @@ export { createWorkspace } from "./create-workspace.js";
 export { ForgeError } from "./errors.js";
 export { ForgeModule } from "./forge.module.js";
 export { SwcTranspiler } from "./services/swc-transpiler.js";
+export { transpileCache } from "./services/transpile-cache.js";
 export { BuildTargets } from "./types/build-target.type.js";
 export { Debug as DebugConfiguration, DefaultConfigurations, Link as LinkConfiguration, Release as ReleaseConfiguration, WorkspaceDefaults } from "./workspace.config.js";

package/es6/src/packaging/release-exports.js

@@ -1,11 +1,13 @@
+import { sourceExtensions } from "@decohere/mesh";
 const ES6_PREFIX = "./es6/";
 /** Condition names that can point at runnable ESM, most specific first. `types` never does. */ const RUNTIME_CONDITIONS = [
     "import",
     "node",
     "default"
 ];
-/** `src/main.ts` becomes `src/main.js`, with any leading `./` dropped. */ function toJs(filePath) {
-    return filePath.replace(/^\.\//, "").replace(/\.ts$/, ".js").replace(/\.mts$/, ".mjs");
+/** `src/main.ts` becomes `src/main.js` (`.mts` `.mjs`, `.cts` `.cjs`), with any leading `./` dropped. */ function toJs(filePath) {
+    const file = filePath.replace(/^\.\//, "");
+    return sourceExtensions.isSource(file) ? sourceExtensions.outputPath(file) : file;
 }
 /**
  * The `exports` a library needs once only its `es6/` output is shipped: the library's own

package/es6/src/services/file-writer.service.js

@@ -14,19 +14,12 @@ export class FileWriterService {
     #artifactByPath = new Map();
     #warmupSignature = "";
     #warmupPromise;
-    #initialized = false;
     #pendingWrites = [];
     #activeWorkers = 0;
     #drainResolvers = [];
     #ensuredDirs = new Set();
     #ensureDirPromises = new Map();
     #workerError;
-    async initialize() {
-        if (this.#initialized) {
-            return;
-        }
-        this.#initialized = true;
-    }
     async warmup(projects) {
         const outputDirs = this.getOutputDirs(projects);
         const signature = outputDirs.join("|");

package/es6/src/services/incremental-watch.js

@@ -0,0 +1,18 @@
+import { Subject } from "rxjs";
+/**
+ * Runs a transformer's handler for every workspace file change and emits what it built. The
+ * handler invalidates the transformer's own caches, rebuilds, and returns the responses (empty
+ * for a deletion or when nothing was built).
+ */ export class IncrementalWatch {
+    #results = new Subject();
+    get results$() {
+        return this.#results.asObservable();
+    }
+    watch(workspace, handler) {
+        workspace.projectFileChanged$.subscribe((evt)=>{
+            void handler(evt).then((responses)=>{
+                this.#results.next(responses);
+            });
+        });
+    }
+}

package/es6/src/services/output-cache.js

@@ -0,0 +1,29 @@
+import { io } from "@decohere/nexus/io";
+/** The outputs each source file last built to, so watch mode can delete them when it goes. */ export class OutputCache {
+    #bySource = new Map();
+    get(sourcePath) {
+        return this.#bySource.get(sourcePath);
+    }
+    /** Records the successful outputs, replacing what each of their source files had before. */ record(responses) {
+        const bySource = new Map();
+        for (const response of responses){
+            if (response.outcome !== "success") continue;
+            const group = bySource.get(response.file.fullPath) ?? [];
+            group.push(response);
+            bySource.set(response.file.fullPath, group);
+        }
+        for (const [sourcePath, group] of bySource){
+            this.#bySource.set(sourcePath, group);
+        }
+    }
+    /** Deletes the files a source built to and forgets them. */ delete(sourcePath) {
+        const outputs = this.#bySource.get(sourcePath);
+        if (outputs == null) return;
+        for (const response of outputs){
+            if (response.outputPath != null) {
+                void io.deleteFile(response.outputPath);
+            }
+        }
+        this.#bySource.delete(sourcePath);
+    }
+}

package/es6/src/services/swc-transpiler.js

@@ -7,29 +7,33 @@ function _ts_decorate(decorators, target, key, desc) {
 function _ts_metadata(k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-import fs from "node:fs";
 import path from "node:path";
+import { sourceExtensions } from "@decohere/mesh";
 import { cache, invalidateCache } from "@decohere/nexus/caching";
 import { Trace } from "@decohere/nexus/diagnostics";
-import { mixwith } from "@decohere/nexus/extensibility";
 import { io } from "@decohere/nexus/io";
 import { transform, transformSync } from "@swc/core";
 import { BuildTargets } from "../types/build-target.type.js";
 import "../extensions/project.extensions.js";
 import { SwcConfigFactory } from "../factories/swc-config.factory.js";
-import { CachesOutputs } from "../mixins/caches-outputs.mixin.js";
-import { IncrementalTransform } from "../mixins/incremental-transform.mixin.js";
 import { TransformResponse } from "../types/transform-response.model.js";
-export class SwcTranspiler extends mixwith(CachesOutputs, IncrementalTransform) {
+import { IncrementalWatch } from "./incremental-watch.js";
+import { OutputCache } from "./output-cache.js";
+export class SwcTranspiler {
     buildTargets = [
         BuildTargets.es6,
         BuildTargets.commonjs
     ];
     #swcConfigFactory = new SwcConfigFactory();
     #workspace;
+    #outputs = new OutputCache();
+    #incremental = new IncrementalWatch();
+    get incrementalTransform$() {
+        return this.#incremental.results$;
+    }
     watch(workspace) {
         this.#workspace = workspace;
-        super.watch(workspace);
+        this.#incremental.watch(workspace, (evt)=>this.onIncrementalFileEvent(evt));
     }
     withAliasContext(options = {}) {
         return {
@@ -63,42 +67,18 @@ export class SwcTranspiler extends mixwith(CachesOutputs, IncrementalTransform)
             return responses.flat();
         }));
         const flat = responses.flat();
-        this.cacheOutputs(flat);
+        this.#outputs.record(flat);
         return flat;
     }
-    async transformFile(fileArrayLike, buildTarget, options = {}) {
-        const files = Array.isArray(fileArrayLike) ? fileArrayLike : [
-            fileArrayLike
-        ];
-        const responses = this.transformTarget(files, buildTarget, options);
-        return responses;
-    }
     /**
 	 * The SWC options for one project and target, without a filename. Building them reads the
 	 * workspace's aliases and merges configs, so a caller that transpiles many files builds them
-	 * once and passes them to {@link transformFileSync}.
+	 * once and passes them to {@link transformCode}.
 	 */ createBaseConfig(buildTarget, options = {}) {
         return this.#swcConfigFactory.createBaseConfig(buildTarget, this.withAliasContext(options));
     }
-    /**
-	 * Synchronous, single-file variant of `transformFile`.
-	 * Reads the file with `fs.readFileSync` and transpiles via `swc.transformSync`.
-	 * Intended for callers that cannot await (e.g. Node.js `registerHooks` load hook).
-	 * Pass `baseConfig` from {@link createBaseConfig} to skip rebuilding it for every file.
-	 */ transformFileSync(file, buildTarget, options = {}, baseConfig = this.createBaseConfig(buildTarget, options)) {
+    /** Sync variant of {@link transformCode}, for the load hook, which cannot await (#514). */ transformCodeSync(content, file, buildTarget, baseConfig) {
         const swcOptions = this.#swcConfigFactory.createFileConfig(file, baseConfig);
-        let content;
-        try {
-            content = fs.readFileSync(file.fullPath, "utf8");
-        } catch (error) {
-            return TransformResponse.Error({
-                file,
-                messages: [
-                    String(error)
-                ],
-                config: swcOptions
-            });
-        }
         if (content === "") return SwcTranspiler.skippedEmpty(file, swcOptions);
         try {
             const transformed = transformSync(content, swcOptions);
@@ -116,135 +96,76 @@ export class SwcTranspiler extends mixwith(CachesOutputs, IncrementalTransform)
             });
         }
     }
-    /**
-	 * Async variant of {@link transformFileSync}, with the same result for the same file. SWC
-	 * runs it on libuv's thread pool, so many calls in flight compile in parallel (#661).
-	 */ async transformFileAsync(file, buildTarget, options = {}, baseConfig = this.createBaseConfig(buildTarget, options)) {
-        let content;
-        try {
-            content = await fs.promises.readFile(file.fullPath, "utf8");
-        } catch (error) {
-            const swcOptions = this.#swcConfigFactory.createFileConfig(file, baseConfig);
-            return TransformResponse.Error({
-                file,
-                messages: [
-                    String(error)
-                ],
-                config: swcOptions
-            });
-        }
-        return this.transformCode(content, file, buildTarget, baseConfig);
-    }
     /**
 	 * Compiles `content` as the source of `file`, without reading the file: for callers that
 	 * already hold the code, such as the Vitest plugin, which must compile what Vite passes it
-	 * rather than an earlier read of the disk (#517). Async SWC, on the thread pool.
-	 */ async transformCode(content, file, buildTarget, baseConfig) {
+	 * rather than an earlier read of the disk (#517). Async SWC, on the thread pool, so many
+	 * calls in flight compile in parallel (#661). With a `project`, the response carries where
+	 * the build writes the output.
+	 */ async transformCode(content, file, buildTarget, baseConfig, project) {
         const swcOptions = this.#swcConfigFactory.createFileConfig(file, baseConfig);
-        if (content === "") return SwcTranspiler.skippedEmpty(file, swcOptions);
+        if (content === "") return SwcTranspiler.skippedEmpty(file, swcOptions, project);
         try {
             const transformed = await transform(content, swcOptions);
             if (transformed == null) {
                 throw new Error("swc.transform returned no result");
             }
-            return SwcTranspiler.succeeded(file, buildTarget, swcOptions, content, transformed.code);
+            return SwcTranspiler.succeeded(file, buildTarget, swcOptions, content, transformed.code, project);
         } catch (error) {
             return TransformResponse.Error({
                 file,
                 messages: [
                     String(error)
                 ],
-                config: swcOptions
+                config: swcOptions,
+                project
             });
         }
     }
-    static skippedEmpty(file, swcOptions) {
+    static skippedEmpty(file, swcOptions, project) {
         return TransformResponse.Skipped({
             file,
             messages: "File is empty",
-            config: swcOptions
+            config: swcOptions,
+            project
         });
     }
-    static succeeded(file, buildTarget, swcOptions, content, code) {
-        const filePath = file.relativePath;
-        const extName = path.extname(filePath);
-        const fileName = filePath.replace(new RegExp(`${extName}$`), ".js");
+    static succeeded(file, buildTarget, swcOptions, content, code, project) {
+        const fileName = sourceExtensions.outputPath(file.relativePath);
+        const outBaseDir = project?.getOutDir(buildTarget);
+        const outputPath = outBaseDir ? path.join(outBaseDir, fileName) : undefined;
         return TransformResponse.Success({
             file,
             code,
             sourceContent: content,
             target: buildTarget,
             fileName,
-            config: swcOptions
+            outputDir: outputPath ? path.dirname(outputPath) : undefined,
+            outputPath,
+            config: swcOptions,
+            project
         });
     }
     async transformTarget(files, buildTarget, options, project, onOutput) {
-        const baseConfig = this.#swcConfigFactory.createBaseConfig(buildTarget, this.withAliasContext(options));
-        return await Promise.all(files.map((file)=>{
-            const swcOptions = this.#swcConfigFactory.createFileConfig(file, baseConfig);
-            return this.runTransform(file, buildTarget, swcOptions, project, onOutput);
+        const baseConfig = this.createBaseConfig(buildTarget, options);
+        return await Promise.all(files.map(async (file)=>{
+            const content = await this.getFileContent(file);
+            const response = await this.transformCode(content, file, buildTarget, baseConfig, project);
+            onOutput?.(response);
+            return response;
         }));
     }
-    async runTransform(file, target, swcOptions, project, onOutput) {
-        const content = await this.getFileContent(file);
-        if (content === "") {
-            const skipped = TransformResponse.Skipped({
-                file,
-                messages: "File is empty",
-                config: swcOptions,
-                project
-            });
-            onOutput?.(skipped);
-            return skipped;
-        }
-        try {
-            const filePath = file.relativePath;
-            const extName = path.extname(filePath);
-            const fileName = filePath.replace(new RegExp(`${extName}$`), ".js");
-            const outBaseDir = project?.getOutDir(target);
-            const outputPath = outBaseDir ? path.join(outBaseDir, fileName) : undefined;
-            const outputDir = outputPath ? path.dirname(outputPath) : undefined;
-            const transformed = await transform(content, swcOptions);
-            if (transformed == null) {
-                throw new Error("swc.transform returned no result");
-            }
-            const success = TransformResponse.Success({
-                file,
-                code: transformed.code,
-                sourceContent: content,
-                target,
-                fileName,
-                outputDir,
-                outputPath,
-                config: swcOptions,
-                project
-            });
-            onOutput?.(success);
-            return success;
-        } catch (error) {
-            const failure = TransformResponse.Error({
-                file,
-                messages: [
-                    String(error)
-                ],
-                config: swcOptions,
-                project
-            });
-            onOutput?.(failure);
-            return failure;
-        }
-    }
     async onIncrementalFileEvent(evt) {
         const { file, project } = evt;
         if (evt.eventName === io.WatchEvents.unlink) {
-            this.deleteCachedOutputs(file.fullPath);
+            this.#outputs.delete(file.fullPath);
             return [];
         }
         if (!project.isSourceFile(file)) {
             return [];
         }
         const freshContent = await file.getContent();
-        const cached = this.outputCache.get(file.fullPath);
+        const cached = this.#outputs.get(file.fullPath);
         if (cached != null && cached[0]?.sourceContent === freshContent) {
             return [];
         }

package/es6/src/services/transpile-cache.js

@@ -0,0 +1,29 @@
+import { existsSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { version as swcVersion } from "@swc/core";
+/**
+ * Where compiled code is cached on disk (#514), or null when caching is off:
+ *
+ * - `DECOHERE_CACHE=0` turns it off.
+ * - `DECOHERE_CACHE_DIR` puts it in that directory.
+ * - Otherwise `<root>/node_modules/.cache/decohere`, where tools keep caches, or when the
+ *   workspace has no `node_modules`, `$XDG_CACHE_HOME/decohere`, then the OS temp directory.
+ *
+ * Flux keeps its entries in the `flux` folder inside it; `forge clean` removes the folder.
+ */ function directory(rootDir, env = process.env) {
+    if (env.DECOHERE_CACHE === "0") return null;
+    if (env.DECOHERE_CACHE_DIR != null && env.DECOHERE_CACHE_DIR !== "") {
+        return path.resolve(env.DECOHERE_CACHE_DIR);
+    }
+    const nodeModules = path.join(rootDir, "node_modules");
+    if (existsSync(nodeModules)) return path.join(nodeModules, ".cache", "decohere");
+    if (env.XDG_CACHE_HOME != null && env.XDG_CACHE_HOME !== "") {
+        return path.join(env.XDG_CACHE_HOME, "decohere");
+    }
+    return path.join(os.tmpdir(), "decohere");
+}
+/** The SWC version compiling: part of every cache key, so upgrading SWC misses. */ export const transpileCache = {
+    directory,
+    swcVersion
+};