@decohere/flux 0.0.1-dev.8 → 0.0.1-dev.81

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

@@ -0,0 +1,160 @@
+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 { registerHooks } from "node:module";
+import path from "node:path";
+import { injectable } from "@decohere/crucible/decorators";
+import { BuildTargets, SwcTranspiler, WorkspaceDefaults } from "@decohere/forge";
+import { packageAliases, WorkspaceFactory } from "@decohere/mesh";
+import { FileEx, io } from "@decohere/nexus/io";
+import { scribe } from "@decohere/scribe";
+import { rewriteServeSpecifier } from "./rewrite-serve-specifier.js";
+export class SourceModuleLoader {
+    logger = scribe.logger(SourceModuleLoader.name);
+    transpiler = new SwcTranspiler();
+    disposed = false;
+    hooksRegistered = false;
+    workspace;
+    buildConfig = "debug";
+    fileInfoMap = new Map();
+    transpileCache = new Map();
+    aliasPaths = {};
+    aliasBaseUrl = path.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.buildConfig = options.buildConfig;
+        this.workspace = options.workspace ?? await WorkspaceFactory.create({
+            ...WorkspaceDefaults,
+            rootDir: process.cwd()
+        });
+        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;
+        registerHooks({
+            resolve: (specifier, context, next)=>{
+                if (this.disposed) return next(specifier, context);
+                const parentUrl = context.parentURL ?? "";
+                const rewritten = rewriteServeSpecifier({
+                    specifier,
+                    parentUrl,
+                    isWatchedTs: (filePath)=>this.fileInfoMap.has(filePath),
+                    resolveBare: (bare)=>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.pathToFileUrl(path.resolve(absolutePath)));
+        return import(url);
+    }
+    invalidateTranspile(...absolutePaths) {
+        for (const fullPath of absolutePaths){
+            this.transpileCache.delete(fullPath);
+            this.transpiler.invalidateContentCache(new FileEx({
+                fullPath
+            }));
+        }
+    }
+    dispose() {
+        this.disposed = true;
+        this.transpileCache.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;
+        const cleanPath = new URL(url).pathname;
+        const fileInfo = this.fileInfoMap.get(cleanPath);
+        if (fileInfo == null) return null;
+        const cached = this.transpileCache.get(cleanPath);
+        if (cached != null) return {
+            source: cached
+        };
+        const { project } = fileInfo;
+        const tsConfig = project.getTsConfigSync();
+        const userConfig = project.getSwcConfigSync();
+        const file = new FileEx({
+            fullPath: cleanPath
+        });
+        const response = this.transpiler.transformFileSync(file, BuildTargets.es6, {
+            tsConfig,
+            aliasPaths: true,
+            userConfig,
+            workspace: this.workspace,
+            projects: this.workspace?.getProjects(this.buildConfig)
+        });
+        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
+        };
+    }
+}
+SourceModuleLoader = _ts_decorate([
+    injectable()
+], SourceModuleLoader);
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/flux/src/source-module-loader.ts"],"sourcesContent":["import type {\n\tLoadFnOutput,\n\tLoadHookContext,\n\tResolveFnOutput,\n\tResolveHookContext,\n} from \"node:module\";\nimport { registerHooks } from \"node:module\";\nimport path from \"node:path\";\nimport { injectable } from \"@decohere/crucible/decorators\";\nimport { BuildTargets, SwcTranspiler, WorkspaceDefaults } from \"@decohere/forge\";\nimport type { Project, Workspace } from \"@decohere/mesh\";\nimport { packageAliases, WorkspaceFactory } from \"@decohere/mesh\";\nimport { FileEx, io } from \"@decohere/nexus/io\";\nimport { type Logger, scribe } from \"@decohere/scribe\";\nimport { rewriteServeSpecifier } from \"./rewrite-serve-specifier.js\";\n\ntype FileInfo = { project: Project };\n\nexport interface SourceModuleLoaderOptions {\n\t/** Build configuration name. */\n\tbuildConfig: string;\n\t/**\n\t * Pre-built Workspace instance to use instead of running WorkspaceFactory.\n\t * Useful in tests to bypass filesystem-based workspace discovery.\n\t */\n\tworkspace?: Workspace;\n\t/**\n\t * Map a watched `.ts` file URL for ESM resolution.\n\t * Hot reload passes a `?version=` bust; one-shot run uses identity.\n\t */\n\tversionFileUrl?: (fileUrl: string) => string;\n\t/** Optional post-resolve hook (e.g. dependency tracking for HMR). */\n\tonResolved?: (result: ResolveFnOutput, parentUrl: string) => void;\n}\n\n/**\n * Registers Node ESM resolve/load hooks and SWC-transpiles workspace `.ts`\n * on the fly. No file watching and no entry reboot — that belongs to\n * {@link HotReloadServer}.\n */\n@injectable()\nexport class SourceModuleLoader {\n\tprivate readonly logger: Logger = scribe.logger(SourceModuleLoader.name);\n\tprivate readonly transpiler = new SwcTranspiler();\n\tprivate disposed = false;\n\tprivate hooksRegistered = false;\n\tprivate workspace?: Workspace;\n\tprivate buildConfig = \"debug\";\n\tprivate fileInfoMap = new Map<string, FileInfo>();\n\tprivate transpileCache = new Map<string, string>();\n\tprivate aliasPaths: Record<string, string[]> = {};\n\tprivate aliasBaseUrl = path.resolve(\".\");\n\tprivate versionFileUrl: (fileUrl: string) => string = (fileUrl) => fileUrl;\n\tprivate onResolved?: (result: ResolveFnOutput, parentUrl: string) => void;\n\n\tpublic getWorkspace(): Workspace | undefined {\n\t\treturn this.workspace;\n\t}\n\n\tpublic getBuildConfig(): string {\n\t\treturn this.buildConfig;\n\t}\n\n\tpublic hasSourceFile(absolutePath: string): boolean {\n\t\treturn this.fileInfoMap.has(absolutePath);\n\t}\n\n\tpublic sourceFilePaths(): IterableIterator<string> {\n\t\treturn this.fileInfoMap.keys();\n\t}\n\n\tpublic setSourceFile(absolutePath: string, project: Project): void {\n\t\tthis.fileInfoMap.set(absolutePath, { project });\n\t}\n\n\tpublic async configure(options: SourceModuleLoaderOptions): Promise<void> {\n\t\tthis.disposed = false;\n\t\tthis.transpileCache.clear();\n\t\tthis.buildConfig = options.buildConfig;\n\t\tthis.workspace =\n\t\t\toptions.workspace ??\n\t\t\t(await WorkspaceFactory.create({ ...WorkspaceDefaults, rootDir: process.cwd() }));\n\t\tthis.versionFileUrl = options.versionFileUrl ?? ((fileUrl) => fileUrl);\n\t\tthis.onResolved = options.onResolved;\n\t\tthis.fileInfoMap = await this.buildFileInfoMap(this.buildConfig);\n\t\tconst aliases = this.workspace.getPackageAliases(this.buildConfig);\n\t\tthis.aliasBaseUrl = aliases.baseUrl;\n\t\tthis.aliasPaths = aliases.paths;\n\t}\n\n\tpublic registerHooks(): void {\n\t\tif (this.hooksRegistered) return;\n\t\tthis.hooksRegistered = true;\n\t\tregisterHooks({\n\t\t\tresolve: (\n\t\t\t\tspecifier: string,\n\t\t\t\tcontext: ResolveHookContext,\n\t\t\t\tnext: (specifier: string, context?: Partial<ResolveHookContext>) => ResolveFnOutput,\n\t\t\t) => {\n\t\t\t\tif (this.disposed) return next(specifier, context);\n\t\t\t\tconst parentUrl = context.parentURL ?? \"\";\n\t\t\t\tconst rewritten =\n\t\t\t\t\trewriteServeSpecifier({\n\t\t\t\t\t\tspecifier,\n\t\t\t\t\t\tparentUrl,\n\t\t\t\t\t\tisWatchedTs: (filePath) => this.fileInfoMap.has(filePath),\n\t\t\t\t\t\tresolveBare: (bare) =>\n\t\t\t\t\t\t\tpackageAliases.resolvePath(bare, this.aliasPaths, this.aliasBaseUrl),\n\t\t\t\t\t\tversionFileUrl: this.versionFileUrl,\n\t\t\t\t\t}) ?? specifier;\n\t\t\t\tconst result = next(rewritten, context) as ResolveFnOutput;\n\t\t\t\tthis.onResolved?.(result, parentUrl);\n\t\t\t\treturn result;\n\t\t\t},\n\t\t\tload: (\n\t\t\t\turl: string,\n\t\t\t\tcontext: LoadHookContext,\n\t\t\t\tnext: (url: string, context?: Partial<LoadHookContext>) => LoadFnOutput,\n\t\t\t): LoadFnOutput => {\n\t\t\t\tif (this.disposed) return next(url, context);\n\t\t\t\tconst result = this.loadTs(url);\n\t\t\t\tif (result != null) {\n\t\t\t\t\treturn { format: \"module\", source: result.source, shortCircuit: true };\n\t\t\t\t}\n\t\t\t\treturn next(url, context);\n\t\t\t},\n\t\t});\n\t}\n\n\tpublic async importEntry(absolutePath: string): Promise<unknown> {\n\t\tconst url = this.versionFileUrl(io.pathToFileUrl(path.resolve(absolutePath)));\n\t\treturn import(url);\n\t}\n\n\tpublic invalidateTranspile(...absolutePaths: string[]): void {\n\t\tfor (const fullPath of absolutePaths) {\n\t\t\tthis.transpileCache.delete(fullPath);\n\t\t\tthis.transpiler.invalidateContentCache(new FileEx({ fullPath }));\n\t\t}\n\t}\n\n\tpublic dispose(): void {\n\t\tthis.disposed = true;\n\t\tthis.transpileCache.clear();\n\t\tthis.fileInfoMap.clear();\n\t\tthis.workspace?.[Symbol.dispose]();\n\t\tthis.workspace = undefined;\n\t}\n\n\tprivate async buildFileInfoMap(buildConfig: string): Promise<Map<string, FileInfo>> {\n\t\tconst projects = this.workspace?.getProjects(buildConfig) ?? [];\n\t\tconst entries = await Promise.all(\n\t\t\tprojects.map(async (project) => {\n\t\t\t\tconst files = await project.getAllFiles();\n\t\t\t\treturn files.map((file): [string, FileInfo] => [file.fullPath, { project }]);\n\t\t\t}),\n\t\t);\n\t\treturn new Map(entries.flat());\n\t}\n\n\tprivate loadTs(url: string): { source: string } | null {\n\t\tif (!url.startsWith(\"file:\")) return null;\n\n\t\tconst cleanPath = new URL(url).pathname;\n\t\tconst fileInfo = this.fileInfoMap.get(cleanPath);\n\t\tif (fileInfo == null) return null;\n\n\t\tconst cached = this.transpileCache.get(cleanPath);\n\t\tif (cached != null) return { source: cached };\n\n\t\tconst { project } = fileInfo;\n\t\tconst tsConfig = project.getTsConfigSync();\n\t\tconst userConfig = project.getSwcConfigSync();\n\n\t\tconst file = new FileEx({ fullPath: cleanPath });\n\t\tconst response = this.transpiler.transformFileSync(file, BuildTargets.es6, {\n\t\t\ttsConfig,\n\t\t\taliasPaths: true,\n\t\t\tuserConfig,\n\t\t\tworkspace: this.workspace,\n\t\t\tprojects: this.workspace?.getProjects(this.buildConfig),\n\t\t});\n\n\t\tif (response.outcome !== \"success\") {\n\t\t\tthis.logger.error(`Failed to transpile ${cleanPath}`, response);\n\t\t\tthrow new Error(`Failed to transpile ${cleanPath}`);\n\t\t}\n\n\t\tthis.transpileCache.set(cleanPath, response.code);\n\t\treturn { source: response.code };\n\t}\n}\n"],"names":["registerHooks","path","injectable","BuildTargets","SwcTranspiler","WorkspaceDefaults","packageAliases","WorkspaceFactory","FileEx","io","scribe","rewriteServeSpecifier","SourceModuleLoader","logger","name","transpiler","disposed","hooksRegistered","workspace","buildConfig","fileInfoMap","Map","transpileCache","aliasPaths","aliasBaseUrl","resolve","versionFileUrl","fileUrl","onResolved","getWorkspace","getBuildConfig","hasSourceFile","absolutePath","has","sourceFilePaths","keys","setSourceFile","project","set","configure","options","clear","create","rootDir","process","cwd","buildFileInfoMap","aliases","getPackageAliases","baseUrl","paths","specifier","context","next","parentUrl","parentURL","rewritten","isWatchedTs","filePath","resolveBare","bare","resolvePath","result","load","url","loadTs","format","source","shortCircuit","importEntry","pathToFileUrl","invalidateTranspile","absolutePaths","fullPath","delete","invalidateContentCache","dispose","Symbol","undefined","projects","getProjects","entries","Promise","all","map","files","getAllFiles","file","flat","startsWith","cleanPath","URL","pathname","fileInfo","get","cached","tsConfig","getTsConfigSync","userConfig","getSwcConfigSync","response","transformFileSync","es6","outcome","error","Error","code"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decohere/flux",
-  "version": "0.0.1-dev.8",
+  "version": "0.0.1-dev.81",
   "description": "Hot module reload server for Node.js ESM applications",
   "keywords": [
     "typescript",
@@ -19,23 +19,19 @@
       "types": "./types/src/index.d.ts",
       "import": "./es6/src/index.js",
       "require": "./commonjs/src/index.js"
-    },
-    "./serve": {
-      "types": "./types/src/serve.d.ts",
-      "import": "./es6/src/serve.js"
     }
   },
-  "bin": {
-    "ember": "./es6/src/serve.js"
-  },
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
   },
   "dependencies": {
-    "@decohere/crucible": "0.0.1-dev.8",
-    "@decohere/mesh": "0.0.1-dev.8",
-    "@decohere/nexus": "0.0.1-dev.8",
-    "@decohere/scribe": "0.0.1-dev.8"
+    "@decohere/crucible": "0.0.1-dev.81",
+    "@decohere/forge": "0.0.1-dev.81",
+    "@decohere/mesh": "0.0.1-dev.81",
+    "@decohere/nexus": "0.0.1-dev.81",
+    "@decohere/scribe": "0.0.1-dev.81",
+    "commander": "^13.1.0",
+    "rxjs": "^7.8.2"
   },
   "devDependencies": {}
 }

package/types/src/deferred-script-runner.d.ts

@@ -0,0 +1,18 @@
+import { type ChildProcess } from "node:child_process";
+export type DeferredScriptStart = {
+    readonly label: string;
+    readonly cwd: string;
+    readonly script: string;
+    /** Workspace root used to detect pnpm/npm/yarn. */
+    readonly workspaceRoot: string;
+};
+/**
+ * Nixpacks-style child processes for foreign packages in a flux serve slice.
+ * Killed when the Flux container disposes (SIGINT → RootModule teardown).
+ */
+export declare class DeferredScriptRunner implements AsyncDisposable {
+    private readonly logger;
+    private readonly children;
+    start(options: DeferredScriptStart): ChildProcess;
+    [Symbol.asyncDispose](): Promise<void>;
+}

package/types/src/{ember.command.d.ts → flux.command.d.ts}

@@ -1,6 +1,6 @@
 import type { Actions } from "@decohere/nexus/cli";
 import { type CommandHandler, type CommandResponse, type CommandType, DecohereCommand } from "@decohere/nexus/cli";
-export declare class EmberCommand extends DecohereCommand {
+export declare class FluxCommand extends DecohereCommand {
     constructor(commands: Record<string, CommandType>, handler: CommandHandler);
     run(_actions: Actions, _options: never): Promise<CommandResponse>;
 }

package/types/src/flux.module.d.ts

@@ -0,0 +1,16 @@
+import type { WorkspaceFactoryOptions } from "@decohere/nexus/cli";
+import { ModuleManifest } from "@decohere/nexus/cli";
+import type { ContainerBuilder } from "@decohere/nexus/composition";
+import { FluxCommand } from "./flux.command.js";
+import { RunAction } from "./run.action.js";
+import { ServeAction } from "./serve.action.js";
+export declare class FluxModule extends ModuleManifest {
+    readonly id = "flux";
+    readonly command: typeof FluxCommand;
+    readonly actions: {
+        serve: typeof ServeAction;
+        run: typeof RunAction;
+    };
+    registerServices(builder: ContainerBuilder): void;
+    createWorkspace(options: WorkspaceFactoryOptions): Promise<import("@decohere/mesh").Workspace>;
+}

package/types/src/hot-reload-server.d.ts

@@ -1,38 +1,78 @@
 import { EventEmitter } from "node:events";
-import type { Logger } from "@decohere/scribe";
+import type { Workspace } from "@decohere/mesh";
+/** Default quiet window before a file-change reboot. */
+export declare const DEFAULT_REBOOT_DEBOUNCE_MS = 250;
+export declare function resolveRebootDebounceMs(value: number | undefined): number;
 export interface HotReloadServerEvents {
+    start: [];
     reboot: [];
 }
+export interface HotReloadServerOptions {
+    /** Build configuration name. */
+    buildConfig: string;
+    /** Name of the project to serve. Defaults to the first project in the workspace. */
+    project?: string;
+    /**
+     * Multiple Flux app package names to boot in one process (directory slice).
+     * When set, takes precedence over {@link project}.
+     */
+    projects?: readonly string[];
+    /**
+     * Pre-built Workspace instance to use instead of running WorkspaceFactory.
+     * Useful in tests to bypass filesystem-based workspace discovery.
+     */
+    workspace?: Workspace;
+    /**
+     * Quiet window in milliseconds after the last affecting save before a reboot.
+     * Defaults to {@link DEFAULT_REBOOT_DEBOUNCE_MS}. Raise this for agent save trains.
+     */
+    rebootDebounceMs?: number;
+}
 export declare class HotReloadServer extends EventEmitter<HotReloadServerEvents> {
     private readonly logger;
+    private readonly loader;
     private disposed;
-    private entryModule;
-    private entry;
-    private sourceFiles;
+    /** Absolute entry paths currently served (one or more Flux apps). */
+    private entries;
+    private pendingEntryReboots;
+    private watchSubscription?;
     private moduleCache;
     private dependencies;
-    private watchers;
-    constructor(logger: Logger);
-    start(entry: string, ...watchDirs: string[]): Promise<void>;
+    private rebootTail;
+    private rebootDebounceGen;
+    private rebootInFlight;
+    private rebootFollowUp;
+    private rebootQueued;
+    /** Modules whose reverse-graph edges are pruned at reboot, not on schedule. */
+    private pendingGraphPrune;
+    private scheduleReboot;
+    start(options: HotReloadServerOptions): Promise<void>;
     dispose(): Promise<void>;
-    private removeSourceFiles;
-    private getSourceFiles;
-    private configureModuleHooks;
-    private onResolve;
-    private isSourceModule;
+    [Symbol.asyncDispose](): Promise<void>;
+    private bootEntries;
+    private bootEntry;
+    private bindScheduleReboot;
+    private requestReboot;
+    private runReboot;
+    private disposeEntries;
+    private disposeEntry;
+    private requireWorkspace;
+    private resolveProjects;
+    /**
+     * Post-next dependency tracker: records which source files import which
+     * other source files so that reloadIfAffected can traverse the graph.
+     */
+    private onPostResolve;
+    private onFileChange;
+    private reloadIfAffected;
     private getDependencyGraph;
     private trackDependency;
     private getCachedOrNew;
     private versionModule;
-    private watch;
-    private onFileAdded;
-    private onSourceFileChanged;
-    private onFileDeleted;
-    private reloadIfAffected;
-    private isSelf;
-    private invlidateModule;
+    private invalidateModuleCaches;
+    private prunePendingDependencyEdges;
+    /** Remove these modules as parents so boot can rebuild edges without stale importers. */
+    private pruneDependencyParents;
     private invalidateAllSourceFiles;
-    private disposeAndBoot;
-    private disposeEntry;
-    private bootEntry;
+    private isSelf;
 }

package/types/src/index.d.ts

@@ -1,9 +1,9 @@
-export { EmberCommand } from "./ember.command.js";
-export type { EmberModuleContext, EmberModuleResult } from "./ember.module.js";
-export { EmberActions, EmberModule } from "./ember.module.js";
-export * from "./hot-reload-server.js";
+export { DeferredScriptRunner } from "./deferred-script-runner.js";
+export { FluxModule } from "./flux.module.js";
+export type { HotReloadServerOptions } from "./hot-reload-server.js";
+export { DEFAULT_REBOOT_DEBOUNCE_MS, HotReloadServer } from "./hot-reload-server.js";
+export type { RunOptions } from "./run.action.js";
 export type { ServeOptions } from "./serve.action.js";
-export { ServeAction } from "./serve.action.js";
-export { ServeCommand } from "./serve.command.js";
-export type { WorkspaceServeOptions } from "./workspace-serve.action.js";
-export { WorkspaceServeAction } from "./workspace-serve.action.js";
+export { type ClassifiedSlice, classifySliceProject, classifySliceProjects, normalizeSlicePrefix, projectsInSlice, projectsInSlices, resolveDeferScript, type SliceKind, type SliceProjectView, } from "./slice-serve.js";
+export type { SourceModuleLoaderOptions } from "./source-module-loader.js";
+export { SourceModuleLoader } from "./source-module-loader.js";

package/types/src/rewrite-serve-specifier.d.ts

@@ -0,0 +1,13 @@
+export type RewriteServeSpecifierOptions = {
+    specifier: string;
+    parentUrl: string;
+    isWatchedTs: (absolutePath: string) => boolean;
+    resolveBare: (specifier: string) => string | null;
+    versionFileUrl: (fileUrl: string) => string;
+};
+/**
+ * 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 declare function rewriteServeSpecifier(options: RewriteServeSpecifierOptions): string | null;

package/types/src/run.action.d.ts

@@ -0,0 +1,17 @@
+import { Workspace } from "@decohere/mesh";
+import { type Action, ActionResponse } from "@decohere/nexus/cli";
+import { SourceModuleLoader } from "./source-module-loader.js";
+export type RunOptions = {
+    /** Absolute or cwd-relative path to a `.ts` entry file. */
+    entry: string;
+    configuration: string;
+    /** Arguments forwarded to the entry (bin-style `process.argv.slice(2)`). */
+    args?: string[];
+};
+export declare class RunAction implements Action<RunOptions> {
+    private readonly loader;
+    private readonly workspace;
+    private readonly logger;
+    constructor(loader: SourceModuleLoader, workspace: Workspace);
+    run(options: RunOptions): Promise<ActionResponse>;
+}

package/types/src/run.command.d.ts

@@ -0,0 +1,11 @@
+import { DecohereCommand } from "@decohere/nexus/cli";
+import { RunAction } from "./run.action.js";
+export declare class RunCommand extends DecohereCommand {
+    get actions(): (typeof RunAction)[];
+    constructor(name: string);
+    /**
+     * 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: (...args: any[]) => void | Promise<void>): this;
+}

package/types/src/serve.action.d.ts

@@ -1,8 +1,23 @@
+import { Workspace } from "@decohere/mesh";
 import { type Action, ActionResponse } from "@decohere/nexus/cli";
+import { DeferredScriptRunner } from "./deferred-script-runner.js";
+import { HotReloadServer } from "./hot-reload-server.js";
 export type ServeOptions = {
-    entry: string;
-    watchDir: string;
+    configuration: string;
+    project?: string;
+    /** One or more module directory tokens (`funding`, `shell`, `projects/funding`). */
+    slices?: string[];
+    rebootDebounceMs?: number;
 };
 export declare class ServeAction implements Action<ServeOptions> {
+    private readonly server;
+    private readonly workspace;
+    private readonly deferredScripts;
+    private readonly logger;
+    constructor(server: HotReloadServer, workspace: Workspace, deferredScripts: DeferredScriptRunner);
     run(options: ServeOptions): Promise<ActionResponse>;
+    private runSlices;
+    private toSliceViews;
+    private toSliceView;
+    private findProject;
 }

package/types/src/serve.command.d.ts

@@ -1,6 +1,11 @@
 import { DecohereCommand } from "@decohere/nexus/cli";
-import { WorkspaceServeAction } from "./workspace-serve.action.js";
+import { ServeAction } from "./serve.action.js";
 export declare class ServeCommand extends DecohereCommand {
-    get actions(): (typeof WorkspaceServeAction)[];
+    get actions(): (typeof ServeAction)[];
     constructor(name: string);
+    /**
+     * Commander passes positional args before options when `[slices...]` is declared.
+     * The CLI host ModuleFactory expects `(opts, cmd)` — normalize here.
+     */
+    action(fn: (...args: any[]) => void | Promise<void>): this;
 }

package/types/src/slice-serve.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Directory-slice helpers for `flux serve <dir>…` — classify Mesh packages as
+ * Flux apps, Nixpacks-style script deferrals, or libraries to skip.
+ */
+export type SliceProjectView = {
+    readonly name: string;
+    /** Relative project dir from workspace root (e.g. `projects/funding/api`). */
+    readonly projectDirectory: string;
+    readonly main: string;
+    readonly scripts: Record<string, string>;
+};
+export type SliceKind = "flux" | "defer" | "skip";
+export type ClassifiedSlice = {
+    readonly flux: SliceProjectView[];
+    readonly defer: SliceProjectView[];
+    readonly skip: SliceProjectView[];
+};
+/** Preferred package scripts for foreign toolchains (Nixpacks-style). */
+export declare const DEFER_SCRIPT_CANDIDATES: readonly ["dev", "serve"];
+/**
+ * Normalize a CLI slice token to a `projects/…` prefix without a trailing slash.
+ * `funding` and `projects/funding` both become `projects/funding`.
+ */
+export declare function normalizeSlicePrefix(slice: string): string;
+/**
+ * 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 declare function isUnderSlice(projectDirectory: string, slicePrefix: string): boolean;
+export declare function projectsInSlice(projects: readonly SliceProjectView[], slice: string): SliceProjectView[];
+/** Union of packages under any of the slice tokens (deduped by package name). */
+export declare function projectsInSlices(projects: readonly SliceProjectView[], slices: readonly string[]): SliceProjectView[];
+/** Script invokes Flux (in-process serve stays on Flux, not deferred). */
+export declare function isFluxOwnedScript(script: string): boolean;
+/**
+ * First Nixpacks-style serve script that is not Flux-owned.
+ * Prefers `dev`, then `serve`.
+ */
+export declare function resolveDeferScript(scripts: Record<string, string>): string | undefined;
+/** Convention: Flux Node apps use `main` ending in `main.ts` / `main.tsx`. */
+export declare function isFluxAppMain(main: string): boolean;
+/**
+ * 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 declare function classifySliceProject(project: SliceProjectView): SliceKind;
+export declare function classifySliceProjects(projects: readonly SliceProjectView[], slices: string | readonly string[]): ClassifiedSlice;

package/types/src/source-module-loader.d.ts

@@ -0,0 +1,49 @@
+import type { ResolveFnOutput } from "node:module";
+import type { Project, Workspace } from "@decohere/mesh";
+export interface SourceModuleLoaderOptions {
+    /** Build configuration name. */
+    buildConfig: string;
+    /**
+     * Pre-built Workspace instance to use instead of running WorkspaceFactory.
+     * Useful in tests to bypass filesystem-based workspace discovery.
+     */
+    workspace?: Workspace;
+    /**
+     * Map a watched `.ts` file URL for ESM resolution.
+     * Hot reload passes a `?version=` bust; one-shot run uses identity.
+     */
+    versionFileUrl?: (fileUrl: string) => string;
+    /** Optional post-resolve hook (e.g. dependency tracking for HMR). */
+    onResolved?: (result: ResolveFnOutput, parentUrl: string) => void;
+}
+/**
+ * Registers Node ESM resolve/load hooks and SWC-transpiles workspace `.ts`
+ * on the fly. No file watching and no entry reboot — that belongs to
+ * {@link HotReloadServer}.
+ */
+export declare class SourceModuleLoader {
+    private readonly logger;
+    private readonly transpiler;
+    private disposed;
+    private hooksRegistered;
+    private workspace?;
+    private buildConfig;
+    private fileInfoMap;
+    private transpileCache;
+    private aliasPaths;
+    private aliasBaseUrl;
+    private versionFileUrl;
+    private onResolved?;
+    getWorkspace(): Workspace | undefined;
+    getBuildConfig(): string;
+    hasSourceFile(absolutePath: string): boolean;
+    sourceFilePaths(): IterableIterator<string>;
+    setSourceFile(absolutePath: string, project: Project): void;
+    configure(options: SourceModuleLoaderOptions): Promise<void>;
+    registerHooks(): void;
+    importEntry(absolutePath: string): Promise<unknown>;
+    invalidateTranspile(...absolutePaths: string[]): void;
+    dispose(): void;
+    private buildFileInfoMap;
+    private loadTs;
+}

package/commonjs/src/ember.command.js

@@ -1,27 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "EmberCommand", {
-    enumerable: true,
-    get: function() {
-        return EmberCommand;
-    }
-});
-const _cli = require("@decohere/nexus/cli");
-const _servecommand = require("./serve.command.js");
-class EmberCommand extends _cli.DecohereCommand {
-    constructor(commands, handler){
-        super(EmberCommand);
-        this.exitOverride();
-        this.registerSubcommand({
-            serve: _servecommand.ServeCommand,
-            ...commands
-        }, handler);
-    }
-    run(_actions, _options) {
-        return this.help();
-    }
-}
-
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL2ZsdXgvc3JjL2VtYmVyLmNvbW1hbmQudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBBY3Rpb25zIH0gZnJvbSBcIkBkZWNvaGVyZS9uZXh1cy9jbGlcIjtcbmltcG9ydCB7XG5cdHR5cGUgQ29tbWFuZEhhbmRsZXIsXG5cdHR5cGUgQ29tbWFuZFJlc3BvbnNlLFxuXHR0eXBlIENvbW1hbmRUeXBlLFxuXHREZWNvaGVyZUNvbW1hbmQsXG59IGZyb20gXCJAZGVjb2hlcmUvbmV4dXMvY2xpXCI7XG5pbXBvcnQgeyBTZXJ2ZUNvbW1hbmQgfSBmcm9tIFwiLi9zZXJ2ZS5jb21tYW5kLmpzXCI7XG5cbmV4cG9ydCBjbGFzcyBFbWJlckNvbW1hbmQgZXh0ZW5kcyBEZWNvaGVyZUNvbW1hbmQge1xuXHRwdWJsaWMgY29uc3RydWN0b3IoY29tbWFuZHM6IFJlY29yZDxzdHJpbmcsIENvbW1hbmRUeXBlPiwgaGFuZGxlcjogQ29tbWFuZEhhbmRsZXIpIHtcblx0XHRzdXBlcihFbWJlckNvbW1hbmQpO1xuXHRcdHRoaXMuZXhpdE92ZXJyaWRlKCk7XG5cdFx0dGhpcy5yZWdpc3RlclN1YmNvbW1hbmQoeyBzZXJ2ZTogU2VydmVDb21tYW5kLCAuLi5jb21tYW5kcyB9LCBoYW5kbGVyKTtcblx0fVxuXG5cdHB1YmxpYyBydW4oX2FjdGlvbnM6IEFjdGlvbnMsIF9vcHRpb25zOiBuZXZlcik6IFByb21pc2U8Q29tbWFuZFJlc3BvbnNlPiB7XG5cdFx0cmV0dXJuIHRoaXMuaGVscCgpO1xuXHR9XG59XG4iXSwibmFtZXMiOlsiRW1iZXJDb21tYW5kIiwiRGVjb2hlcmVDb21tYW5kIiwiY29tbWFuZHMiLCJoYW5kbGVyIiwiZXhpdE92ZXJyaWRlIiwicmVnaXN0ZXJTdWJjb21tYW5kIiwic2VydmUiLCJTZXJ2ZUNvbW1hbmQiLCJydW4iLCJfYWN0aW9ucyIsIl9vcHRpb25zIiwiaGVscCJdLCJtYXBwaW5ncyI6Ijs7OzsrQkFTYUE7OztlQUFBQTs7O3FCQUhOOzhCQUNzQjtBQUV0QixNQUFNQSxxQkFBcUJDLG9CQUFlO0lBQ2hELFlBQW1CQyxRQUFxQyxFQUFFQyxPQUF1QixDQUFFO1FBQ2xGLEtBQUssQ0FBQ0g7UUFDTixJQUFJLENBQUNJLFlBQVk7UUFDakIsSUFBSSxDQUFDQyxrQkFBa0IsQ0FBQztZQUFFQyxPQUFPQywwQkFBWTtZQUFFLEdBQUdMLFFBQVE7UUFBQyxHQUFHQztJQUMvRDtJQUVPSyxJQUFJQyxRQUFpQixFQUFFQyxRQUFlLEVBQTRCO1FBQ3hFLE9BQU8sSUFBSSxDQUFDQyxJQUFJO0lBQ2pCO0FBQ0QifQ==