@decohere/flux 0.0.1-dev.9 → 0.0.1-dev.91

package/es6/src/index.js

@@ -1,4 +1,8 @@
+export { DeferredScriptRunner } from "./deferred-script-runner.js";
+export { flux } from "./flux.js";
 export { FluxModule } from "./flux.module.js";
-export { HotReloadServer } from "./hot-reload-server.js";
+export { DEFAULT_REBOOT_DEBOUNCE_MS, HotReloadServer } from "./hot-reload-server.js";
+export { classifySliceProject, classifySliceProjects, normalizeSlicePrefix, projectsInSlice, projectsInSlices, resolveDeferScript } from "./slice-serve.js";
+export { SourceModuleLoader } from "./source-module-loader.js";
 
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL2ZsdXgvc3JjL2luZGV4LnRzIl0sInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7IEZsdXhNb2R1bGUgfSBmcm9tIFwiLi9mbHV4Lm1vZHVsZS5qc1wiO1xuZXhwb3J0IHR5cGUgeyBIb3RSZWxvYWRTZXJ2ZXJPcHRpb25zIH0gZnJvbSBcIi4vaG90LXJlbG9hZC1zZXJ2ZXIuanNcIjtcbmV4cG9ydCB7IEhvdFJlbG9hZFNlcnZlciB9IGZyb20gXCIuL2hvdC1yZWxvYWQtc2VydmVyLmpzXCI7XG5leHBvcnQgdHlwZSB7IFNlcnZlT3B0aW9ucyB9IGZyb20gXCIuL3NlcnZlLmFjdGlvbi5qc1wiO1xuIl0sIm5hbWVzIjpbIkZsdXhNb2R1bGUiLCJIb3RSZWxvYWRTZXJ2ZXIiXSwibWFwcGluZ3MiOiJBQUFBLFNBQVNBLFVBQVUsUUFBUSxtQkFBbUI7QUFFOUMsU0FBU0MsZUFBZSxRQUFRLHlCQUF5QiJ9
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,40 @@
+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 and bare workspace
+ * package names (dynamic `import()` never goes through SWC path rewrite).
+ */ 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);
+    if (bareTarget != null && isWatchedTs(bareTarget)) {
+        return versionFileUrl(pathToFileURL(bareTarget).toString());
+    }
+    return 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;
+    let filePath = fileURLToPath(resolved);
+    if (filePath.endsWith(".js")) {
+        filePath = `${filePath.slice(0, -3)}.ts`;
+    } else if (!filePath.endsWith(".ts")) {
+        filePath = `${filePath}.ts`;
+    }
+    return isWatchedTs(filePath) ? filePath : null;
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/es6/src/run.action.js

@@ -0,0 +1,40 @@
+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";
+// biome-ignore lint/style/useImportType: <DI>
+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);
+
+//# sourceMappingURL=data:application/json;base64,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

package/es6/src/run.command.js

@@ -0,0 +1,57 @@
+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 !== "")
+    };
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/es6/src/serve.action.js

@@ -7,35 +7,104 @@ function _ts_decorate(decorators, target, key, desc) {
 function _ts_metadata(k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
+import path from "node:path";
 import { injectable } from "@decohere/crucible/decorators";
 // biome-ignore lint/style/useImportType: <DI>
 import { Workspace } from "@decohere/mesh";
 import { ActionResponse } from "@decohere/nexus/cli";
+import { scribe } from "@decohere/scribe";
+// biome-ignore lint/style/useImportType: <DI>
+import { DeferredScriptRunner } from "./deferred-script-runner.js";
 // biome-ignore lint/style/useImportType: <DI>
 import { HotReloadServer } from "./hot-reload-server.js";
+import { classifySliceProjects, resolveDeferScript } from "./slice-serve.js";
 export class ServeAction {
     server;
     workspace;
-    constructor(server, workspace){
+    deferredScripts;
+    logger = 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,
-            project: options.project
+            project: options.project,
+            rebootDebounceMs: options.rebootDebounceMs
         });
         return ActionResponse.Blocking(ServeAction.name);
     }
+    async runSlices(options, slices) {
+        const views = await this.toSliceViews(options.configuration);
+        const classified = 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 = path.resolve(this.workspace.rootDir ?? process.cwd());
+        for (const deferred of classified.defer){
+            const script = 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 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([
     injectable(),
     _ts_metadata("design:type", Function),
     _ts_metadata("design:paramtypes", [
         typeof HotReloadServer === "undefined" ? Object : HotReloadServer,
-        typeof Workspace === "undefined" ? Object : Workspace
+        typeof Workspace === "undefined" ? Object : Workspace,
+        typeof DeferredScriptRunner === "undefined" ? Object : 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":["path","injectable","Workspace","ActionResponse","scribe","DeferredScriptRunner","HotReloadServer","classifySliceProjects","resolveDeferScript","ServeAction","logger","name","server","workspace","deferredScripts","run","options","slices","filter","s","length","project","Error","runSlices","start","buildConfig","configuration","rebootDebounceMs","Blocking","views","toSliceViews","classified","label","join","skipped","skip","info","projectDirectory","flux","defer","workspaceRoot","resolve","rootDir","process","cwd","deferred","script","scripts","findProject","projectRoot","projects","map","p","getProjects","Promise","all","toSliceView","pkg","getPackageJson","replaceAll","main","found","find"],"mappings":"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"}

package/es6/src/serve.command.js

@@ -1,4 +1,5 @@
 import { ConfigurationOption, DecohereCommand, ProjectOption } from "@decohere/nexus/cli";
+import { DEFAULT_REBOOT_DEBOUNCE_MS, resolveRebootDebounceMs } from "./hot-reload-server.js";
 import { ServeAction } from "./serve.action.js";
 export class ServeCommand extends DecohereCommand {
     get actions() {
@@ -8,10 +9,39 @@ export class ServeCommand extends 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 ConfigurationOption("debug"));
         this.addOption(new ProjectOption());
+        this.option("--reboot-debounce-ms <ms>", "Quiet window in milliseconds after the last affecting save before a reboot", (value)=>resolveRebootDebounceMs(Number(value)), DEFAULT_REBOOT_DEBOUNCE_MS);
     }
+    /**
+	 * Commander passes positional args before options when `[slices...]` is declared.
+	 * The CLI host 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,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL2ZsdXgvc3JjL3NlcnZlLmNvbW1hbmQudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29uZmlndXJhdGlvbk9wdGlvbiwgRGVjb2hlcmVDb21tYW5kLCBQcm9qZWN0T3B0aW9uIH0gZnJvbSBcIkBkZWNvaGVyZS9uZXh1cy9jbGlcIjtcbmltcG9ydCB7IFNlcnZlQWN0aW9uIH0gZnJvbSBcIi4vc2VydmUuYWN0aW9uLmpzXCI7XG5cbmV4cG9ydCBjbGFzcyBTZXJ2ZUNvbW1hbmQgZXh0ZW5kcyBEZWNvaGVyZUNvbW1hbmQge1xuXHRwdWJsaWMgb3ZlcnJpZGUgZ2V0IGFjdGlvbnMoKSB7XG5cdFx0cmV0dXJuIFtTZXJ2ZUFjdGlvbl07XG5cdH1cblxuXHRwdWJsaWMgY29uc3RydWN0b3IobmFtZTogc3RyaW5nKSB7XG5cdFx0c3VwZXIobmFtZSk7XG5cdFx0dGhpcy5kZXNjcmlwdGlvbihcIlNlcnZlIGEgcHJvamVjdCBpbiBhIHdvcmtzcGFjZSBjb25maWd1cmF0aW9uXCIpO1xuXHRcdHRoaXMuYWRkT3B0aW9uKG5ldyBDb25maWd1cmF0aW9uT3B0aW9uKFwiZGVidWdcIikpO1xuXHRcdHRoaXMuYWRkT3B0aW9uKG5ldyBQcm9qZWN0T3B0aW9uKCkpO1xuXHR9XG59XG4iXSwibmFtZXMiOlsiQ29uZmlndXJhdGlvbk9wdGlvbiIsIkRlY29oZXJlQ29tbWFuZCIsIlByb2plY3RPcHRpb24iLCJTZXJ2ZUFjdGlvbiIsIlNlcnZlQ29tbWFuZCIsImFjdGlvbnMiLCJuYW1lIiwiZGVzY3JpcHRpb24iLCJhZGRPcHRpb24iXSwibWFwcGluZ3MiOiJBQUFBLFNBQVNBLG1CQUFtQixFQUFFQyxlQUFlLEVBQUVDLGFBQWEsUUFBUSxzQkFBc0I7QUFDMUYsU0FBU0MsV0FBVyxRQUFRLG9CQUFvQjtBQUVoRCxPQUFPLE1BQU1DLHFCQUFxQkg7SUFDakMsSUFBb0JJLFVBQVU7UUFDN0IsT0FBTztZQUFDRjtTQUFZO0lBQ3JCO0lBRUEsWUFBbUJHLElBQVksQ0FBRTtRQUNoQyxLQUFLLENBQUNBO1FBQ04sSUFBSSxDQUFDQyxXQUFXLENBQUM7UUFDakIsSUFBSSxDQUFDQyxTQUFTLENBQUMsSUFBSVIsb0JBQW9CO1FBQ3ZDLElBQUksQ0FBQ1EsU0FBUyxDQUFDLElBQUlOO0lBQ3BCO0FBQ0QifQ==
+//# sourceMappingURL=data:application/json;base64,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

package/es6/src/slice-serve.js

@@ -0,0 +1,107 @@
+/**
+ * Directory-slice helpers for `flux serve <dir>…` — classify Mesh packages as
+ * Flux apps, Nixpacks-style script deferrals, or libraries to skip.
+ */ /** Preferred package scripts for foreign toolchains (Nixpacks-style). */ export const DEFER_SCRIPT_CANDIDATES = [
+    "dev",
+    "serve"
+];
+/**
+ * Normalize a CLI slice token to a `projects/…` prefix without a trailing slash.
+ * `funding` and `projects/funding` both become `projects/funding`.
+ */ export 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}`;
+}
+/**
+ * True when `projectDirectory` belongs to the slice token.
+ *
+ * Matches:
+ * - nested: `projects/funding`, `projects/funding/api`
+ * - flat dotted package dirs: `projects/funding.web` for token `funding`
+ *
+ * Does not match siblings that only share a string prefix (`funding` vs `funding-fee.api`).
+ */ export 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}.`);
+}
+export function projectsInSlice(projects, slice) {
+    const prefix = normalizeSlicePrefix(slice);
+    return projects.filter((p)=>isUnderSlice(p.projectDirectory, prefix));
+}
+/** Union of packages under any of the slice tokens (deduped by package name). */ export 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()
+    ];
+}
+/** Script invokes Flux (in-process serve stays on Flux, not deferred). */ export function isFluxOwnedScript(script) {
+    return /\bflux\b/i.test(script);
+}
+/**
+ * First Nixpacks-style serve script that is not Flux-owned.
+ * Prefers `dev`, then `serve`.
+ */ export function resolveDeferScript(scripts) {
+    for (const name of DEFER_SCRIPT_CANDIDATES){
+        const body = scripts[name];
+        if (body != null && body !== "" && !isFluxOwnedScript(body)) {
+            return name;
+        }
+    }
+    return undefined;
+}
+/** Convention: Flux Node apps use `main` ending in `main.ts` / `main.tsx`. */ export function isFluxAppMain(main) {
+    const normalized = main.replaceAll("\\", "/");
+    return /(^|\/)main\.tsx?$/.test(normalized);
+}
+/**
+ * Classify one package. Foreign serve scripts win over `main.ts` (Vite apps
+ * often have a main entry but must not be HMR-booted by Flux).
+ */ export function classifySliceProject(project) {
+    if (resolveDeferScript(project.scripts) != null) {
+        return "defer";
+    }
+    if (isFluxAppMain(project.main)) {
+        return "flux";
+    }
+    return "skip";
+}
+export 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","normalizeSlicePrefix","slice","trimmed","replaceAll","replace","Error","startsWith","isUnderSlice","projectDirectory","slicePrefix","dir","prefix","projectsInSlice","projects","filter","p","projectsInSlices","slices","byName","Map","project","set","name","values","isFluxOwnedScript","script","test","resolveDeferScript","scripts","body","undefined","isFluxAppMain","main","normalized","classifySliceProject","classifySliceProjects","tokens","inSlice","flux","defer","skip","kind","push"],"mappings":"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"}