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

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

@@ -1,237 +0,0 @@
-"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");
-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();
-    /** 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;
-        this.transpileCache.clear();
-        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) {
-        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.transpiler.invalidateContentCache(new _io.FileEx({
-                fullPath
-            }));
-        }
-    }
-    dispose() {
-        this.disposed = true;
-        this.transpileCache.clear();
-        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());
-    }
-    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/es6/bench/load.bench.js

@@ -1,136 +0,0 @@
-/**
- * Cold-load benchmark for flux: how long the load hook takes to compile and import a workspace
- * whose files import each other, the way an app's do (#513).
- *
- *   pnpm bench:flux                        # 8 libraries × 40 files, 10 processes
- *   BENCH_LIBS=4 BENCH_FILES=100 BENCH_RUNS=5 pnpm bench:flux
- *
- * Generates the workspace in a temp directory: each library re-exports a `models/` directory
- * through its index (a directory import), each model imports the previous one (relative, with
- * `.js`) and the previous library by package name, and has a decorated class. Each process
- * imports the last library twice under different URL versions with a fresh loader cache, so
- * both loads transpile every file: the first is a real cold start, the second runs with Node
- * and SWC warmed up. Prints the median of each and the time per file.
- */ import { spawnSync } from "node:child_process";
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { createWorkspace } from "@decohere/forge";
-import { SourceModuleLoader } from "../src/source-module-loader.js";
-const libs = Number(process.env.BENCH_LIBS ?? 8);
-const filesPerLib = Number(process.env.BENCH_FILES ?? 40);
-const runs = Number(process.env.BENCH_RUNS ?? 10);
-function write(file, content) {
-    mkdirSync(path.dirname(file), {
-        recursive: true
-    });
-    writeFileSync(file, content);
-}
-function generate(root) {
-    write(path.join(root, "package.json"), JSON.stringify({
-        name: "flux-bench",
-        type: "module"
-    }));
-    write(path.join(root, "tsconfig.json"), JSON.stringify({
-        compilerOptions: {
-            experimentalDecorators: true
-        }
-    }));
-    for(let lib = 0; lib < libs; lib++){
-        const dir = path.join(root, "projects", `lib-${lib}`);
-        write(path.join(dir, "package.json"), JSON.stringify({
-            name: `@bench/lib-${lib}`,
-            type: "module",
-            main: "src/index.ts"
-        }));
-        const previousLib = lib > 0 ? `@bench/lib-${lib - 1}` : null;
-        write(path.join(dir, "src/index.ts"), `export * from "./models";\n`);
-        const exports = [];
-        for(let file = 0; file < filesPerLib; file++){
-            const name = `Model${lib}x${file}`;
-            const previous = file > 0 ? `Model${lib}x${file - 1}` : null;
-            write(path.join(dir, "src/models", `model-${file}.ts`), [
-                previous ? `import { ${previous} } from "./model-${file - 1}.js";` : "",
-                previousLib && file === 0 ? `import { Model${lib - 1}x0 } from "${previousLib}";` : "",
-                `const tag = (_target: unknown) => {};`,
-                `@tag`,
-                `export class ${name} {`,
-                `\tpublic readonly id: number = ${file};`,
-                `\tpublic constructor(public readonly label: string = "${name}") {}`,
-                `\tpublic describe(): string { return \`\${this.label}:\${this.id}\`; }`,
-                previous ? `\tpublic previous = ${previous};` : "",
-                previousLib && file === 0 ? `\tpublic upstream = Model${lib - 1}x0;` : "",
-                `}`
-            ].filter(Boolean).join("\n"));
-            exports.push(`export * from "./model-${file}.js";`);
-        }
-        write(path.join(dir, "src/models/index.ts"), `${exports.join("\n")}\n`);
-    }
-    return path.join(root, "projects", `lib-${libs - 1}`, "src/index.ts");
-}
-/** One sample, in this process: the first load (cold) and a second one (warm Node and SWC). */ async function sample() {
-    const root = mkdtempSync(path.join(tmpdir(), "flux-bench-"));
-    try {
-        const entry = generate(root);
-        const workspace = await createWorkspace({
-            rootDir: root
-        });
-        const loader = new SourceModuleLoader();
-        const load = async (version)=>{
-            const started = performance.now();
-            await loader.configure({
-                buildConfig: "debug",
-                workspace,
-                versionFileUrl: (fileUrl)=>`${fileUrl}?v=${version}`
-            });
-            loader.registerHooks();
-            await loader.importEntry(entry);
-            return performance.now() - started;
-        };
-        const cold = await load(1);
-        const warm = await load(2);
-        return {
-            files: [
-                ...loader.sourceFilePaths()
-            ].length,
-            cold,
-            warm
-        };
-    } finally{
-        rmSync(root, {
-            recursive: true,
-            force: true
-        });
-    }
-}
-const median = (values)=>[
-        ...values
-    ].sort((a, b)=>a - b)[Math.floor(values.length / 2)] ?? 0;
-if (process.argv.includes("--sample")) {
-    console.log(JSON.stringify(await sample()));
-} else {
-    // Each sample runs in a fresh process: Node never unloads modules, so loads in one process
-    // slow down as the heap grows and the numbers drift.
-    const results = Array.from({
-        length: runs
-    }, ()=>{
-        const child = spawnSync(process.execPath, [
-            ...process.execArgv,
-            fileURLToPath(import.meta.url),
-            "--sample"
-        ], {
-            encoding: "utf8",
-            env: process.env
-        });
-        if (child.status !== 0) throw new Error(`sample failed:\n${child.stderr}`);
-        const last = child.stdout.trim().split("\n").at(-1) ?? "";
-        return JSON.parse(last);
-    });
-    const files = results[0]?.files ?? 0;
-    const report = (label, values)=>{
-        const ms = median(values);
-        return `${label} ${ms.toFixed(1)} ms (${(ms / files * 1000).toFixed(0)} µs/file)`;
-    };
-    console.log(`flux load, ${files} files, median of ${runs} processes: ` + `${report("first", results.map((r)=>r.cold))}, ` + `${report("second", results.map((r)=>r.warm))}`);
-}

package/es6/src/deferred-script-runner.js

@@ -1,46 +0,0 @@
-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.js

@@ -1,41 +0,0 @@
-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/rewrite-serve-specifier.js

@@ -1,49 +0,0 @@
-import path from "node:path";
-import { fileURLToPath, pathToFileURL } from "node:url";
-import { packageAliases } from "@decohere/mesh";
-/**
- * Map a resolve-hook specifier to a versioned watched `.ts` file URL.
- * Covers relative `.js` / `.ts` / extensionless imports, directory imports (`./models` is
- * `./models/index.ts`), and bare workspace package names and subpaths. Flux compiles without
- * SWC's own path resolution, so this is the only place imports are mapped to sources (#513).
- */ export function rewriteServeSpecifier(options) {
-    const { specifier, parentUrl, isWatchedTs, resolveBare, versionFileUrl } = options;
-    const relativeTs = resolveRelativeWatchedTs(specifier, parentUrl, isWatchedTs);
-    if (relativeTs != null) {
-        return versionFileUrl(pathToFileURL(relativeTs).toString());
-    }
-    const bareTarget = resolveBare(specifier);
-    const bareTs = bareTarget == null ? null : watchedTs(bareTarget, isWatchedTs);
-    if (bareTs != null) {
-        return versionFileUrl(pathToFileURL(bareTs).toString());
-    }
-    return null;
-}
-/**
- * The watched `.ts` file a path names: itself (with `.js` read as `.ts`, or `.ts` added), else
- * the `index.ts` of the directory it names. A file wins over a directory of the same name.
- */ function watchedTs(filePath, isWatchedTs) {
-    const withoutSlash = filePath.replace(/[/\\]+$/, "");
-    const stem = withoutSlash.replace(/\.(js|ts)$/, "");
-    // From the stem: Mesh's alias lookup has already added `.ts` to a subpath that names a
-    // directory (`@lib/models` arrives as `…/models.ts`).
-    const candidates = [
-        `${stem}.ts`,
-        path.join(stem, "index.ts")
-    ];
-    return candidates.find((candidate)=>isWatchedTs(candidate)) ?? null;
-}
-function resolveRelativeWatchedTs(specifier, parentUrl, isWatchedTs) {
-    if (packageAliases.isBareSpecifier(specifier)) return null;
-    if (!(specifier.startsWith(".") || specifier.startsWith("/"))) return null;
-    const parentClean = parentUrl.split("?")[0];
-    if (parentClean == null || parentClean === "") return null;
-    let resolved;
-    try {
-        resolved = new URL(specifier, parentClean);
-    } catch  {
-        return null;
-    }
-    if (resolved.protocol !== "file:") return null;
-    return watchedTs(fileURLToPath(resolved), isWatchedTs);
-}

package/es6/src/run.action.js

@@ -1,37 +0,0 @@
-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 { injectable } from "@decohere/crucible/decorators";
-import { Workspace } from "@decohere/mesh";
-import { ActionResponse } from "@decohere/nexus/cli";
-import { scribe } from "@decohere/scribe";
-import { flux } from "./flux.js";
-export class RunAction {
-    workspace;
-    logger = scribe.logger(RunAction.name);
-    constructor(workspace){
-        this.workspace = workspace;
-    }
-    async run(options) {
-        this.logger.trace(`Running ${options.entry}`);
-        await flux.run(options.entry, {
-            configuration: options.configuration,
-            args: options.args,
-            workspace: this.workspace
-        });
-        return ActionResponse.Success(RunAction.name);
-    }
-}
-RunAction = _ts_decorate([
-    injectable(),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof Workspace === "undefined" ? Object : Workspace
-    ])
-], RunAction);

package/es6/src/run.command.js

@@ -1,55 +0,0 @@
-import { ConfigurationOption, DecohereCommand } from "@decohere/nexus/cli";
-import { RunAction } from "./run.action.js";
-export class RunCommand extends DecohereCommand {
-    get actions() {
-        return [
-            RunAction
-        ];
-    }
-    constructor(name){
-        super(name);
-        this.description("Compile and run a TypeScript entry on the fly (no watch / HMR)");
-        this.argument("<entry>", "Path to the TypeScript entry file");
-        this.argument("[args...]", "Arguments forwarded to the entry after rewriting argv");
-        this.addOption(new ConfigurationOption("debug"));
-    }
-    /**
-	 * Commander passes positionals before options when `<entry> [args...]` is declared.
-	 * The CLI host ModuleFactory expects `(opts, cmd)` — normalize and stash entry/args on opts.
-	 */ action(fn) {
-        return super.action((...args)=>{
-            const cmd = args.at(-1);
-            const opts = args.at(-2);
-            const { entry, entryArgs } = normalizeRunPositionals(args.slice(0, -2));
-            cmd.setOptionValue("entry", entry);
-            cmd.setOptionValue("args", entryArgs);
-            return fn(opts, cmd);
-        });
-    }
-}
-/** Commander yields `[entry, args[]]` or sometimes a flat list depending on arity. */ function normalizeRunPositionals(positionals) {
-    if (positionals.length === 0) {
-        return {
-            entry: "",
-            entryArgs: []
-        };
-    }
-    const first = positionals[0];
-    if (typeof first !== "string" || first === "") {
-        return {
-            entry: "",
-            entryArgs: []
-        };
-    }
-    const second = positionals[1];
-    if (Array.isArray(second)) {
-        return {
-            entry: first,
-            entryArgs: second.filter((s)=>typeof s === "string")
-        };
-    }
-    return {
-        entry: first,
-        entryArgs: positionals.slice(1).filter((s)=>typeof s === "string" && s !== "")
-    };
-}