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

package/commonjs/bench/load.bench.js

@@ -1,145 +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.
- */ "use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-const _nodechild_process = require("node:child_process");
-const _nodefs = require("node:fs");
-const _nodeos = require("node:os");
-const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
-const _nodeurl = require("node:url");
-const _forge = require("@decohere/forge");
-const _sourcemoduleloader = require("../src/source-module-loader.js");
-function _interop_require_default(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-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) {
-    (0, _nodefs.mkdirSync)(_nodepath.default.dirname(file), {
-        recursive: true
-    });
-    (0, _nodefs.writeFileSync)(file, content);
-}
-function generate(root) {
-    write(_nodepath.default.join(root, "package.json"), JSON.stringify({
-        name: "flux-bench",
-        type: "module"
-    }));
-    write(_nodepath.default.join(root, "tsconfig.json"), JSON.stringify({
-        compilerOptions: {
-            experimentalDecorators: true
-        }
-    }));
-    for(let lib = 0; lib < libs; lib++){
-        const dir = _nodepath.default.join(root, "projects", `lib-${lib}`);
-        write(_nodepath.default.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(_nodepath.default.join(dir, "src/index.ts"), `export * from "./models";\n`);
-        const exports1 = [];
-        for(let file = 0; file < filesPerLib; file++){
-            const name = `Model${lib}x${file}`;
-            const previous = file > 0 ? `Model${lib}x${file - 1}` : null;
-            write(_nodepath.default.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"));
-            exports1.push(`export * from "./model-${file}.js";`);
-        }
-        write(_nodepath.default.join(dir, "src/models/index.ts"), `${exports1.join("\n")}\n`);
-    }
-    return _nodepath.default.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 = (0, _nodefs.mkdtempSync)(_nodepath.default.join((0, _nodeos.tmpdir)(), "flux-bench-"));
-    try {
-        const entry = generate(root);
-        const workspace = await (0, _forge.createWorkspace)({
-            rootDir: root
-        });
-        const loader = new _sourcemoduleloader.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{
-        (0, _nodefs.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 = (0, _nodechild_process.spawnSync)(process.execPath, [
-            ...process.execArgv,
-            (0, _nodeurl.fileURLToPath)(require("url").pathToFileURL(__filename).toString()),
-            "--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/commonjs/src/deferred-script-runner.js

@@ -1,56 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "DeferredScriptRunner", {
-    enumerable: true,
-    get: function() {
-        return DeferredScriptRunner;
-    }
-});
-const _nodechild_process = require("node:child_process");
-const _decorators = require("@decohere/crucible/decorators");
-const _interop = require("@decohere/nexus/interop");
-const _scribe = require("@decohere/scribe");
-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 DeferredScriptRunner {
-    logger = _scribe.scribe.logger(DeferredScriptRunner.name);
-    children = [];
-    start(options) {
-        const pm = (0, _interop.detectPackageManager)(options.workspaceRoot) ?? (0, _interop.packageManagerFromString)("pnpm");
-        this.logger.info(`deferred ${options.label} — running ${pm.name} run ${options.script} in ${options.cwd}`);
-        const child = (0, _nodechild_process.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([
-    (0, _decorators.injectable)()
-], DeferredScriptRunner);

package/commonjs/src/flux.js

@@ -1,56 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "flux", {
-    enumerable: true,
-    get: function() {
-        return flux;
-    }
-});
-const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
-const _hotreloadserver = require("./hot-reload-server.js");
-const _sourcemoduleloader = require("./source-module-loader.js");
-function _interop_require_default(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-/** Process-level one-shot loader so a second `run()` reconfigures instead of stacking hooks. */ const runLoader = new _sourcemoduleloader.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 = _nodepath.default.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.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();
-}
-const flux = {
-    run,
-    serve,
-    dispose
-};

package/commonjs/src/rewrite-serve-specifier.js

@@ -1,59 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "rewriteServeSpecifier", {
-    enumerable: true,
-    get: function() {
-        return rewriteServeSpecifier;
-    }
-});
-const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
-const _nodeurl = require("node:url");
-const _mesh = require("@decohere/mesh");
-function _interop_require_default(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-function rewriteServeSpecifier(options) {
-    const { specifier, parentUrl, isWatchedTs, resolveBare, versionFileUrl } = options;
-    const relativeTs = resolveRelativeWatchedTs(specifier, parentUrl, isWatchedTs);
-    if (relativeTs != null) {
-        return versionFileUrl((0, _nodeurl.pathToFileURL)(relativeTs).toString());
-    }
-    const bareTarget = resolveBare(specifier);
-    const bareTs = bareTarget == null ? null : watchedTs(bareTarget, isWatchedTs);
-    if (bareTs != null) {
-        return versionFileUrl((0, _nodeurl.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`,
-        _nodepath.default.join(stem, "index.ts")
-    ];
-    return candidates.find((candidate)=>isWatchedTs(candidate)) ?? null;
-}
-function resolveRelativeWatchedTs(specifier, parentUrl, isWatchedTs) {
-    if (_mesh.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((0, _nodeurl.fileURLToPath)(resolved), isWatchedTs);
-}

package/commonjs/src/run.action.js

@@ -1,47 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "RunAction", {
-    enumerable: true,
-    get: function() {
-        return RunAction;
-    }
-});
-const _decorators = require("@decohere/crucible/decorators");
-const _mesh = require("@decohere/mesh");
-const _cli = require("@decohere/nexus/cli");
-const _scribe = require("@decohere/scribe");
-const _flux = require("./flux.js");
-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);
-}
-class RunAction {
-    workspace;
-    logger = _scribe.scribe.logger(RunAction.name);
-    constructor(workspace){
-        this.workspace = workspace;
-    }
-    async run(options) {
-        this.logger.trace(`Running ${options.entry}`);
-        await _flux.flux.run(options.entry, {
-            configuration: options.configuration,
-            args: options.args,
-            workspace: this.workspace
-        });
-        return _cli.ActionResponse.Success(RunAction.name);
-    }
-}
-RunAction = _ts_decorate([
-    (0, _decorators.injectable)(),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof _mesh.Workspace === "undefined" ? Object : _mesh.Workspace
-    ])
-], RunAction);

package/commonjs/src/run.command.js

@@ -1,65 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "RunCommand", {
-    enumerable: true,
-    get: function() {
-        return RunCommand;
-    }
-});
-const _cli = require("@decohere/nexus/cli");
-const _runaction = require("./run.action.js");
-class RunCommand extends _cli.DecohereCommand {
-    get actions() {
-        return [
-            _runaction.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 _cli.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 !== "")
-    };
-}

package/commonjs/src/slice-serve.js

@@ -1,130 +0,0 @@
-/**
- * Directory-slice helpers for `flux serve <dir>…` — classify Mesh 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
-    };
-}