@decohere/flux 0.0.1-dev.126 → 0.0.1-dev.14

package/commonjs/src/slice-serve.js

@@ -1,130 +0,0 @@
-/**
- * Directory-slice helpers for `flux serve <dir>…` — classify workspace packages as
- * Flux apps, Nixpacks-style script deferrals, or libraries to skip.
- */ "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 DEFER_SCRIPT_CANDIDATES () {
-        return DEFER_SCRIPT_CANDIDATES;
-    },
-    get classifySliceProject () {
-        return classifySliceProject;
-    },
-    get classifySliceProjects () {
-        return classifySliceProjects;
-    },
-    get isFluxAppMain () {
-        return isFluxAppMain;
-    },
-    get isFluxOwnedScript () {
-        return isFluxOwnedScript;
-    },
-    get isUnderSlice () {
-        return isUnderSlice;
-    },
-    get normalizeSlicePrefix () {
-        return normalizeSlicePrefix;
-    },
-    get projectsInSlice () {
-        return projectsInSlice;
-    },
-    get projectsInSlices () {
-        return projectsInSlices;
-    },
-    get resolveDeferScript () {
-        return resolveDeferScript;
-    }
-});
-const DEFER_SCRIPT_CANDIDATES = [
-    "dev",
-    "serve"
-];
-function normalizeSlicePrefix(slice) {
-    const trimmed = slice.replaceAll("\\", "/").replace(/\/+$/, "");
-    if (trimmed === "" || trimmed === ".") {
-        throw new Error("Slice directory must be a non-empty path");
-    }
-    if (trimmed === "projects" || trimmed.startsWith("projects/")) {
-        return trimmed;
-    }
-    return `projects/${trimmed}`;
-}
-function isUnderSlice(projectDirectory, slicePrefix) {
-    const dir = projectDirectory.replaceAll("\\", "/").replace(/\/+$/, "");
-    const prefix = slicePrefix.replaceAll("\\", "/").replace(/\/+$/, "");
-    if (dir === prefix || dir.startsWith(`${prefix}/`)) {
-        return true;
-    }
-    // Flat monorepo packages: projects/<module>.<role>
-    return dir.startsWith(`${prefix}.`);
-}
-function projectsInSlice(projects, slice) {
-    const prefix = normalizeSlicePrefix(slice);
-    return projects.filter((p)=>isUnderSlice(p.projectDirectory, prefix));
-}
-function projectsInSlices(projects, slices) {
-    const byName = new Map();
-    for (const slice of slices){
-        for (const project of projectsInSlice(projects, slice)){
-            byName.set(project.name, project);
-        }
-    }
-    return [
-        ...byName.values()
-    ];
-}
-function isFluxOwnedScript(script) {
-    return /\bflux\b/i.test(script);
-}
-function resolveDeferScript(scripts) {
-    for (const name of DEFER_SCRIPT_CANDIDATES){
-        const body = scripts[name];
-        if (body != null && body !== "" && !isFluxOwnedScript(body)) {
-            return name;
-        }
-    }
-    return undefined;
-}
-function isFluxAppMain(main) {
-    const normalized = main.replaceAll("\\", "/");
-    return /(^|\/)main\.tsx?$/.test(normalized);
-}
-function classifySliceProject(project) {
-    if (resolveDeferScript(project.scripts) != null) {
-        return "defer";
-    }
-    if (isFluxAppMain(project.main)) {
-        return "flux";
-    }
-    return "skip";
-}
-function classifySliceProjects(projects, slices) {
-    const tokens = typeof slices === "string" ? [
-        slices
-    ] : [
-        ...slices
-    ];
-    const inSlice = projectsInSlices(projects, tokens);
-    const flux = [];
-    const defer = [];
-    const skip = [];
-    for (const project of inSlice){
-        const kind = classifySliceProject(project);
-        if (kind === "flux") flux.push(project);
-        else if (kind === "defer") defer.push(project);
-        else skip.push(project);
-    }
-    return {
-        flux,
-        defer,
-        skip
-    };
-}

package/commonjs/src/source-module-loader.js

@@ -1,378 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "SourceModuleLoader", {
-    enumerable: true,
-    get: function() {
-        return SourceModuleLoader;
-    }
-});
-const _nodefs = require("node:fs");
-const _nodemodule = require("node:module");
-const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
-const _nodeurl = require("node:url");
-const _decorators = require("@decohere/crucible/decorators");
-const _forge = require("@decohere/forge");
-const _workspace = require("@decohere/workspace");
-const _io = require("@decohere/core/io");
-const _scribe = require("@decohere/scribe");
-const _rewriteservespecifier = require("./rewrite-serve-specifier.js");
-const _staticimports = require("./static-imports.js");
-const _transpilediskcache = require("./transpile-disk-cache.js");
-function _interop_require_default(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-function _getRequireWildcardCache(nodeInterop) {
-    if (typeof WeakMap !== "function") return null;
-    var cacheBabelInterop = new WeakMap();
-    var cacheNodeInterop = new WeakMap();
-    return (_getRequireWildcardCache = function(nodeInterop) {
-        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
-    })(nodeInterop);
-}
-function _interop_require_wildcard(obj, nodeInterop) {
-    if (!nodeInterop && obj && obj.__esModule) {
-        return obj;
-    }
-    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
-        return {
-            default: obj
-        };
-    }
-    var cache = _getRequireWildcardCache(nodeInterop);
-    if (cache && cache.has(obj)) {
-        return cache.get(obj);
-    }
-    var newObj = {
-        __proto__: null
-    };
-    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
-    for(var key in obj){
-        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
-            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
-            if (desc && (desc.get || desc.set)) {
-                Object.defineProperty(newObj, key, desc);
-            } else {
-                newObj[key] = obj[key];
-            }
-        }
-    }
-    newObj.default = obj;
-    if (cache) {
-        cache.set(obj, newObj);
-    }
-    return newObj;
-}
-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;
-}
-class SourceModuleLoader {
-    logger = _scribe.scribe.logger(SourceModuleLoader.name);
-    transpiler = new _forge.SwcTranspiler();
-    disposed = false;
-    hooksRegistered = false;
-    workspace;
-    buildConfig = "debug";
-    fileInfoMap = new Map();
-    transpileCache = new Map();
-    /** Bumped when a file's cached code is dropped, so an up-front compile already running can't put it back. */ transpileVersions = new Map();
-    /** The source files each entry's walk reached, so a reboot only walks out from what changed. */ reachedFrom = new Map();
-    /** Compiled code on disk across runs; null when caching is off. */ diskCache = null;
-    /** Up-front compiles in flight, shared by entries booting at the same time. */ compilingAhead = new Map();
-    /** SWC options per project, built on first use and kept until the next `configure()`. */ swcConfigs = new Map();
-    commonJsConfigs = new Map();
-    aliasPaths = {};
-    aliasBaseUrl = _nodepath.default.resolve(".");
-    versionFileUrl = (fileUrl)=>fileUrl;
-    onResolved;
-    getWorkspace() {
-        return this.workspace;
-    }
-    hasSourceFile(absolutePath) {
-        return this.fileInfoMap.has(absolutePath);
-    }
-    sourceFilePaths() {
-        return this.fileInfoMap.keys();
-    }
-    setSourceFile(absolutePath, project) {
-        this.fileInfoMap.set(absolutePath, {
-            project
-        });
-    }
-    async configure(options) {
-        this.disposed = false;
-        // A new Map, not clear(): an up-front compile from before can't write into this one.
-        this.transpileCache = new Map();
-        this.reachedFrom = new Map();
-        this.swcConfigs.clear();
-        this.commonJsConfigs.clear();
-        this.buildConfig = options.buildConfig;
-        this.workspace = options.workspace ?? await (0, _forge.createWorkspace)();
-        this.versionFileUrl = options.versionFileUrl ?? ((fileUrl)=>fileUrl);
-        this.onResolved = options.onResolved;
-        this.fileInfoMap = await this.buildFileInfoMap(this.buildConfig);
-        this.diskCache = _transpilediskcache.TranspileDiskCache.forWorkspace(this.workspace.rootDir);
-        // In the background; it turns the cache off, with a warning, rather than throw.
-        void this.diskCache?.pruneIfDue();
-        const aliases = this.workspace.getPackageAliases(this.buildConfig);
-        this.aliasBaseUrl = aliases.baseUrl;
-        this.aliasPaths = aliases.paths;
-    }
-    registerHooks() {
-        if (this.hooksRegistered) return;
-        this.hooksRegistered = true;
-        // Compiled code carries inline source maps; Node only applies them to stack traces when
-        // this is on. Without it, errors point at compiled line numbers.
-        process.setSourceMapsEnabled(true);
-        (0, _nodemodule.registerHooks)({
-            resolve: (specifier, context, next)=>{
-                if (this.disposed) return next(specifier, context);
-                const parentUrl = context.parentURL ?? "";
-                const rewritten = (0, _rewriteservespecifier.rewriteServeSpecifier)({
-                    specifier,
-                    parentUrl,
-                    isWatchedTs: (filePath)=>this.fileInfoMap.has(filePath),
-                    resolveBare: (bare)=>_workspace.packageAliases.resolvePath(bare, this.aliasPaths, this.aliasBaseUrl),
-                    versionFileUrl: this.versionFileUrl
-                }) ?? specifier;
-                const result = next(rewritten, context);
-                this.onResolved?.(result, parentUrl);
-                return result;
-            },
-            load: (url, context, next)=>{
-                if (this.disposed) return next(url, context);
-                const result = this.loadTs(url);
-                if (result != null) {
-                    return {
-                        format: result.format,
-                        source: result.source,
-                        shortCircuit: true
-                    };
-                }
-                return next(url, context);
-            }
-        });
-    }
-    async importEntry(absolutePath) {
-        await this.compileAhead(_nodepath.default.resolve(absolutePath));
-        const url = this.versionFileUrl(_io.io.pathToFileUrl(_nodepath.default.resolve(absolutePath)));
-        return Promise.resolve(url).then((p)=>/*#__PURE__*/ _interop_require_wildcard(require(p)));
-    }
-    invalidateTranspile(...absolutePaths) {
-        for (const fullPath of absolutePaths){
-            this.transpileCache.delete(fullPath);
-            this.transpileVersions.set(fullPath, (this.transpileVersions.get(fullPath) ?? 0) + 1);
-        }
-    }
-    dispose() {
-        this.disposed = true;
-        this.transpileCache = new Map();
-        this.reachedFrom = new Map();
-        this.swcConfigs.clear();
-        this.commonJsConfigs.clear();
-        this.fileInfoMap.clear();
-        this.workspace?.[Symbol.dispose]();
-        this.workspace = undefined;
-    }
-    async buildFileInfoMap(buildConfig) {
-        const projects = this.workspace?.getProjects(buildConfig) ?? [];
-        const entries = await Promise.all(projects.map(async (project)=>{
-            const files = await project.getAllFiles();
-            return files.map((file)=>[
-                    file.fullPath,
-                    {
-                        project
-                    }
-                ]);
-        }));
-        return new Map(entries.flat());
-    }
-    /**
-	 * Compiles the entry and the source files it imports, before Node imports it. The load
-	 * hook is synchronous, so it would compile one file at a time on the main thread; async SWC
-	 * runs on the thread pool. Walks out from the entry, compiling each file's imports in parallel,
-	 * so files the app never imports (tests, other apps) are not compiled. A reboot walks out only
-	 * from the files it reached before that are no longer cached (the saved ones), so their new
-	 * imports are found without visiting the rest of the graph again.
-	 *
-	 * A file that fails here is left out of the cache instead of failing the boot: the load hook
-	 * then compiles it again and throws as before, naming the file. The walk is a hint; whatever
-	 * it misses is compiled by the load hook when Node gets to it.
-	 */ async compileAhead(entryPath) {
-        const reached = this.reachedFrom.get(entryPath);
-        const starts = reached == null ? [
-            entryPath
-        ] : [
-            ...reached
-        ].filter((fullPath)=>!this.transpileCache.has(fullPath));
-        const seen = new Set(reached);
-        for (const start of starts)seen.delete(start);
-        const visit = async (fullPath)=>{
-            if (seen.has(fullPath)) return;
-            seen.add(fullPath);
-            const code = await this.compiledAhead(fullPath);
-            if (code == null) return;
-            const parentUrl = (0, _nodeurl.pathToFileURL)(fullPath).toString();
-            await Promise.all(_staticimports.staticImports.scan(code).map((specifier)=>{
-                const target = this.sourcePathOf(specifier, parentUrl);
-                return target == null ? undefined : visit(target);
-            }));
-        };
-        await Promise.all(starts.map(visit));
-        this.reachedFrom.set(entryPath, seen);
-    }
-    /** The file's compiled code, from the cache or compiled now; undefined if it isn't a source. */ compiledAhead(fullPath) {
-        const fileInfo = this.fileInfoMap.get(fullPath);
-        if (fileInfo == null) return Promise.resolve(undefined);
-        const cached = this.transpileCache.get(fullPath);
-        if (cached != null) return Promise.resolve(cached);
-        const inFlight = this.compilingAhead.get(fullPath);
-        if (inFlight != null) return inFlight;
-        const version = this.transpileVersions.get(fullPath);
-        const cache = this.transpileCache;
-        const compiling = this.compileAsync(fullPath, fileInfo.project).then((code)=>{
-            if (code == null) return undefined;
-            // Saved, reconfigured or disposed while compiling: don't cache stale code.
-            const current = !this.disposed && cache === this.transpileCache && version === this.transpileVersions.get(fullPath);
-            if (current) cache.set(fullPath, code);
-            return code;
-        }).finally(()=>this.compilingAhead.delete(fullPath));
-        this.compilingAhead.set(fullPath, compiling);
-        return compiling;
-    }
-    /** The source file a specifier names, mapped the way the resolve hook maps it. */ sourcePathOf(specifier, parentUrl) {
-        const url = (0, _rewriteservespecifier.rewriteServeSpecifier)({
-            specifier,
-            parentUrl,
-            isWatchedTs: (filePath)=>this.fileInfoMap.has(filePath),
-            resolveBare: (bare)=>_workspace.packageAliases.resolvePath(bare, this.aliasPaths, this.aliasBaseUrl),
-            versionFileUrl: (fileUrl)=>fileUrl
-        });
-        return url == null ? null : (0, _nodeurl.fileURLToPath)(url);
-    }
-    loadTs(url) {
-        if (!url.startsWith("file:")) return null;
-        // fileURLToPath, not URL.pathname: decodes %20 and gives Windows paths, so files
-        // whose path has a space still match the workspace's package list.
-        const cleanPath = (0, _nodeurl.fileURLToPath)(url);
-        const fileInfo = this.fileInfoMap.get(cleanPath);
-        if (fileInfo == null) return null;
-        const format = _workspace.sourceExtensions.isCommonJs(cleanPath) ? "commonjs" : "module";
-        const cached = this.transpileCache.get(cleanPath);
-        if (cached != null) return {
-            source: cached,
-            format
-        };
-        const code = this.compileSync(cleanPath, fileInfo.project);
-        this.transpileCache.set(cleanPath, code);
-        return {
-            source: code,
-            format
-        };
-    }
-    /**
-	 * Compiles a file for the load hook, through the disk cache. Throws, naming the file,
-	 * when it can't be read or doesn't compile.
-	 */ compileSync(fullPath, project) {
-        const file = new _io.FileEx({
-            fullPath
-        });
-        const baseConfig = this.swcConfigFor(project, fullPath);
-        let source;
-        try {
-            source = (0, _nodefs.readFileSync)(fullPath, "utf8");
-        } catch (error) {
-            this.logger.error(`Failed to transpile ${fullPath}`, error);
-            throw new Error(`Failed to transpile ${fullPath}`, {
-                cause: error
-            });
-        }
-        const key = this.diskCache?.keyFor(fullPath, source, baseConfig);
-        const hit = key == null ? undefined : this.diskCache?.readSync(key);
-        if (hit != null) return hit;
-        const response = this.transpiler.transformCodeSync(source, file, _forge.BuildTargets.es6, baseConfig);
-        if (response.outcome !== "success") {
-            this.logger.error(`Failed to transpile ${fullPath}`, response);
-            throw new Error(`Failed to transpile ${fullPath}`);
-        }
-        if (key != null) this.diskCache?.writeSync(key, response.code);
-        return response.code;
-    }
-    /**
-	 * Compiles a file ahead, through the disk cache; undefined when it doesn't compile, which the
-	 * load hook then reports (see {@link compileAhead}). The source and the cache entry are read
-	 * synchronously: for small files that is far cheaper than a trip through libuv's thread pool,
-	 * which async SWC needs for the compiles that miss.
-	 */ async compileAsync(fullPath, project) {
-        const file = new _io.FileEx({
-            fullPath
-        });
-        const baseConfig = this.swcConfigFor(project, fullPath);
-        let source;
-        try {
-            source = (0, _nodefs.readFileSync)(fullPath, "utf8");
-        } catch  {
-            // Left to the load hook, which reads it again and fails naming it, as for a file
-            // that doesn't compile.
-            return undefined;
-        }
-        const key = this.diskCache?.keyFor(fullPath, source, baseConfig);
-        const hit = key == null ? undefined : this.diskCache?.readSync(key);
-        if (hit != null) return hit;
-        const response = await this.transpiler.transformCode(source, file, _forge.BuildTargets.es6, baseConfig);
-        if (response.outcome !== "success") return undefined;
-        if (key != null) await this.diskCache?.write(key, response.code);
-        return response.code;
-    }
-    /**
-	 * The project's SWC options, built once: rebuilding them for every file was about a quarter
-	 * of load time. Import specifiers are left as written, without `jsc.paths` or
-	 * `resolveFully`: the resolve hook maps them to source files (aliases, `.js` to `.ts`,
-	 * directory indexes), so SWC does not resolve them a second time against the disk.
-	 */ swcConfigFor(project, fullPath) {
-        const config = this.esModuleConfigFor(project);
-        if (!_workspace.sourceExtensions.isCommonJs(fullPath)) return config;
-        // `.cts` is CommonJS: Node loads it with `require` semantics, so SWC emits CommonJS.
-        // Kept per project, like the ES module options, so the disk cache hashes them once.
-        const cached = this.commonJsConfigs.get(project);
-        if (cached != null) return cached;
-        const commonJs = {
-            ...config,
-            module: {
-                type: "commonjs"
-            }
-        };
-        this.commonJsConfigs.set(project, commonJs);
-        return commonJs;
-    }
-    esModuleConfigFor(project) {
-        const cached = this.swcConfigs.get(project);
-        if (cached != null) return cached;
-        const base = this.transpiler.createBaseConfig(_forge.BuildTargets.es6, {
-            tsConfig: project.getTsConfigSync(),
-            userConfig: project.getSwcConfigSync(),
-            aliasPaths: false,
-            workspace: this.workspace
-        });
-        // `module` is the ES module config (`type: "es6"` above); the spread loses the narrowing.
-        const module = {
-            ...base.module,
-            resolveFully: false
-        };
-        const config = {
-            ...base,
-            module
-        };
-        this.swcConfigs.set(project, config);
-        return config;
-    }
-}
-SourceModuleLoader = _ts_decorate([
-    (0, _decorators.injectable)()
-], SourceModuleLoader);

package/commonjs/src/static-imports.js

@@ -1,37 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "staticImports", {
-    enumerable: true,
-    get: function() {
-        return staticImports;
-    }
-});
-/**
- * The module specifiers a compiled ES module names in `import … from`, `export … from`, bare
- * `import "x"` and literal `import("x")`.
- *
- * Only a hint for compiling ahead: a specifier it misses is compiled when Node loads it,
- * and one it finds by mistake (an import written inside a string) costs one extra compile. So a
- * scan of SWC's output is enough; it never decides what runs.
- */ const STATIC = /\b(?:import|export)\s*(?:[\w$*{},\s]+?\s*from\s*)?["']([^"'\n]+)["']/g;
-const DYNAMIC = /\bimport\s*\(\s*["']([^"'\n]+)["']\s*\)/g;
-function scan(code) {
-    const found = new Set();
-    for (const pattern of [
-        STATIC,
-        DYNAMIC
-    ]){
-        for (const match of code.matchAll(pattern)){
-            const specifier = match[1];
-            if (specifier != null) found.add(specifier);
-        }
-    }
-    return [
-        ...found
-    ];
-}
-const staticImports = {
-    scan
-};

package/commonjs/src/transpile-disk-cache.js

@@ -1,148 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "TranspileDiskCache", {
-    enumerable: true,
-    get: function() {
-        return TranspileDiskCache;
-    }
-});
-const _nodecrypto = require("node:crypto");
-const _nodefs = /*#__PURE__*/ _interop_require_default(require("node:fs"));
-const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
-const _forge = require("@decohere/forge");
-const _scribe = require("@decohere/scribe");
-function _interop_require_default(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-/** Bump when what flux stores changes, so older entries stop matching. */ const FORMAT = 1;
-/** Entries untouched for this long are pruned. */ const MAX_AGE_MS = 30 * 24 * 60 * 60 * 1000;
-/** Pruning runs at most this often, recorded by the mtime of a marker file. */ const PRUNE_EVERY_MS = 24 * 60 * 60 * 1000;
-const PRUNE_MARKER = ".last-prune";
-class TranspileDiskCache {
-    dir;
-    logger = _scribe.scribe.logger(TranspileDiskCache.name);
-    disabled = false;
-    constructor(dir){
-        this.dir = dir;
-    }
-    /** The cache for a workspace, or null when caching is off (`DECOHERE_CACHE=0`). */ static forWorkspace(rootDir) {
-        const base = _forge.transpileCache.directory(rootDir);
-        return base == null ? null : new TranspileDiskCache(_nodepath.default.join(base, "flux"));
-    }
-    get directory() {
-        return this.dir;
-    }
-    /**
-	 * The key for a file compiled with `baseOptions`: the per-file options are those plus the
-	 * file's path (forge's `createFileConfig`), so hashing the base once per project and adding
-	 * the path covers them without serialising options for every file.
-	 */ keyFor(fullPath, source, baseOptions) {
-        return (0, _nodecrypto.createHash)("sha256").update(`${FORMAT}\0${_forge.transpileCache.swcVersion}\0${this.optionsHash(baseOptions)}\0`).update(`${fullPath}\0`).update(source).digest("hex");
-    }
-    optionsHashes = new WeakMap();
-    optionsHash(options) {
-        const cached = this.optionsHashes.get(options);
-        if (cached != null) return cached;
-        const hash = (0, _nodecrypto.createHash)("sha256").update(JSON.stringify(options)).digest("hex");
-        this.optionsHashes.set(options, hash);
-        return hash;
-    }
-    readSync(key) {
-        if (this.disabled) return undefined;
-        try {
-            return _nodefs.default.readFileSync(this.entryPath(key), "utf8");
-        } catch (error) {
-            return this.missOrDisable(error);
-        }
-    }
-    async read(key) {
-        if (this.disabled) return undefined;
-        try {
-            return await _nodefs.default.promises.readFile(this.entryPath(key), "utf8");
-        } catch (error) {
-            return this.missOrDisable(error);
-        }
-    }
-    writeSync(key, code) {
-        if (this.disabled) return;
-        const file = this.entryPath(key);
-        const temp = this.tempPath(file);
-        try {
-            _nodefs.default.mkdirSync(_nodepath.default.dirname(file), {
-                recursive: true
-            });
-            _nodefs.default.writeFileSync(temp, code);
-            _nodefs.default.renameSync(temp, file);
-        } catch (error) {
-            this.disable("write", error);
-        }
-    }
-    async write(key, code) {
-        if (this.disabled) return;
-        const file = this.entryPath(key);
-        const temp = this.tempPath(file);
-        try {
-            await _nodefs.default.promises.mkdir(_nodepath.default.dirname(file), {
-                recursive: true
-            });
-            await _nodefs.default.promises.writeFile(temp, code);
-            await _nodefs.default.promises.rename(temp, file);
-        } catch (error) {
-            this.disable("write", error);
-        }
-    }
-    /** Deletes entries older than 30 days, if it hasn't done so in the last day. */ async pruneIfDue(now = Date.now()) {
-        if (this.disabled) return;
-        const marker = _nodepath.default.join(this.dir, PRUNE_MARKER);
-        try {
-            const last = await _nodefs.default.promises.stat(marker).then((stat)=>stat.mtimeMs, (error)=>{
-                if (error.code === "ENOENT") return 0;
-                throw error;
-            });
-            if (now - last < PRUNE_EVERY_MS) return;
-            await _nodefs.default.promises.mkdir(this.dir, {
-                recursive: true
-            });
-            await _nodefs.default.promises.writeFile(marker, "");
-            for (const shard of (await _nodefs.default.promises.readdir(this.dir, {
-                withFileTypes: true
-            }))){
-                if (!shard.isDirectory()) continue;
-                const shardDir = _nodepath.default.join(this.dir, shard.name);
-                for (const entry of (await _nodefs.default.promises.readdir(shardDir))){
-                    // Old entries, and temp files a crashed process left mid-write.
-                    const file = _nodepath.default.join(shardDir, entry);
-                    const mtime = await _nodefs.default.promises.stat(file).then((stat)=>stat.mtimeMs, (error)=>{
-                        // Renamed or removed by another process since the listing: nothing to prune.
-                        if (error.code === "ENOENT") return undefined;
-                        throw error;
-                    });
-                    if (mtime != null && now - mtime > MAX_AGE_MS) await _nodefs.default.promises.rm(file, {
-                        force: true
-                    });
-                }
-            }
-        } catch (error) {
-            this.disable("prune", error);
-        }
-    }
-    entryPath(key) {
-        return _nodepath.default.join(this.dir, key.slice(0, 2), `${key}.js`);
-    }
-    tempPath(file) {
-        return `${file}.${process.pid}.${(0, _nodecrypto.randomBytes)(4).toString("hex")}.tmp`;
-    }
-    /** A missing entry is a miss; any other read error turns the cache off. */ missOrDisable(error) {
-        if (error.code !== "ENOENT") this.disable("read", error);
-        return undefined;
-    }
-    disable(operation, error) {
-        if (this.disabled) return;
-        this.disabled = true;
-        this.logger.warn(`Transpile cache turned off for this run: could not ${operation} ${this.dir} (${String(error)}). ` + "Flux compiles without it. Set DECOHERE_CACHE_DIR to a writable directory, or DECOHERE_CACHE=0 to silence this.");
-    }
-}