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

package/README.md

@@ -10,6 +10,8 @@ Build system (SWC). `forge build --configuration debug` rewrites workspace impor
 
 Forge debug (`aliasPaths: true`) asks Mesh for a map of `package.json` `name` → source `main` (`Workspace.getPackageAliases`) and feeds it to SWC as `jsc.paths`. Flux uses the same map in its resolve hook only, and compiles without `jsc.paths` or `resolveFully`, so imports are resolved once (#513).
 
+`tsc` can't read Mesh's map, and without `node_modules` links it finds workspace packages only through tsconfig `paths`. `forge paths` writes the map to `tsconfig.paths.json` for the root tsconfig to extend, and `forge paths --check` fails when the file is out of date (#518).
+
 That is a **debug** rule. Release does not rewrite aliases: production must resolve like any other Node app (installed packages, `exports` / `main` pointing at emitted JS).
 
 ### Why aliases instead of workspace symlinks

package/commonjs/src/actions/index.js

@@ -11,6 +11,7 @@ _export_star(require("./dependency-sync.action.js"), exports);
 _export_star(require("./docker.action.js"), exports);
 _export_star(require("./link.action.js"), exports);
 _export_star(require("./package.action.js"), exports);
+_export_star(require("./paths.action.js"), exports);
 _export_star(require("./publish.action.js"), exports);
 _export_star(require("./sync-lock-file.action.js"), exports);
 _export_star(require("./tag.action.js"), exports);

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

@@ -0,0 +1,109 @@
+"use strict";
+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 PATHS_FILE () {
+        return PATHS_FILE;
+    },
+    get Paths () {
+        return Paths;
+    }
+});
+const _nodefs = require("node:fs");
+const _promises = require("node:fs/promises");
+const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
+const _decorators = require("@decohere/crucible/decorators");
+const _mesh = require("@decohere/mesh");
+const _cli = require("@decohere/nexus/cli");
+const _scribe = require("@decohere/scribe");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+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);
+}
+const PATHS_FILE = "tsconfig.paths.json";
+class Paths {
+    workspace;
+    #logger = _scribe.scribe.logger(Paths.name);
+    constructor(workspace){
+        this.workspace = workspace;
+    }
+    async run(options) {
+        const file = _nodepath.default.join(this.workspace.rootDir, PATHS_FILE);
+        const content = Paths.render(this.workspace);
+        const current = (0, _nodefs.existsSync)(file) ? await (0, _promises.readFile)(file, "utf8") : null;
+        const changed = current !== content;
+        if (options.check) {
+            if (!changed) {
+                return _cli.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 _cli.ActionResponse.Error(Paths.name, [
+                {
+                    file,
+                    changed,
+                    succeeded: false,
+                    error
+                }
+            ]);
+        }
+        if (changed) {
+            await (0, _promises.writeFile)(file, content);
+            this.#logger.info(`Wrote ${PATHS_FILE}`);
+        }
+        return _cli.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 = _nodepath.default.resolve(workspace.rootDir);
+        const { paths } = _mesh.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([
+    (0, _decorators.injectable)(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _mesh.Workspace === "undefined" ? Object : _mesh.Workspace
+    ])
+], Paths);

package/commonjs/src/commands/index.js

@@ -8,6 +8,7 @@ _export_star(require("./docker.command.js"), exports);
 _export_star(require("./forge.command.js"), exports);
 _export_star(require("./link.command.js"), exports);
 _export_star(require("./package.command.js"), exports);
+_export_star(require("./paths.command.js"), exports);
 _export_star(require("./publish.command.js"), exports);
 _export_star(require("./tag.command.js"), exports);
 _export_star(require("./typecheck.command.js"), exports);

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "PathsCommand", {
+    enumerable: true,
+    get: function() {
+        return PathsCommand;
+    }
+});
+const _cli = require("@decohere/nexus/cli");
+const _pathsaction = require("../actions/paths.action.js");
+class PathsCommand extends _cli.DecohereCommand {
+    get actions() {
+        return [
+            _pathsaction.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/commonjs/src/extensions/project.extensions.js

@@ -52,7 +52,7 @@ class ProjectExtensions {
     }
     static swcConfigPaths(project) {
         return [
-            _nodepath.default.join(project.projectDirectory, _const.SWC_CONFIG),
+            _nodepath.default.join(project.projectRoot, _const.SWC_CONFIG),
             _nodepath.default.join(project.rootDir, _const.SWC_CONFIG)
         ];
     }

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

@@ -73,9 +73,18 @@ 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/commonjs/src/forge.module.js

@@ -76,6 +76,7 @@ class ForgeModule extends _cli.ModuleManifest {
         reportDependencies: _index.ReportDependencies,
         version: _index.Version,
         tag: _index.Tag,
+        paths: _index.Paths,
         typecheck: _index.TypeCheck,
         commitFiles: _index.CommitFiles,
         link: _index.Link,
@@ -89,6 +90,7 @@ class ForgeModule extends _cli.ModuleManifest {
         package: _index1.PackageCommand,
         version: _index1.VersionCommand,
         tag: _index1.TagCommand,
+        paths: _index1.PathsCommand,
         typecheck: _index1.TypeCheckCommand,
         link: _index1.LinkCommand,
         unlink: _index1.UnlinkCommand

package/commonjs/src/index.js

@@ -38,11 +38,15 @@ _export(exports, {
     },
     get createWorkspace () {
         return _createworkspace.createWorkspace;
+    },
+    get transpileCache () {
+        return _transpilecache.transpileCache;
     }
 });
 const _createworkspace = require("./create-workspace.js");
 const _errors = require("./errors.js");
 const _forgemodule = require("./forge.module.js");
 const _swctranspiler = require("./services/swc-transpiler.js");
+const _transpilecache = require("./services/transpile-cache.js");
 const _buildtargettype = require("./types/build-target.type.js");
 const _workspaceconfig = require("./workspace.config.js");

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

@@ -8,14 +8,16 @@ Object.defineProperty(exports, "releaseExports", {
         return releaseExports;
     }
 });
+const _mesh = require("@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 _mesh.sourceExtensions.isSource(file) ? _mesh.sourceExtensions.outputPath(file) : file;
 }
 /**
  * The `exports` a library needs once only its `es6/` output is shipped: the library's own

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

@@ -29,19 +29,12 @@ 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/commonjs/src/services/incremental-watch.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "IncrementalWatch", {
+    enumerable: true,
+    get: function() {
+        return IncrementalWatch;
+    }
+});
+const _rxjs = require("rxjs");
+class IncrementalWatch {
+    #results = new _rxjs.Subject();
+    get results$() {
+        return this.#results.asObservable();
+    }
+    watch(workspace, handler) {
+        workspace.projectFileChanged$.subscribe((evt)=>{
+            void handler(evt).then((responses)=>{
+                this.#results.next(responses);
+            });
+        });
+    }
+}

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

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "OutputCache", {
+    enumerable: true,
+    get: function() {
+        return OutputCache;
+    }
+});
+const _io = require("@decohere/nexus/io");
+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.io.deleteFile(response.outputPath);
+            }
+        }
+        this.#bySource.delete(sourcePath);
+    }
+}

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

@@ -8,19 +8,18 @@ Object.defineProperty(exports, "SwcTranspiler", {
         return SwcTranspiler;
     }
 });
-const _nodefs = /*#__PURE__*/ _interop_require_default(require("node:fs"));
 const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
+const _mesh = require("@decohere/mesh");
 const _caching = require("@decohere/nexus/caching");
 const _diagnostics = require("@decohere/nexus/diagnostics");
-const _extensibility = require("@decohere/nexus/extensibility");
 const _io = require("@decohere/nexus/io");
 const _core = require("@swc/core");
 const _buildtargettype = require("../types/build-target.type.js");
 require("../extensions/project.extensions.js");
 const _swcconfigfactory = require("../factories/swc-config.factory.js");
-const _cachesoutputsmixin = require("../mixins/caches-outputs.mixin.js");
-const _incrementaltransformmixin = require("../mixins/incremental-transform.mixin.js");
 const _transformresponsemodel = require("../types/transform-response.model.js");
+const _incrementalwatch = require("./incremental-watch.js");
+const _outputcache = require("./output-cache.js");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -35,16 +34,21 @@ 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);
 }
-class SwcTranspiler extends (0, _extensibility.mixwith)(_cachesoutputsmixin.CachesOutputs, _incrementaltransformmixin.IncrementalTransform) {
+class SwcTranspiler {
     buildTargets = [
         _buildtargettype.BuildTargets.es6,
         _buildtargettype.BuildTargets.commonjs
     ];
     #swcConfigFactory = new _swcconfigfactory.SwcConfigFactory();
     #workspace;
+    #outputs = new _outputcache.OutputCache();
+    #incremental = new _incrementalwatch.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 {
@@ -78,42 +82,18 @@ class SwcTranspiler extends (0, _extensibility.mixwith)(_cachesoutputsmixin.Cach
             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 = _nodefs.default.readFileSync(file.fullPath, "utf8");
-        } catch (error) {
-            return _transformresponsemodel.TransformResponse.Error({
-                file,
-                messages: [
-                    String(error)
-                ],
-                config: swcOptions
-            });
-        }
         if (content === "") return SwcTranspiler.skippedEmpty(file, swcOptions);
         try {
             const transformed = (0, _core.transformSync)(content, swcOptions);
@@ -132,126 +112,75 @@ class SwcTranspiler extends (0, _extensibility.mixwith)(_cachesoutputsmixin.Cach
         }
     }
     /**
-	 * 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)) {
+	 * 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, 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);
-        let content;
-        try {
-            content = await _nodefs.default.promises.readFile(file.fullPath, "utf8");
-        } catch (error) {
-            return _transformresponsemodel.TransformResponse.Error({
-                file,
-                messages: [
-                    String(error)
-                ],
-                config: swcOptions
-            });
-        }
-        if (content === "") return SwcTranspiler.skippedEmpty(file, swcOptions);
+        if (content === "") return SwcTranspiler.skippedEmpty(file, swcOptions, project);
         try {
             const transformed = await (0, _core.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 _transformresponsemodel.TransformResponse.Error({
                 file,
                 messages: [
                     String(error)
                 ],
-                config: swcOptions
+                config: swcOptions,
+                project
             });
         }
     }
-    static skippedEmpty(file, swcOptions) {
+    static skippedEmpty(file, swcOptions, project) {
         return _transformresponsemodel.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 = _nodepath.default.extname(filePath);
-        const fileName = filePath.replace(new RegExp(`${extName}$`), ".js");
+    static succeeded(file, buildTarget, swcOptions, content, code, project) {
+        const fileName = _mesh.sourceExtensions.outputPath(file.relativePath);
+        const outBaseDir = project?.getOutDir(buildTarget);
+        const outputPath = outBaseDir ? _nodepath.default.join(outBaseDir, fileName) : undefined;
         return _transformresponsemodel.TransformResponse.Success({
             file,
             code,
             sourceContent: content,
             target: buildTarget,
             fileName,
-            config: swcOptions
+            outputDir: outputPath ? _nodepath.default.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 = _transformresponsemodel.TransformResponse.Skipped({
-                file,
-                messages: "File is empty",
-                config: swcOptions,
-                project
-            });
-            onOutput?.(skipped);
-            return skipped;
-        }
-        try {
-            const filePath = file.relativePath;
-            const extName = _nodepath.default.extname(filePath);
-            const fileName = filePath.replace(new RegExp(`${extName}$`), ".js");
-            const outBaseDir = project?.getOutDir(target);
-            const outputPath = outBaseDir ? _nodepath.default.join(outBaseDir, fileName) : undefined;
-            const outputDir = outputPath ? _nodepath.default.dirname(outputPath) : undefined;
-            const transformed = await (0, _core.transform)(content, swcOptions);
-            if (transformed == null) {
-                throw new Error("swc.transform returned no result");
-            }
-            const success = _transformresponsemodel.TransformResponse.Success({
-                file,
-                code: transformed.code,
-                sourceContent: content,
-                target,
-                fileName,
-                outputDir,
-                outputPath,
-                config: swcOptions,
-                project
-            });
-            onOutput?.(success);
-            return success;
-        } catch (error) {
-            const failure = _transformresponsemodel.TransformResponse.Error({
-                file,
-                messages: [
-                    String(error)
-                ],
-                config: swcOptions,
-                project
-            });
-            onOutput?.(failure);
-            return failure;
-        }
-    }
     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)) {
             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/commonjs/src/services/transpile-cache.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "transpileCache", {
+    enumerable: true,
+    get: function() {
+        return transpileCache;
+    }
+});
+const _nodefs = require("node:fs");
+const _nodeos = /*#__PURE__*/ _interop_require_default(require("node:os"));
+const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
+const _core = require("@swc/core");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+/**
+ * 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 _nodepath.default.resolve(env.DECOHERE_CACHE_DIR);
+    }
+    const nodeModules = _nodepath.default.join(rootDir, "node_modules");
+    if ((0, _nodefs.existsSync)(nodeModules)) return _nodepath.default.join(nodeModules, ".cache", "decohere");
+    if (env.XDG_CACHE_HOME != null && env.XDG_CACHE_HOME !== "") {
+        return _nodepath.default.join(env.XDG_CACHE_HOME, "decohere");
+    }
+    return _nodepath.default.join(_nodeos.default.tmpdir(), "decohere");
+}
+const transpileCache = {
+    directory,
+    swcVersion: _core.version
+};