@decohere/flux 0.0.1-dev.74 → 0.0.1-dev.75

package/commonjs/src/serve.action.js

@@ -8,10 +8,19 @@ Object.defineProperty(exports, "ServeAction", {
         return ServeAction;
     }
 });
+const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
 const _decorators = require("@decohere/crucible/decorators");
 const _mesh = require("@decohere/mesh");
 const _cli = require("@decohere/nexus/cli");
+const _scribe = require("@decohere/scribe");
+const _deferredscriptrunner = require("./deferred-script-runner.js");
 const _hotreloadserver = require("./hot-reload-server.js");
+const _sliceserve = require("./slice-serve.js");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
 function _ts_decorate(decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
     if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -24,11 +33,21 @@ function _ts_metadata(k, v) {
 class ServeAction {
     server;
     workspace;
-    constructor(server, workspace){
+    deferredScripts;
+    logger = _scribe.scribe.logger(ServeAction.name);
+    constructor(server, workspace, deferredScripts){
         this.server = server;
         this.workspace = workspace;
+        this.deferredScripts = deferredScripts;
     }
     async run(options) {
+        const slices = (options.slices ?? []).filter((s)=>s !== "");
+        if (slices.length > 0 && options.project != null) {
+            throw new Error("Use either directory slices or --project, not both");
+        }
+        if (slices.length > 0) {
+            return this.runSlices(options, slices);
+        }
         await this.server.start({
             workspace: this.workspace,
             buildConfig: options.configuration,
@@ -37,14 +56,67 @@ class ServeAction {
         });
         return _cli.ActionResponse.Blocking(ServeAction.name);
     }
+    async runSlices(options, slices) {
+        const views = await this.toSliceViews(options.configuration);
+        const classified = (0, _sliceserve.classifySliceProjects)(views, slices);
+        const label = slices.join(" ");
+        for (const skipped of classified.skip){
+            this.logger.info(`skipped ${skipped.projectDirectory} — library (no Flux entry / scripts)`);
+        }
+        if (classified.flux.length === 0 && classified.defer.length === 0) {
+            throw new Error(`No runnable projects in slice(s) "${label}" (need Flux main.ts apps and/or package scripts.dev/serve)`);
+        }
+        const workspaceRoot = _nodepath.default.resolve(this.workspace.rootDir ?? process.cwd());
+        for (const deferred of classified.defer){
+            const script = (0, _sliceserve.resolveDeferScript)(deferred.scripts);
+            if (script == null) continue;
+            const project = this.findProject(options.configuration, deferred.name);
+            this.deferredScripts.start({
+                label: deferred.projectDirectory,
+                cwd: project.projectRoot,
+                script,
+                workspaceRoot
+            });
+        }
+        if (classified.flux.length > 0) {
+            await this.server.start({
+                workspace: this.workspace,
+                buildConfig: options.configuration,
+                projects: classified.flux.map((p)=>p.name),
+                rebootDebounceMs: options.rebootDebounceMs
+            });
+        }
+        return _cli.ActionResponse.Blocking(ServeAction.name);
+    }
+    async toSliceViews(configuration) {
+        const projects = this.workspace.getProjects(configuration);
+        return Promise.all(projects.map((project)=>this.toSliceView(project)));
+    }
+    async toSliceView(project) {
+        const pkg = await project.getPackageJson();
+        return {
+            name: project.name,
+            projectDirectory: project.projectDirectory.replaceAll("\\", "/"),
+            main: pkg.main ?? "src/index.ts",
+            scripts: pkg.scripts ?? {}
+        };
+    }
+    findProject(configuration, name) {
+        const found = this.workspace.getProjects(configuration).find((p)=>p.name === name);
+        if (found == null) {
+            throw new Error(`Project "${name}" not found in workspace`);
+        }
+        return found;
+    }
 }
 ServeAction = _ts_decorate([
     (0, _decorators.injectable)(),
     _ts_metadata("design:type", Function),
     _ts_metadata("design:paramtypes", [
         typeof _hotreloadserver.HotReloadServer === "undefined" ? Object : _hotreloadserver.HotReloadServer,
-        typeof _mesh.Workspace === "undefined" ? Object : _mesh.Workspace
+        typeof _mesh.Workspace === "undefined" ? Object : _mesh.Workspace,
+        typeof _deferredscriptrunner.DeferredScriptRunner === "undefined" ? Object : _deferredscriptrunner.DeferredScriptRunner
     ])
 ], ServeAction);
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/flux/src/serve.action.ts"],"sourcesContent":["import path from \"node:path\";\nimport { injectable } from \"@decohere/crucible/decorators\";\n// biome-ignore lint/style/useImportType: <DI>\nimport { type Project, Workspace } from \"@decohere/mesh\";\nimport { type Action, ActionResponse } from \"@decohere/nexus/cli\";\nimport { type Logger, scribe } from \"@decohere/scribe\";\n// biome-ignore lint/style/useImportType: <DI>\nimport { DeferredScriptRunner } from \"./deferred-script-runner.js\";\n// biome-ignore lint/style/useImportType: <DI>\nimport { HotReloadServer } from \"./hot-reload-server.js\";\nimport {\n\tclassifySliceProjects,\n\tresolveDeferScript,\n\ttype SliceProjectView,\n} from \"./slice-serve.js\";\n\nexport type ServeOptions = {\n\tconfiguration: string;\n\tproject?: string;\n\t/** One or more module directory tokens (`funding`, `shell`, `projects/funding`). */\n\tslices?: string[];\n\trebootDebounceMs?: number;\n};\n\n@injectable()\nexport class ServeAction implements Action<ServeOptions> {\n\tprivate readonly logger: Logger = scribe.logger(ServeAction.name);\n\n\tpublic constructor(\n\t\tprivate readonly server: HotReloadServer,\n\t\tprivate readonly workspace: Workspace,\n\t\tprivate readonly deferredScripts: DeferredScriptRunner,\n\t) {}\n\n\tpublic async run(options: ServeOptions): Promise<ActionResponse> {\n\t\tconst slices = (options.slices ?? []).filter((s) => s !== \"\");\n\t\tif (slices.length > 0 && options.project != null) {\n\t\t\tthrow new Error(\"Use either directory slices or --project, not both\");\n\t\t}\n\n\t\tif (slices.length > 0) {\n\t\t\treturn this.runSlices(options, slices);\n\t\t}\n\n\t\tawait this.server.start({\n\t\t\tworkspace: this.workspace,\n\t\t\tbuildConfig: options.configuration,\n\t\t\tproject: options.project,\n\t\t\trebootDebounceMs: options.rebootDebounceMs,\n\t\t});\n\t\treturn ActionResponse.Blocking(ServeAction.name);\n\t}\n\n\tprivate async runSlices(options: ServeOptions, slices: string[]): Promise<ActionResponse> {\n\t\tconst views = await this.toSliceViews(options.configuration);\n\t\tconst classified = classifySliceProjects(views, slices);\n\t\tconst label = slices.join(\" \");\n\n\t\tfor (const skipped of classified.skip) {\n\t\t\tthis.logger.info(\n\t\t\t\t`skipped ${skipped.projectDirectory} — library (no Flux entry / scripts)`,\n\t\t\t);\n\t\t}\n\n\t\tif (classified.flux.length === 0 && classified.defer.length === 0) {\n\t\t\tthrow new Error(\n\t\t\t\t`No runnable projects in slice(s) \"${label}\" (need Flux main.ts apps and/or package scripts.dev/serve)`,\n\t\t\t);\n\t\t}\n\n\t\tconst workspaceRoot = path.resolve(this.workspace.rootDir ?? process.cwd());\n\n\t\tfor (const deferred of classified.defer) {\n\t\t\tconst script = resolveDeferScript(deferred.scripts);\n\t\t\tif (script == null) continue;\n\t\t\tconst project = this.findProject(options.configuration, deferred.name);\n\t\t\tthis.deferredScripts.start({\n\t\t\t\tlabel: deferred.projectDirectory,\n\t\t\t\tcwd: project.projectRoot,\n\t\t\t\tscript,\n\t\t\t\tworkspaceRoot,\n\t\t\t});\n\t\t}\n\n\t\tif (classified.flux.length > 0) {\n\t\t\tawait this.server.start({\n\t\t\t\tworkspace: this.workspace,\n\t\t\t\tbuildConfig: options.configuration,\n\t\t\t\tprojects: classified.flux.map((p) => p.name),\n\t\t\t\trebootDebounceMs: options.rebootDebounceMs,\n\t\t\t});\n\t\t}\n\n\t\treturn ActionResponse.Blocking(ServeAction.name);\n\t}\n\n\tprivate async toSliceViews(configuration: string): Promise<SliceProjectView[]> {\n\t\tconst projects = this.workspace.getProjects(configuration);\n\t\treturn Promise.all(projects.map((project) => this.toSliceView(project)));\n\t}\n\n\tprivate async toSliceView(project: Project): Promise<SliceProjectView> {\n\t\tconst pkg = await project.getPackageJson();\n\t\treturn {\n\t\t\tname: project.name,\n\t\t\tprojectDirectory: project.projectDirectory.replaceAll(\"\\\\\", \"/\"),\n\t\t\tmain: pkg.main ?? \"src/index.ts\",\n\t\t\tscripts: pkg.scripts ?? {},\n\t\t};\n\t}\n\n\tprivate findProject(configuration: string, name: string): Project {\n\t\tconst found = this.workspace.getProjects(configuration).find((p) => p.name === name);\n\t\tif (found == null) {\n\t\t\tthrow new Error(`Project \"${name}\" not found in workspace`);\n\t\t}\n\t\treturn found;\n\t}\n}\n"],"names":["ServeAction","logger","scribe","name","server","workspace","deferredScripts","run","options","slices","filter","s","length","project","Error","runSlices","start","buildConfig","configuration","rebootDebounceMs","ActionResponse","Blocking","views","toSliceViews","classified","classifySliceProjects","label","join","skipped","skip","info","projectDirectory","flux","defer","workspaceRoot","path","resolve","rootDir","process","cwd","deferred","script","resolveDeferScript","scripts","findProject","projectRoot","projects","map","p","getProjects","Promise","all","toSliceView","pkg","getPackageJson","replaceAll","main","found","find"],"mappings":"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"}

package/commonjs/src/serve.command.js

@@ -19,11 +19,39 @@ class ServeCommand extends _cli.DecohereCommand {
     }
     constructor(name){
         super(name);
-        this.description("Serve a project in a workspace configuration");
+        this.description("Serve a project or directory slices (Flux apps in-process; foreign packages via package scripts)");
+        this.argument("[slices...]", "Module directories to serve (e.g. funding shell secmaster, or projects/funding)");
         this.addOption(new _cli.ConfigurationOption("debug"));
         this.addOption(new _cli.ProjectOption());
         this.option("--reboot-debounce-ms <ms>", "Quiet window in milliseconds after the last affecting save before a reboot", (value)=>(0, _hotreloadserver.resolveRebootDebounceMs)(Number(value)), _hotreloadserver.DEFAULT_REBOOT_DEBOUNCE_MS);
     }
+    /**
+	 * Commander passes positional args before options when `[slices...]` is declared.
+	 * Terminal's ModuleFactory expects `(opts, cmd)` — normalize here.
+	 */ action(fn) {
+        return super.action((...args)=>{
+            const cmd = args.at(-1);
+            const first = args[0];
+            const hasPositionalSlices = Array.isArray(first) || typeof first === "string" || first === undefined;
+            const opts = hasPositionalSlices ? args[1] : args[0];
+            const slices = normalizePositionalSlices(first);
+            if (slices.length > 0) {
+                cmd.setOptionValue("slices", slices);
+            }
+            return fn(opts, cmd);
+        });
+    }
+}
+function normalizePositionalSlices(first) {
+    if (Array.isArray(first)) {
+        return first.filter((s)=>typeof s === "string" && s !== "");
+    }
+    if (typeof first === "string" && first !== "") {
+        return [
+            first
+        ];
+    }
+    return [];
 }
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/commonjs/src/slice-serve.js

@@ -0,0 +1,132 @@
+/**
+ * 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
+    };
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/flux/src/slice-serve.ts"],"sourcesContent":["/**\n * Directory-slice helpers for `flux serve <dir>…` — classify Mesh packages as\n * Flux apps, Nixpacks-style script deferrals, or libraries to skip.\n */\n\nexport type SliceProjectView = {\n\treadonly name: string;\n\t/** Relative project dir from workspace root (e.g. `projects/funding/api`). */\n\treadonly projectDirectory: string;\n\treadonly main: string;\n\treadonly scripts: Record<string, string>;\n};\n\nexport type SliceKind = \"flux\" | \"defer\" | \"skip\";\n\nexport type ClassifiedSlice = {\n\treadonly flux: SliceProjectView[];\n\treadonly defer: SliceProjectView[];\n\treadonly skip: SliceProjectView[];\n};\n\n/** Preferred package scripts for foreign toolchains (Nixpacks-style). */\nexport const DEFER_SCRIPT_CANDIDATES = [\"dev\", \"serve\"] as const;\n\n/**\n * Normalize a CLI slice token to a `projects/…` prefix without a trailing slash.\n * `funding` and `projects/funding` both become `projects/funding`.\n */\nexport function normalizeSlicePrefix(slice: string): string {\n\tconst trimmed = slice.replaceAll(\"\\\\\", \"/\").replace(/\\/+$/, \"\");\n\tif (trimmed === \"\" || trimmed === \".\") {\n\t\tthrow new Error(\"Slice directory must be a non-empty path\");\n\t}\n\tif (trimmed === \"projects\" || trimmed.startsWith(\"projects/\")) {\n\t\treturn trimmed;\n\t}\n\treturn `projects/${trimmed}`;\n}\n\n/**\n * True when `projectDirectory` belongs to the slice token.\n *\n * Matches:\n * - nested: `projects/funding`, `projects/funding/api`\n * - flat dotted package dirs: `projects/funding.web` for token `funding`\n *\n * Does not match siblings that only share a string prefix (`funding` vs `funding-fee.api`).\n */\nexport function isUnderSlice(projectDirectory: string, slicePrefix: string): boolean {\n\tconst dir = projectDirectory.replaceAll(\"\\\\\", \"/\").replace(/\\/+$/, \"\");\n\tconst prefix = slicePrefix.replaceAll(\"\\\\\", \"/\").replace(/\\/+$/, \"\");\n\tif (dir === prefix || dir.startsWith(`${prefix}/`)) {\n\t\treturn true;\n\t}\n\t// Flat monorepo packages: projects/<module>.<role>\n\treturn dir.startsWith(`${prefix}.`);\n}\n\nexport function projectsInSlice(\n\tprojects: readonly SliceProjectView[],\n\tslice: string,\n): SliceProjectView[] {\n\tconst prefix = normalizeSlicePrefix(slice);\n\treturn projects.filter((p) => isUnderSlice(p.projectDirectory, prefix));\n}\n\n/** Union of packages under any of the slice tokens (deduped by package name). */\nexport function projectsInSlices(\n\tprojects: readonly SliceProjectView[],\n\tslices: readonly string[],\n): SliceProjectView[] {\n\tconst byName = new Map<string, SliceProjectView>();\n\tfor (const slice of slices) {\n\t\tfor (const project of projectsInSlice(projects, slice)) {\n\t\t\tbyName.set(project.name, project);\n\t\t}\n\t}\n\treturn [...byName.values()];\n}\n\n/** Script invokes Flux (in-process serve stays on Flux, not deferred). */\nexport function isFluxOwnedScript(script: string): boolean {\n\treturn /\\bflux\\b/i.test(script);\n}\n\n/**\n * First Nixpacks-style serve script that is not Flux-owned.\n * Prefers `dev`, then `serve`.\n */\nexport function resolveDeferScript(scripts: Record<string, string>): string | undefined {\n\tfor (const name of DEFER_SCRIPT_CANDIDATES) {\n\t\tconst body = scripts[name];\n\t\tif (body != null && body !== \"\" && !isFluxOwnedScript(body)) {\n\t\t\treturn name;\n\t\t}\n\t}\n\treturn undefined;\n}\n\n/** Convention: Flux Node apps use `main` ending in `main.ts` / `main.tsx`. */\nexport function isFluxAppMain(main: string): boolean {\n\tconst normalized = main.replaceAll(\"\\\\\", \"/\");\n\treturn /(^|\\/)main\\.tsx?$/.test(normalized);\n}\n\n/**\n * Classify one package. Foreign serve scripts win over `main.ts` (Vite apps\n * often have a main entry but must not be HMR-booted by Flux).\n */\nexport function classifySliceProject(project: SliceProjectView): SliceKind {\n\tif (resolveDeferScript(project.scripts) != null) {\n\t\treturn \"defer\";\n\t}\n\tif (isFluxAppMain(project.main)) {\n\t\treturn \"flux\";\n\t}\n\treturn \"skip\";\n}\n\nexport function classifySliceProjects(\n\tprojects: readonly SliceProjectView[],\n\tslices: string | readonly string[],\n): ClassifiedSlice {\n\tconst tokens = typeof slices === \"string\" ? [slices] : [...slices];\n\tconst inSlice = projectsInSlices(projects, tokens);\n\tconst flux: SliceProjectView[] = [];\n\tconst defer: SliceProjectView[] = [];\n\tconst skip: SliceProjectView[] = [];\n\tfor (const project of inSlice) {\n\t\tconst kind = classifySliceProject(project);\n\t\tif (kind === \"flux\") flux.push(project);\n\t\telse if (kind === \"defer\") defer.push(project);\n\t\telse skip.push(project);\n\t}\n\treturn { flux, defer, skip };\n}\n"],"names":["DEFER_SCRIPT_CANDIDATES","classifySliceProject","classifySliceProjects","isFluxAppMain","isFluxOwnedScript","isUnderSlice","normalizeSlicePrefix","projectsInSlice","projectsInSlices","resolveDeferScript","slice","trimmed","replaceAll","replace","Error","startsWith","projectDirectory","slicePrefix","dir","prefix","projects","filter","p","slices","byName","Map","project","set","name","values","script","test","scripts","body","undefined","main","normalized","tokens","inSlice","flux","defer","skip","kind","push"],"mappings":"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"}

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

@@ -0,0 +1,48 @@
+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);
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL2ZsdXgvc3JjL2RlZmVycmVkLXNjcmlwdC1ydW5uZXIudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgdHlwZSBDaGlsZFByb2Nlc3MsIHNwYXduIH0gZnJvbSBcIm5vZGU6Y2hpbGRfcHJvY2Vzc1wiO1xuaW1wb3J0IHsgaW5qZWN0YWJsZSB9IGZyb20gXCJAZGVjb2hlcmUvY3J1Y2libGUvZGVjb3JhdG9yc1wiO1xuaW1wb3J0IHsgZGV0ZWN0UGFja2FnZU1hbmFnZXIsIHBhY2thZ2VNYW5hZ2VyRnJvbVN0cmluZyB9IGZyb20gXCJAZGVjb2hlcmUvbmV4dXMvaW50ZXJvcFwiO1xuaW1wb3J0IHsgdHlwZSBMb2dnZXIsIHNjcmliZSB9IGZyb20gXCJAZGVjb2hlcmUvc2NyaWJlXCI7XG5cbmV4cG9ydCB0eXBlIERlZmVycmVkU2NyaXB0U3RhcnQgPSB7XG5cdHJlYWRvbmx5IGxhYmVsOiBzdHJpbmc7XG5cdHJlYWRvbmx5IGN3ZDogc3RyaW5nO1xuXHRyZWFkb25seSBzY3JpcHQ6IHN0cmluZztcblx0LyoqIFdvcmtzcGFjZSByb290IHVzZWQgdG8gZGV0ZWN0IHBucG0vbnBtL3lhcm4uICovXG5cdHJlYWRvbmx5IHdvcmtzcGFjZVJvb3Q6IHN0cmluZztcbn07XG5cbi8qKlxuICogTml4cGFja3Mtc3R5bGUgY2hpbGQgcHJvY2Vzc2VzIGZvciBmb3JlaWduIHBhY2thZ2VzIGluIGEgZmx1eCBzZXJ2ZSBzbGljZS5cbiAqIEtpbGxlZCB3aGVuIHRoZSBGbHV4IGNvbnRhaW5lciBkaXNwb3NlcyAoU0lHSU5UIOKGkiBSb290TW9kdWxlIHRlYXJkb3duKS5cbiAqL1xuQGluamVjdGFibGUoKVxuZXhwb3J0IGNsYXNzIERlZmVycmVkU2NyaXB0UnVubmVyIGltcGxlbWVudHMgQXN5bmNEaXNwb3NhYmxlIHtcblx0cHJpdmF0ZSByZWFkb25seSBsb2dnZXI6IExvZ2dlciA9IHNjcmliZS5sb2dnZXIoRGVmZXJyZWRTY3JpcHRSdW5uZXIubmFtZSk7XG5cdHByaXZhdGUgcmVhZG9ubHkgY2hpbGRyZW46IENoaWxkUHJvY2Vzc1tdID0gW107XG5cblx0cHVibGljIHN0YXJ0KG9wdGlvbnM6IERlZmVycmVkU2NyaXB0U3RhcnQpOiBDaGlsZFByb2Nlc3Mge1xuXHRcdGNvbnN0IHBtID0gZGV0ZWN0UGFja2FnZU1hbmFnZXIob3B0aW9ucy53b3Jrc3BhY2VSb290KSA/PyBwYWNrYWdlTWFuYWdlckZyb21TdHJpbmcoXCJwbnBtXCIpO1xuXHRcdHRoaXMubG9nZ2VyLmluZm8oXG5cdFx0XHRgZGVmZXJyZWQgJHtvcHRpb25zLmxhYmVsfSDigJQgcnVubmluZyAke3BtLm5hbWV9IHJ1biAke29wdGlvbnMuc2NyaXB0fSBpbiAke29wdGlvbnMuY3dkfWAsXG5cdFx0KTtcblx0XHRjb25zdCBjaGlsZCA9IHNwYXduKHBtLm5hbWUsIFtcInJ1blwiLCBvcHRpb25zLnNjcmlwdF0sIHtcblx0XHRcdGN3ZDogb3B0aW9ucy5jd2QsXG5cdFx0XHRzdGRpbzogXCJpbmhlcml0XCIsXG5cdFx0XHRlbnY6IHByb2Nlc3MuZW52LFxuXHRcdFx0c2hlbGw6IGZhbHNlLFxuXHRcdH0pO1xuXHRcdGNoaWxkLm9uKFwiZXhpdFwiLCAoY29kZSwgc2lnbmFsKSA9PiB7XG5cdFx0XHRpZiAoc2lnbmFsKSByZXR1cm47XG5cdFx0XHRpZiAoY29kZSAhPSBudWxsICYmIGNvZGUgIT09IDApIHtcblx0XHRcdFx0dGhpcy5sb2dnZXIud2FybihgZGVmZXJyZWQgJHtvcHRpb25zLmxhYmVsfSBleGl0ZWQgd2l0aCAke2NvZGV9YCk7XG5cdFx0XHR9XG5cdFx0fSk7XG5cdFx0dGhpcy5jaGlsZHJlbi5wdXNoKGNoaWxkKTtcblx0XHRyZXR1cm4gY2hpbGQ7XG5cdH1cblxuXHRwdWJsaWMgYXN5bmMgW1N5bWJvbC5hc3luY0Rpc3Bvc2VdKCkge1xuXHRcdGZvciAoY29uc3QgY2hpbGQgb2YgdGhpcy5jaGlsZHJlbikge1xuXHRcdFx0aWYgKCFjaGlsZC5raWxsZWQpIHtcblx0XHRcdFx0Y2hpbGQua2lsbChcIlNJR1RFUk1cIik7XG5cdFx0XHR9XG5cdFx0fVxuXHRcdHRoaXMuY2hpbGRyZW4ubGVuZ3RoID0gMDtcblx0fVxufVxuIl0sIm5hbWVzIjpbInNwYXduIiwiaW5qZWN0YWJsZSIsImRldGVjdFBhY2thZ2VNYW5hZ2VyIiwicGFja2FnZU1hbmFnZXJGcm9tU3RyaW5nIiwic2NyaWJlIiwiRGVmZXJyZWRTY3JpcHRSdW5uZXIiLCJsb2dnZXIiLCJuYW1lIiwiY2hpbGRyZW4iLCJzdGFydCIsIm9wdGlvbnMiLCJwbSIsIndvcmtzcGFjZVJvb3QiLCJpbmZvIiwibGFiZWwiLCJzY3JpcHQiLCJjd2QiLCJjaGlsZCIsInN0ZGlvIiwiZW52IiwicHJvY2VzcyIsInNoZWxsIiwib24iLCJjb2RlIiwic2lnbmFsIiwid2FybiIsInB1c2giLCJTeW1ib2wiLCJhc3luY0Rpc3Bvc2UiLCJraWxsZWQiLCJraWxsIiwibGVuZ3RoIl0sIm1hcHBpbmdzIjoiOzs7Ozs7QUFBQSxTQUE0QkEsS0FBSyxRQUFRLHFCQUFxQjtBQUM5RCxTQUFTQyxVQUFVLFFBQVEsZ0NBQWdDO0FBQzNELFNBQVNDLG9CQUFvQixFQUFFQyx3QkFBd0IsUUFBUSwwQkFBMEI7QUFDekYsU0FBc0JDLE1BQU0sUUFBUSxtQkFBbUI7QUFldkQsT0FBTyxNQUFNQztJQUNLQyxTQUFpQkYsT0FBT0UsTUFBTSxDQUFDRCxxQkFBcUJFLElBQUksRUFBRTtJQUMxREMsV0FBMkIsRUFBRSxDQUFDO0lBRXhDQyxNQUFNQyxPQUE0QixFQUFnQjtRQUN4RCxNQUFNQyxLQUFLVCxxQkFBcUJRLFFBQVFFLGFBQWEsS0FBS1QseUJBQXlCO1FBQ25GLElBQUksQ0FBQ0csTUFBTSxDQUFDTyxJQUFJLENBQ2YsQ0FBQyxTQUFTLEVBQUVILFFBQVFJLEtBQUssQ0FBQyxXQUFXLEVBQUVILEdBQUdKLElBQUksQ0FBQyxLQUFLLEVBQUVHLFFBQVFLLE1BQU0sQ0FBQyxJQUFJLEVBQUVMLFFBQVFNLEdBQUcsRUFBRTtRQUV6RixNQUFNQyxRQUFRakIsTUFBTVcsR0FBR0osSUFBSSxFQUFFO1lBQUM7WUFBT0csUUFBUUssTUFBTTtTQUFDLEVBQUU7WUFDckRDLEtBQUtOLFFBQVFNLEdBQUc7WUFDaEJFLE9BQU87WUFDUEMsS0FBS0MsUUFBUUQsR0FBRztZQUNoQkUsT0FBTztRQUNSO1FBQ0FKLE1BQU1LLEVBQUUsQ0FBQyxRQUFRLENBQUNDLE1BQU1DO1lBQ3ZCLElBQUlBLFFBQVE7WUFDWixJQUFJRCxRQUFRLFFBQVFBLFNBQVMsR0FBRztnQkFDL0IsSUFBSSxDQUFDakIsTUFBTSxDQUFDbUIsSUFBSSxDQUFDLENBQUMsU0FBUyxFQUFFZixRQUFRSSxLQUFLLENBQUMsYUFBYSxFQUFFUyxNQUFNO1lBQ2pFO1FBQ0Q7UUFDQSxJQUFJLENBQUNmLFFBQVEsQ0FBQ2tCLElBQUksQ0FBQ1Q7UUFDbkIsT0FBT0E7SUFDUjtJQUVBLE1BQWEsQ0FBQ1UsT0FBT0MsWUFBWSxDQUFDLEdBQUc7UUFDcEMsS0FBSyxNQUFNWCxTQUFTLElBQUksQ0FBQ1QsUUFBUSxDQUFFO1lBQ2xDLElBQUksQ0FBQ1MsTUFBTVksTUFBTSxFQUFFO2dCQUNsQlosTUFBTWEsSUFBSSxDQUFDO1lBQ1o7UUFDRDtRQUNBLElBQUksQ0FBQ3RCLFFBQVEsQ0FBQ3VCLE1BQU0sR0FBRztJQUN4QjtBQUNEIn0=

package/es6/src/flux.module.js

@@ -1,5 +1,6 @@
 import { WorkspaceFactory } from "@decohere/mesh";
 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 { ServeAction } from "./serve.action.js";
@@ -11,6 +12,7 @@ export class FluxModule extends ModuleManifest {
     };
     registerServices(builder) {
         builder.registerSingleton(HotReloadServer);
+        builder.registerSingleton(DeferredScriptRunner);
     }
     createWorkspace(options) {
         return WorkspaceFactory.create({
@@ -19,4 +21,4 @@ export class FluxModule extends ModuleManifest {
     }
 }
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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