@decohere/flux 0.0.1-dev.38 → 0.0.1-dev.4

package/tests/hmr.integration.spec.js

@@ -0,0 +1,134 @@
+/**
+ * Integration: HotReloadServer full reload cycle with real Node hooks + memfs.
+ *
+ * How it works:
+ * - Fixtures exist on disk so vite-node can resolve and externalize them
+ * - vi.mock("fs") / vi.mock("node:fs") redirects all fs calls to memfs
+ * - The load hook in hmr.external-module.setup.ts intercepts externalized
+ *   module loads and serves content from vol when present
+ * - onResolve rewrites URLs to versioned copies after a file is invalidated,
+ *   which forces Node to bypass its module cache on next import
+ *
+ * Fixture tree:  main.js → dep-a.js → dep-b.js
+ */ import { scribe } from "../../scribe/scribe/src/index.js";
+import { vol } from "memfs";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+vi.mock("fs");
+vi.mock("node:fs");
+import { HotReloadServer } from "../src/hot-reload-server.js";
+const fixturesDir = new URL("./__fixtures__/hmr", import.meta.url).pathname;
+const mainPath = `${fixturesDir}/main.js`;
+const depAPath = `${fixturesDir}/dep-a.js`;
+const depBPath = `${fixturesDir}/dep-b.js`;
+async function seedFromDisk() {
+    const realFs = await vi.importActual("node:fs");
+    vol.fromJSON({
+        [mainPath]: realFs.readFileSync(mainPath, "utf8"),
+        [depAPath]: realFs.readFileSync(depAPath, "utf8"),
+        [depBPath]: realFs.readFileSync(depBPath, "utf8")
+    });
+}
+function nextReboot(server, ms = 2000) {
+    return new Promise((resolve, reject)=>{
+        const timer = setTimeout(()=>reject(new Error("reboot did not fire")), ms);
+        server.once("reboot", ()=>{
+            clearTimeout(timer);
+            resolve();
+        });
+    });
+}
+describe("HotReloadServer real hook integration", ()=>{
+    let server;
+    beforeEach(async ()=>{
+        server = new HotReloadServer(scribe.logger("HotReloadServerTest"));
+        await seedFromDisk();
+        await server.start(mainPath, fixturesDir);
+    });
+    afterEach(async ()=>{
+        await server.dispose();
+        vol.reset();
+    });
+    it("should not ghost-reboot when a module is removed from the dependency graph after a reload", async ()=>{
+        // Remove dep-b from dep-a's imports — triggers reboot
+        const reboot1 = nextReboot(server);
+        vol.writeFileSync(depAPath, `export const value = 0;`);
+        await reboot1;
+        // dep-b is no longer imported — changing it must not reboot
+        let rebooted = false;
+        server.once("reboot", ()=>{
+            rebooted = true;
+        });
+        vol.writeFileSync(depBPath, `export const value = 42;`);
+        await new Promise((resolve)=>setTimeout(resolve, 500));
+        expect(rebooted).toBe(false);
+    });
+    it("should not infinitely recurse and should still reboot when a circular dependency is detected", async ()=>{
+        // Inject a back-edge: dep-b → dep-a, creating dep-a ↔ dep-b cycle
+        const deps = server.dependencies;
+        deps.set(depBPath, [
+            ...deps.get(depBPath) ?? [],
+            depAPath
+        ]);
+        const reboot = nextReboot(server);
+        vol.writeFileSync(depBPath, `export const value = 99;`);
+        await reboot;
+    });
+    it("should reboot when dep-b is re-added after being removed and re-referenced out of order", async ()=>{
+        // Step 1: delete dep-b — graph preserved
+        vol.unlinkSync(depBPath);
+        // Step 2: update dep-a to remove dep-b reference — triggers reboot
+        const reboot1 = nextReboot(server);
+        vol.writeFileSync(depAPath, `export const value = 0;`);
+        await reboot1;
+        // Step 3: update dep-a to re-add dep-b reference — triggers reboot
+        const reboot2 = nextReboot(server);
+        vol.writeFileSync(depAPath, `export { value } from "./dep-b.js";`);
+        await reboot2;
+        // Step 4: add dep-b back — graph still has dep-b → dep-a → main, reboot expected
+        const reboot3 = nextReboot(server);
+        vol.writeFileSync(depBPath, `export const value = 99;`);
+        await reboot3;
+    });
+    it("should reboot when a deleted file is re-added with new content", async ()=>{
+        vol.unlinkSync(depBPath);
+        vol.writeFileSync(depBPath, `export const value = 99;`);
+        const reboot = nextReboot(server);
+        await reboot;
+    });
+    it("should not reboot when a deleted dependency is no longer in the graph", async ()=>{
+        // Delete dep-a, then touch main to get a deterministic sync point —
+        // once main's reboot fires we know the watcher has processed the delete.
+        vol.unlinkSync(depAPath);
+        const sync = nextReboot(server);
+        vol.writeFileSync(mainPath, vol.readFileSync(mainPath, "utf8"));
+        await sync;
+        // Now dep-b has no path to main — changing it must not reboot.
+        let rebooted = false;
+        server.once("reboot", ()=>{
+            rebooted = true;
+        });
+        vol.writeFileSync(depBPath, `export const value = 42;`);
+        await new Promise((resolve)=>setTimeout(resolve, 500));
+        expect(rebooted).toBe(false);
+    });
+    it("should call asyncDispose on the entry when the server is disposed", async ()=>{
+        await server.dispose();
+        expect(vol.existsSync("/disposed.txt")).toBe(true);
+    });
+    it("should reload a direct dependency and serve updated content", async ()=>{
+        const reboot = nextReboot(server);
+        vol.writeFileSync(depAPath, `export { value } from "./dep-b.js"; export const tag = "v2";`);
+        await reboot;
+        const mod = await import(depAPath);
+        expect(mod.tag).toBe("v2");
+    });
+    it("should reload a grandchild dependency and propagate the change to its parent", async ()=>{
+        const reboot = nextReboot(server);
+        vol.writeFileSync(depBPath, `export const value = 99;`);
+        await reboot;
+        const mod = await import(depBPath);
+        expect(mod.value).toBe(99);
+    });
+});
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/flux/tests/hmr.integration.spec.ts"],"sourcesContent":["/**\n * Integration: HotReloadServer full reload cycle with real Node hooks + memfs.\n *\n * How it works:\n * - Fixtures exist on disk so vite-node can resolve and externalize them\n * - vi.mock(\"fs\") / vi.mock(\"node:fs\") redirects all fs calls to memfs\n * - The load hook in hmr.external-module.setup.ts intercepts externalized\n *   module loads and serves content from vol when present\n * - onResolve rewrites URLs to versioned copies after a file is invalidated,\n *   which forces Node to bypass its module cache on next import\n *\n * Fixture tree:  main.js → dep-a.js → dep-b.js\n */\n\nimport { scribe } from \"@decohere/scribe\";\nimport { vol } from \"memfs\";\nimport { afterEach, beforeEach, describe, expect, it, vi } from \"vitest\";\n\nvi.mock(\"fs\");\nvi.mock(\"node:fs\");\n\nimport { HotReloadServer } from \"../src/hot-reload-server.js\";\n\nconst fixturesDir = new URL(\"./__fixtures__/hmr\", import.meta.url).pathname;\nconst mainPath = `${fixturesDir}/main.js`;\nconst depAPath = `${fixturesDir}/dep-a.js`;\nconst depBPath = `${fixturesDir}/dep-b.js`;\n\nasync function seedFromDisk() {\n\tconst realFs = await vi.importActual<typeof import(\"node:fs\")>(\"node:fs\");\n\tvol.fromJSON({\n\t\t[mainPath]: realFs.readFileSync(mainPath, \"utf8\") as string,\n\t\t[depAPath]: realFs.readFileSync(depAPath, \"utf8\") as string,\n\t\t[depBPath]: realFs.readFileSync(depBPath, \"utf8\") as string,\n\t});\n}\n\nfunction nextReboot(server: HotReloadServer, ms = 2000): Promise<void> {\n\treturn new Promise((resolve, reject) => {\n\t\tconst timer = setTimeout(() => reject(new Error(\"reboot did not fire\")), ms);\n\t\tserver.once(\"reboot\", () => {\n\t\t\tclearTimeout(timer);\n\t\t\tresolve();\n\t\t});\n\t});\n}\n\ndescribe(\"HotReloadServer real hook integration\", () => {\n\tlet server: HotReloadServer;\n\n\tbeforeEach(async () => {\n\t\tserver = new HotReloadServer(scribe.logger(\"HotReloadServerTest\"));\n\t\tawait seedFromDisk();\n\t\tawait server.start(mainPath, fixturesDir);\n\t});\n\n\tafterEach(async () => {\n\t\tawait server.dispose();\n\t\tvol.reset();\n\t});\n\n\tit(\"should not ghost-reboot when a module is removed from the dependency graph after a reload\", async () => {\n\t\t// Remove dep-b from dep-a's imports — triggers reboot\n\t\tconst reboot1 = nextReboot(server);\n\t\tvol.writeFileSync(depAPath, `export const value = 0;`);\n\t\tawait reboot1;\n\n\t\t// dep-b is no longer imported — changing it must not reboot\n\t\tlet rebooted = false;\n\t\tserver.once(\"reboot\", () => {\n\t\t\trebooted = true;\n\t\t});\n\t\tvol.writeFileSync(depBPath, `export const value = 42;`);\n\t\tawait new Promise((resolve) => setTimeout(resolve, 500));\n\t\texpect(rebooted).toBe(false);\n\t});\n\n\tit(\"should not infinitely recurse and should still reboot when a circular dependency is detected\", async () => {\n\t\t// Inject a back-edge: dep-b → dep-a, creating dep-a ↔ dep-b cycle\n\t\tconst deps = (server as unknown as { dependencies: Map<string, string[]> }).dependencies;\n\t\tdeps.set(depBPath, [...(deps.get(depBPath) ?? []), depAPath]);\n\n\t\tconst reboot = nextReboot(server);\n\t\tvol.writeFileSync(depBPath, `export const value = 99;`);\n\t\tawait reboot;\n\t});\n\n\tit(\"should reboot when dep-b is re-added after being removed and re-referenced out of order\", async () => {\n\t\t// Step 1: delete dep-b — graph preserved\n\t\tvol.unlinkSync(depBPath);\n\n\t\t// Step 2: update dep-a to remove dep-b reference — triggers reboot\n\t\tconst reboot1 = nextReboot(server);\n\t\tvol.writeFileSync(depAPath, `export const value = 0;`);\n\t\tawait reboot1;\n\n\t\t// Step 3: update dep-a to re-add dep-b reference — triggers reboot\n\t\tconst reboot2 = nextReboot(server);\n\t\tvol.writeFileSync(depAPath, `export { value } from \"./dep-b.js\";`);\n\t\tawait reboot2;\n\n\t\t// Step 4: add dep-b back — graph still has dep-b → dep-a → main, reboot expected\n\t\tconst reboot3 = nextReboot(server);\n\t\tvol.writeFileSync(depBPath, `export const value = 99;`);\n\t\tawait reboot3;\n\t});\n\n\tit(\"should reboot when a deleted file is re-added with new content\", async () => {\n\t\tvol.unlinkSync(depBPath);\n\t\tvol.writeFileSync(depBPath, `export const value = 99;`);\n\t\tconst reboot = nextReboot(server);\n\t\tawait reboot;\n\t});\n\n\tit(\"should not reboot when a deleted dependency is no longer in the graph\", async () => {\n\t\t// Delete dep-a, then touch main to get a deterministic sync point —\n\t\t// once main's reboot fires we know the watcher has processed the delete.\n\t\tvol.unlinkSync(depAPath);\n\t\tconst sync = nextReboot(server);\n\t\tvol.writeFileSync(mainPath, vol.readFileSync(mainPath, \"utf8\") as string);\n\t\tawait sync;\n\n\t\t// Now dep-b has no path to main — changing it must not reboot.\n\t\tlet rebooted = false;\n\t\tserver.once(\"reboot\", () => {\n\t\t\trebooted = true;\n\t\t});\n\t\tvol.writeFileSync(depBPath, `export const value = 42;`);\n\t\tawait new Promise((resolve) => setTimeout(resolve, 500));\n\t\texpect(rebooted).toBe(false);\n\t});\n\n\tit(\"should call asyncDispose on the entry when the server is disposed\", async () => {\n\t\tawait server.dispose();\n\t\texpect(vol.existsSync(\"/disposed.txt\")).toBe(true);\n\t});\n\n\tit(\"should reload a direct dependency and serve updated content\", async () => {\n\t\tconst reboot = nextReboot(server);\n\t\tvol.writeFileSync(\n\t\t\tdepAPath,\n\t\t\t`export { value } from \"./dep-b.js\"; export const tag = \"v2\";`,\n\t\t);\n\t\tawait reboot;\n\t\tconst mod = await import(depAPath);\n\t\texpect(mod.tag).toBe(\"v2\");\n\t});\n\n\tit(\"should reload a grandchild dependency and propagate the change to its parent\", async () => {\n\t\tconst reboot = nextReboot(server);\n\t\tvol.writeFileSync(depBPath, `export const value = 99;`);\n\t\tawait reboot;\n\t\tconst mod = await import(depBPath);\n\t\texpect(mod.value).toBe(99);\n\t});\n});\n"],"names":["scribe","vol","afterEach","beforeEach","describe","expect","it","vi","mock","HotReloadServer","fixturesDir","URL","url","pathname","mainPath","depAPath","depBPath","seedFromDisk","realFs","importActual","fromJSON","readFileSync","nextReboot","server","ms","Promise","resolve","reject","timer","setTimeout","Error","once","clearTimeout","logger","start","dispose","reset","reboot1","writeFileSync","rebooted","toBe","deps","dependencies","set","get","reboot","unlinkSync","reboot2","reboot3","sync","existsSync","mod","tag","value"],"mappings":"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"}

package/commonjs/src/flux.command.js

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

package/commonjs/src/flux.module.js

@@ -1,32 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "FluxModule", {
-    enumerable: true,
-    get: function() {
-        return FluxModule;
-    }
-});
-const _mesh = require("@decohere/mesh");
-const _cli = require("@decohere/nexus/cli");
-const _fluxcommand = require("./flux.command.js");
-const _hotreloadserver = require("./hot-reload-server.js");
-const _serveaction = require("./serve.action.js");
-class FluxModule extends _cli.ModuleManifest {
-    id = "flux";
-    command = _fluxcommand.FluxCommand;
-    actions = {
-        serve: _serveaction.ServeAction
-    };
-    registerServices(builder) {
-        builder.registerSingleton(_hotreloadserver.HotReloadServer);
-    }
-    createWorkspace(options) {
-        return _mesh.WorkspaceFactory.create({
-            configFile: options.configFile
-        });
-    }
-}
-
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL2ZsdXgvc3JjL2ZsdXgubW9kdWxlLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFdvcmtzcGFjZUZhY3RvcnkgfSBmcm9tIFwiQGRlY29oZXJlL21lc2hcIjtcbmltcG9ydCB0eXBlIHsgV29ya3NwYWNlRmFjdG9yeU9wdGlvbnMgfSBmcm9tIFwiQGRlY29oZXJlL25leHVzL2NsaVwiO1xuaW1wb3J0IHsgTW9kdWxlTWFuaWZlc3QgfSBmcm9tIFwiQGRlY29oZXJlL25leHVzL2NsaVwiO1xuaW1wb3J0IHR5cGUgeyBDb250YWluZXJCdWlsZGVyIH0gZnJvbSBcIkBkZWNvaGVyZS9uZXh1cy9jb21wb3NpdGlvblwiO1xuaW1wb3J0IHsgRmx1eENvbW1hbmQgfSBmcm9tIFwiLi9mbHV4LmNvbW1hbmQuanNcIjtcbmltcG9ydCB7IEhvdFJlbG9hZFNlcnZlciB9IGZyb20gXCIuL2hvdC1yZWxvYWQtc2VydmVyLmpzXCI7XG5pbXBvcnQgeyBTZXJ2ZUFjdGlvbiB9IGZyb20gXCIuL3NlcnZlLmFjdGlvbi5qc1wiO1xuXG5leHBvcnQgY2xhc3MgRmx1eE1vZHVsZSBleHRlbmRzIE1vZHVsZU1hbmlmZXN0IHtcblx0cHVibGljIHJlYWRvbmx5IGlkID0gXCJmbHV4XCI7XG5cdHB1YmxpYyByZWFkb25seSBjb21tYW5kID0gRmx1eENvbW1hbmQ7XG5cdHB1YmxpYyByZWFkb25seSBhY3Rpb25zID0ge1xuXHRcdHNlcnZlOiBTZXJ2ZUFjdGlvbixcblx0fTtcblxuXHRwdWJsaWMgcmVnaXN0ZXJTZXJ2aWNlcyhidWlsZGVyOiBDb250YWluZXJCdWlsZGVyKSB7XG5cdFx0YnVpbGRlci5yZWdpc3RlclNpbmdsZXRvbihIb3RSZWxvYWRTZXJ2ZXIpO1xuXHR9XG5cblx0cHVibGljIG92ZXJyaWRlIGNyZWF0ZVdvcmtzcGFjZShvcHRpb25zOiBXb3Jrc3BhY2VGYWN0b3J5T3B0aW9ucykge1xuXHRcdHJldHVybiBXb3Jrc3BhY2VGYWN0b3J5LmNyZWF0ZSh7IGNvbmZpZ0ZpbGU6IG9wdGlvbnMuY29uZmlnRmlsZSB9KTtcblx0fVxufVxuIl0sIm5hbWVzIjpbIkZsdXhNb2R1bGUiLCJNb2R1bGVNYW5pZmVzdCIsImlkIiwiY29tbWFuZCIsIkZsdXhDb21tYW5kIiwiYWN0aW9ucyIsInNlcnZlIiwiU2VydmVBY3Rpb24iLCJyZWdpc3RlclNlcnZpY2VzIiwiYnVpbGRlciIsInJlZ2lzdGVyU2luZ2xldG9uIiwiSG90UmVsb2FkU2VydmVyIiwiY3JlYXRlV29ya3NwYWNlIiwib3B0aW9ucyIsIldvcmtzcGFjZUZhY3RvcnkiLCJjcmVhdGUiLCJjb25maWdGaWxlIl0sIm1hcHBpbmdzIjoiOzs7OytCQVFhQTs7O2VBQUFBOzs7c0JBUm9CO3FCQUVGOzZCQUVIO2lDQUNJOzZCQUNKO0FBRXJCLE1BQU1BLG1CQUFtQkMsbUJBQWM7SUFDN0JDLEtBQUssT0FBTztJQUNaQyxVQUFVQyx3QkFBVyxDQUFDO0lBQ3RCQyxVQUFVO1FBQ3pCQyxPQUFPQyx3QkFBVztJQUNuQixFQUFFO0lBRUtDLGlCQUFpQkMsT0FBeUIsRUFBRTtRQUNsREEsUUFBUUMsaUJBQWlCLENBQUNDLGdDQUFlO0lBQzFDO0lBRWdCQyxnQkFBZ0JDLE9BQWdDLEVBQUU7UUFDakUsT0FBT0Msc0JBQWdCLENBQUNDLE1BQU0sQ0FBQztZQUFFQyxZQUFZSCxRQUFRRyxVQUFVO1FBQUM7SUFDakU7QUFDRCJ9