@decohere/flux 0.0.1-dev.11 → 0.0.1-dev.111

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

@@ -0,0 +1,311 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "SourceModuleLoader", {
+    enumerable: true,
+    get: function() {
+        return SourceModuleLoader;
+    }
+});
+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 _mesh = require("@decohere/mesh");
+const _io = require("@decohere/nexus/io");
+const _scribe = require("@decohere/scribe");
+const _rewriteservespecifier = require("./rewrite-serve-specifier.js");
+const _staticimports = require("./static-imports.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();
+    /** 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();
+    aliasPaths = {};
+    aliasBaseUrl = _nodepath.default.resolve(".");
+    versionFileUrl = (fileUrl)=>fileUrl;
+    onResolved;
+    getWorkspace() {
+        return this.workspace;
+    }
+    getBuildConfig() {
+        return this.buildConfig;
+    }
+    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.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);
+        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 (#506).
+        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)=>_mesh.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: "module",
+                        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);
+            this.transpiler.invalidateContentCache(new _io.FileEx({
+                fullPath
+            }));
+        }
+    }
+    dispose() {
+        this.disposed = true;
+        this.transpileCache = new Map();
+        this.reachedFrom = new Map();
+        this.swcConfigs.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 (#661). 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.transpiler.transformFileAsync(new _io.FileEx({
+            fullPath
+        }), _forge.BuildTargets.es6, {}, this.swcConfigFor(fileInfo.project)).then((response)=>{
+            if (response.outcome !== "success") 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, response.code);
+            return response.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)=>_mesh.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 Mesh's list (#511).
+        const cleanPath = (0, _nodeurl.fileURLToPath)(url);
+        const fileInfo = this.fileInfoMap.get(cleanPath);
+        if (fileInfo == null) return null;
+        const cached = this.transpileCache.get(cleanPath);
+        if (cached != null) return {
+            source: cached
+        };
+        const file = new _io.FileEx({
+            fullPath: cleanPath
+        });
+        const response = this.transpiler.transformFileSync(file, _forge.BuildTargets.es6, {}, this.swcConfigFor(fileInfo.project));
+        if (response.outcome !== "success") {
+            this.logger.error(`Failed to transpile ${cleanPath}`, response);
+            throw new Error(`Failed to transpile ${cleanPath}`);
+        }
+        this.transpileCache.set(cleanPath, response.code);
+        return {
+            source: response.code
+        };
+    }
+    /**
+	 * The project's SWC options, built once: rebuilding them for every file was about a quarter
+	 * of load time (#513). 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) {
+        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

@@ -0,0 +1,37 @@
+"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 (#661): 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/es6/src/deferred-script-runner.js

@@ -0,0 +1,46 @@
+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;
+}
+import { spawn } from "node:child_process";
+import { injectable } from "@decohere/crucible/decorators";
+import { detectPackageManager, packageManagerFromString } from "@decohere/nexus/interop";
+import { scribe } from "@decohere/scribe";
+export class DeferredScriptRunner {
+    logger = scribe.logger(DeferredScriptRunner.name);
+    children = [];
+    start(options) {
+        const pm = detectPackageManager(options.workspaceRoot) ?? packageManagerFromString("pnpm");
+        this.logger.info(`deferred ${options.label} — running ${pm.name} run ${options.script} in ${options.cwd}`);
+        const child = spawn(pm.name, [
+            "run",
+            options.script
+        ], {
+            cwd: options.cwd,
+            stdio: "inherit",
+            env: process.env,
+            shell: false
+        });
+        child.on("exit", (code, signal)=>{
+            if (signal) return;
+            if (code != null && code !== 0) {
+                this.logger.warn(`deferred ${options.label} exited with ${code}`);
+            }
+        });
+        this.children.push(child);
+        return child;
+    }
+    async [Symbol.asyncDispose]() {
+        for (const child of this.children){
+            if (!child.killed) {
+                child.kill("SIGTERM");
+            }
+        }
+        this.children.length = 0;
+    }
+}
+DeferredScriptRunner = _ts_decorate([
+    injectable()
+], DeferredScriptRunner);

package/es6/src/flux.command.js

@@ -1,4 +1,5 @@
 import { DecohereCommand } from "@decohere/nexus/cli";
+import { RunCommand } from "./run.command.js";
 import { ServeCommand } from "./serve.command.js";
 export class FluxCommand extends DecohereCommand {
     constructor(commands, handler){
@@ -6,6 +7,7 @@ export class FluxCommand extends DecohereCommand {
         this.exitOverride();
         this.registerSubcommand({
             serve: ServeCommand,
+            run: RunCommand,
             ...commands
         }, handler);
     }
@@ -13,5 +15,3 @@ export class FluxCommand extends DecohereCommand {
         return this.help();
     }
 }
-
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL2ZsdXgvc3JjL2ZsdXguY29tbWFuZC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IEFjdGlvbnMgfSBmcm9tIFwiQGRlY29oZXJlL25leHVzL2NsaVwiO1xuaW1wb3J0IHtcblx0dHlwZSBDb21tYW5kSGFuZGxlcixcblx0dHlwZSBDb21tYW5kUmVzcG9uc2UsXG5cdHR5cGUgQ29tbWFuZFR5cGUsXG5cdERlY29oZXJlQ29tbWFuZCxcbn0gZnJvbSBcIkBkZWNvaGVyZS9uZXh1cy9jbGlcIjtcbmltcG9ydCB7IFNlcnZlQ29tbWFuZCB9IGZyb20gXCIuL3NlcnZlLmNvbW1hbmQuanNcIjtcblxuZXhwb3J0IGNsYXNzIEZsdXhDb21tYW5kIGV4dGVuZHMgRGVjb2hlcmVDb21tYW5kIHtcblx0cHVibGljIGNvbnN0cnVjdG9yKGNvbW1hbmRzOiBSZWNvcmQ8c3RyaW5nLCBDb21tYW5kVHlwZT4sIGhhbmRsZXI6IENvbW1hbmRIYW5kbGVyKSB7XG5cdFx0c3VwZXIoRmx1eENvbW1hbmQpO1xuXHRcdHRoaXMuZXhpdE92ZXJyaWRlKCk7XG5cdFx0dGhpcy5yZWdpc3RlclN1YmNvbW1hbmQoeyBzZXJ2ZTogU2VydmVDb21tYW5kLCAuLi5jb21tYW5kcyB9LCBoYW5kbGVyKTtcblx0fVxuXG5cdHB1YmxpYyBydW4oX2FjdGlvbnM6IEFjdGlvbnMsIF9vcHRpb25zOiBuZXZlcik6IFByb21pc2U8Q29tbWFuZFJlc3BvbnNlPiB7XG5cdFx0cmV0dXJuIHRoaXMuaGVscCgpO1xuXHR9XG59XG4iXSwibmFtZXMiOlsiRGVjb2hlcmVDb21tYW5kIiwiU2VydmVDb21tYW5kIiwiRmx1eENvbW1hbmQiLCJjb21tYW5kcyIsImhhbmRsZXIiLCJleGl0T3ZlcnJpZGUiLCJyZWdpc3RlclN1YmNvbW1hbmQiLCJzZXJ2ZSIsInJ1biIsIl9hY3Rpb25zIiwiX29wdGlvbnMiLCJoZWxwIl0sIm1hcHBpbmdzIjoiQUFDQSxTQUlDQSxlQUFlLFFBQ1Qsc0JBQXNCO0FBQzdCLFNBQVNDLFlBQVksUUFBUSxxQkFBcUI7QUFFbEQsT0FBTyxNQUFNQyxvQkFBb0JGO0lBQ2hDLFlBQW1CRyxRQUFxQyxFQUFFQyxPQUF1QixDQUFFO1FBQ2xGLEtBQUssQ0FBQ0Y7UUFDTixJQUFJLENBQUNHLFlBQVk7UUFDakIsSUFBSSxDQUFDQyxrQkFBa0IsQ0FBQztZQUFFQyxPQUFPTjtZQUFjLEdBQUdFLFFBQVE7UUFBQyxHQUFHQztJQUMvRDtJQUVPSSxJQUFJQyxRQUFpQixFQUFFQyxRQUFlLEVBQTRCO1FBQ3hFLE9BQU8sSUFBSSxDQUFDQyxJQUFJO0lBQ2pCO0FBQ0QifQ==

package/es6/src/flux.js

@@ -0,0 +1,41 @@
+import path from "node:path";
+import { HotReloadServer } from "./hot-reload-server.js";
+import { SourceModuleLoader } from "./source-module-loader.js";
+/** Process-level one-shot loader so a second `run()` reconfigures instead of stacking hooks. */ const runLoader = new SourceModuleLoader();
+async function run(entry, options = {}) {
+    const trimmed = entry.trim();
+    if (trimmed == null || trimmed === "") {
+        throw new Error("flux.run requires an entry file path");
+    }
+    const absoluteEntry = path.resolve(trimmed);
+    await runLoader.configure({
+        workspace: options.workspace,
+        buildConfig: options.configuration ?? "debug"
+    });
+    runLoader.registerHooks();
+    process.argv = [
+        process.execPath,
+        absoluteEntry,
+        ...options.args ?? []
+    ];
+    return runLoader.importEntry(absoluteEntry);
+}
+async function serve(options = {}) {
+    const server = new HotReloadServer();
+    await server.start({
+        buildConfig: options.configuration ?? "debug",
+        project: options.project,
+        projects: options.projects,
+        workspace: options.workspace,
+        rebootDebounceMs: options.rebootDebounceMs
+    });
+    return server;
+}
+function dispose() {
+    runLoader.dispose();
+}
+export const flux = {
+    run,
+    serve,
+    dispose
+};

package/es6/src/flux.module.js

@@ -1,22 +1,23 @@
-import { WorkspaceFactory } from "@decohere/mesh";
+import { createWorkspace } from "@decohere/forge";
 import { ModuleManifest } from "@decohere/nexus/cli";
+import { DeferredScriptRunner } from "./deferred-script-runner.js";
 import { FluxCommand } from "./flux.command.js";
 import { HotReloadServer } from "./hot-reload-server.js";
+import { RunAction } from "./run.action.js";
 import { ServeAction } from "./serve.action.js";
 export class FluxModule extends ModuleManifest {
     id = "flux";
     command = FluxCommand;
     actions = {
-        serve: ServeAction
+        serve: ServeAction,
+        run: RunAction
     };
     registerServices(builder) {
         builder.registerSingleton(HotReloadServer);
+        builder.registerSingleton(DeferredScriptRunner);
     }
     createWorkspace(options) {
-        return WorkspaceFactory.create({
-            configFile: options.configFile
-        });
+        // Same workspace as `flux.run` / `flux.serve` and forge (#516).
+        return createWorkspace(options);
     }
 }
-
-//# sourceMappingURL=data:application/json;base64,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