@reventlessdev/reventless-gwt 1.0.0-alpha.74 → 1.0.0-alpha.76

package/src/WatcherProbe.res.mjs

@@ -3,13 +3,25 @@
 import * as Nodefs from "node:fs";
 import * as Nodepath from "node:path";
 import * as Stdlib_Int from "@rescript/runtime/lib/es6/Stdlib_Int.js";
+import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
+import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+
+let _errCode = ((e) => (e && typeof e.code === "string") ? e.code : undefined);
 
 function isAlive(pid) {
   try {
     process.kill(pid, 0);
     return true;
-  } catch (exn) {
-    return false;
+  } catch (raw_exn) {
+    let exn = Primitive_exceptions.internalToException(raw_exn);
+    let e = Stdlib_JsExn.fromException(exn);
+    if (e !== undefined) {
+      return Primitive_object.equal(_errCode(Primitive_option.valFromOption(e)), "EPERM");
+    } else {
+      return false;
+    }
   }
 }
 
@@ -38,6 +50,7 @@ function hasLiveWatcher(dir) {
 }
 
 export {
+  _errCode,
   isAlive,
   libLock,
   lockHasLivePid,

package/src/Worker.res

@@ -0,0 +1,24 @@
+// Minimal `node:worker_threads` binding for gwt watch re-runs.
+//
+// Node's ESM module registry is keyed by URL and never evicts, so re-importing a
+// recompiled test file in the same process replays tests that close over the
+// *old* instances of their statically-imported implementation modules (the
+// Loader can only cache-bust the test file's own URL, not its transitive
+// imports). Running each watch re-run in a short-lived Worker gives it a fresh
+// registry — the recompiled modules are re-imported — and reclaims the whole
+// imported graph on worker exit (fixing the monotonic-buster memory leak).
+
+type t
+type workerOptions<'a> = {workerData: 'a}
+type url
+
+@new @module("node:worker_threads")
+external make: (url, workerOptions<'a>) => t = "Worker"
+
+// A worker's stdout is piped to the parent's process.stdout by default, so the
+// NDJSON the formatters write inside the worker reaches the client unchanged.
+@send external on: (t, string, 'cb) => unit = "on"
+@send external terminate: t => promise<int> = "terminate"
+
+// The compiled worker entry lives next to this module in the in-source build.
+let runWorkerUrl: url = %raw(`new URL("./RunWorker.res.mjs", import.meta.url)`)

package/src/Worker.res.mjs

@@ -0,0 +1,9 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+let runWorkerUrl = (new URL("./RunWorker.res.mjs", import.meta.url));
+
+export {
+  runWorkerUrl,
+}
+/* runWorkerUrl Not a pure module */

package/tests/CliRunEntryTest.res

@@ -0,0 +1,57 @@
+// Regression tests for the CLI runner's per-test deadline (A2) and the
+// Collector's skip-depth reset (A4). Before A2 a hung test body wedged the whole
+// run — `runEntry` awaited it with no deadline. Before A4 a throwing `xdescribe`
+// left `skipDepth` > 0, silently skipping every subsequently loaded file; the
+// reset lives in `Collector.activate`.
+
+open JestGlobals
+
+@val external setTimeout: (unit => unit, int) => unit = "setTimeout"
+
+let hangingEntry = (~timeout): Collector.entry => {
+  id: "hangs",
+  name: "hangs forever",
+  describePath: [],
+  slice: None,
+  // A body that never resolves — the pathological hung test.
+  body: () => Promise.make((_resolve, _reject) => ()),
+  status: Collector.Runnable,
+  location: None,
+  timeout,
+}
+
+describe("Cli.runEntry deadline", () => {
+  testPromise("a hung body is reported as a timeout, not a wedge", async () => {
+    let r = await Cli.runEntry(hangingEntry(~timeout=Some(50)))
+    expect(r.status)->toEqual(RunnerTypes.Fail)
+    switch r.mismatch {
+    | Some(Outcome.Throw({error})) => expect(error->String.includes("timed out"))->toEqual(true)
+    | _ => JsError.throwWithMessage("expected a timeout Throw mismatch")
+    }
+  })
+
+  testPromise("a body that resolves within the deadline passes", async () => {
+    let entry: Collector.entry = {
+      id: "ok",
+      name: "resolves fast",
+      describePath: [],
+      slice: None,
+      body: () => Promise.resolve(Outcome.pass),
+      status: Collector.Runnable,
+      location: None,
+      timeout: Some(1000),
+    }
+    let r = await Cli.runEntry(entry)
+    expect(r.status)->toEqual(RunnerTypes.Pass)
+  })
+})
+
+describe("Collector.activate", () => {
+  testSync("resets a leaked skipDepth to zero", () => {
+    // Simulate the leak a throwing xdescribe body would leave behind.
+    Collector.skipDepth := 3
+    Collector.activate()
+    expect(Collector.skipDepth.contents)->toEqual(0)
+    Collector.deactivate()
+  })
+})

package/tests/CliRunEntryTest.res.mjs

@@ -0,0 +1,65 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as Cli$ReventlessGwt from "../src/Cli.res.mjs";
+import * as Outcome$ReventlessGwt from "../src/Outcome.res.mjs";
+import * as Collector$ReventlessGwt from "../src/Collector.res.mjs";
+
+function hangingEntry(timeout) {
+  return {
+    id: "hangs",
+    name: "hangs forever",
+    describePath: [],
+    slice: undefined,
+    body: () => new Promise((_resolve, _reject) => {}),
+    status: "Runnable",
+    location: undefined,
+    timeout: timeout
+  };
+}
+
+globalThis.describe("Cli.runEntry deadline", () => {
+  globalThis.test("a hung body is reported as a timeout, not a wedge", async () => {
+    let r = await Cli$ReventlessGwt.runEntry(hangingEntry(50));
+    globalThis.expect(r.status).toEqual("Fail");
+    let match = r.mismatch;
+    if (match === undefined) {
+      return Stdlib_JsError.throwWithMessage("expected a timeout Throw mismatch");
+    }
+    if (match.TAG !== "Throw") {
+      return Stdlib_JsError.throwWithMessage("expected a timeout Throw mismatch");
+    }
+    globalThis.expect(match.error.includes("timed out")).toEqual(true);
+  });
+  globalThis.test("a body that resolves within the deadline passes", async () => {
+    let entry_describePath = [];
+    let entry_body = () => Promise.resolve(Outcome$ReventlessGwt.pass);
+    let entry_timeout = 1000;
+    let entry = {
+      id: "ok",
+      name: "resolves fast",
+      describePath: entry_describePath,
+      slice: undefined,
+      body: entry_body,
+      status: "Runnable",
+      location: undefined,
+      timeout: entry_timeout
+    };
+    let r = await Cli$ReventlessGwt.runEntry(entry);
+    globalThis.expect(r.status).toEqual("Pass");
+  });
+});
+
+globalThis.describe("Collector.activate", () => {
+  globalThis.test("resets a leaked skipDepth to zero", () => {
+    Collector$ReventlessGwt.skipDepth.contents = 3;
+    Collector$ReventlessGwt.activate();
+    globalThis.expect(Collector$ReventlessGwt.skipDepth.contents).toEqual(0);
+    Collector$ReventlessGwt.deactivate();
+  });
+});
+
+export {
+  hangingEntry,
+}
+/*  Not a pure module */

package/tests/DomainGraphTest.res

@@ -47,17 +47,19 @@ let automation = (~name, ~consumes=[], ~produces=[], ~target=""): Reventless.Plu
   targetName: target,
 }
 
-let inbound = (~name, ~produces=[], ~target=""): Reventless.Plugin.inboundTranslationSliceDef => {
+let inbound = (~name, ~produces=[], ~target="", ~ext=None): Reventless.Plugin.inboundTranslationSliceDef => {
   name,
   commandTypes: produces,
   targetName: target,
+  externalSystem: ext,
 }
 
-let outbound = (~name, ~consumes=[], ~produces=[], ~target=None): Reventless.Plugin.outboundTranslationSliceDef => {
+let outbound = (~name, ~consumes=[], ~produces=[], ~target=None, ~ext=None): Reventless.Plugin.outboundTranslationSliceDef => {
   name,
   consumedEventTypes: consumes,
   inboundCommandTypes: produces,
   targetName: target,
+  externalSystem: ext,
 }
 
 let structure = (
@@ -83,6 +85,8 @@ let structure = (
 
 let hasEdge = (g: DomainGraph.graph, from, to, kind) =>
   g.edges->Array.some(e => e.from == from && e.to == to && e.kind == kind)
+let edgeLabel = (g: DomainGraph.graph, from, to, kind) =>
+  g.edges->Array.find(e => e.from == from && e.to == to && e.kind == kind)->Option.flatMap(e => e.label)
 let nodeKind = (g: DomainGraph.graph, id) =>
   g.nodes->Array.find(n => n.id == id)->Option.map(n => n.kind)
 
@@ -128,6 +132,25 @@ describe("DomainGraph.build", () => {
     expect(hasEdge(g, "Catalog:Category", "Catalog.Archived", "emits"))->toBe(true)
   })
 
+  testPromise("a payload-less event also projects into the aggregate's linked view", async () => {
+    // Classic aggregate → linked view: the projection drew only producedEventTypes, which
+    // drops payload-less events — so a bare `| Archived` emitted but never reached the view.
+    // It must now project too (matching the emit), just like the payloaded `Added`.
+    let shop = structure(
+      ~aggregates=[
+        writable(
+          ~name="Category",
+          ~produces=["Catalog.Added"],
+          ~events=[evt(~name="Added"), evt(~name="Archived")],
+          ~linkedViews=["Categories"],
+        ),
+      ],
+    )
+    let g = DomainGraph.build(~structures=[("Catalog", shop)])
+    expect(hasEdge(g, "Catalog.Added", "Catalog:Categories", "projects"))->toBe(true)
+    expect(hasEdge(g, "Catalog.Archived", "Catalog:Categories", "projects"))->toBe(true)
+  })
+
   testPromise("an Internal StateViewSlice still gets a node + projects edge (dev graph shows it)", async () => {
     // Internal components are hidden from the deployed AutoUI but carried in pluginStructure
     // so the developer-facing domain graph can render them — see Plugin_Structure.res /
@@ -217,6 +240,60 @@ describe("DomainGraph.build", () => {
     expect(hasEdge(g, "Shop:ExportProduct", "Shop_Product_Sync", "delegatesTo"))->toBe(true)
   })
 
+  testPromise("an inbound translation naming an external system draws a box feeding it", async () => {
+    let shop = structure(
+      ~inboundTranslationSlices=[
+        inbound(~name="ImportProduct", ~produces=["ImportProduct.Add"], ~target="Product", ~ext=Some("SupplierFeed")),
+      ],
+    )
+    let g = DomainGraph.build(~structures=[("Shop", shop)])
+    // External box: drawn OUTSIDE the plugin (plugin: "") with a stable "ext:<name>" id.
+    expect(nodeKind(g, "ext:SupplierFeed"))->toEqual(Some("ExternalSystem"))
+    expect(g.nodes->Array.find(n => n.id == "ext:SupplierFeed")->Option.map(n => n.plugin))->toEqual(Some(""))
+    // Inbound direction: external → slice (unlabelled — the arrowhead carries the meaning).
+    expect(hasEdge(g, "ext:SupplierFeed", "Shop:ImportProduct", "translatesIn"))->toBe(true)
+    expect(edgeLabel(g, "ext:SupplierFeed", "Shop:ImportProduct", "translatesIn"))->toEqual(None)
+  })
+
+  testPromise("an outbound translation naming an external system feeds the box", async () => {
+    let shop = structure(
+      ~outboundTranslationSlices=[
+        outbound(~name="SendEmail", ~consumes=["Shop.Placed"], ~target=None, ~ext=Some("EmailService")),
+      ],
+    )
+    let g = DomainGraph.build(~structures=[("Shop", shop)])
+    expect(nodeKind(g, "ext:EmailService"))->toEqual(Some("ExternalSystem"))
+    // Outbound direction: slice → external (unlabelled — the arrowhead carries the meaning).
+    expect(hasEdge(g, "Shop:SendEmail", "ext:EmailService", "translatesOut"))->toBe(true)
+    expect(edgeLabel(g, "Shop:SendEmail", "ext:EmailService", "translatesOut"))->toEqual(None)
+  })
+
+  testPromise("translation slices with no external system draw no box (opt-in)", async () => {
+    let shop = structure(
+      ~inboundTranslationSlices=[inbound(~name="ImportProduct", ~target="Product")],
+    )
+    let g = DomainGraph.build(~structures=[("Shop", shop)])
+    expect(g.nodes->Array.some(n => n.kind == "ExternalSystem"))->toBe(false)
+  })
+
+  testPromise("two slices naming the same external system share one deduped box", async () => {
+    let a = structure(
+      ~outboundTranslationSlices=[
+        outbound(~name="SendEmailA", ~consumes=["A.X"], ~target=None, ~ext=Some("EmailService")),
+      ],
+    )
+    let b = structure(
+      ~inboundTranslationSlices=[
+        inbound(~name="FromEmail", ~produces=["FromEmail.Record"], ~target="Inbox", ~ext=Some("EmailService")),
+      ],
+    )
+    let g = DomainGraph.build(~structures=[("PluginA", a), ("PluginB", b)])
+    // One shared box (per-platform dedup by name) with both an out- and an in-edge.
+    expect(g.nodes->Array.filter(n => n.id == "ext:EmailService")->Array.length)->toBe(1)
+    expect(hasEdge(g, "PluginA:SendEmailA", "ext:EmailService", "translatesOut"))->toBe(true)
+    expect(hasEdge(g, "ext:EmailService", "PluginB:FromEmail", "translatesIn"))->toBe(true)
+  })
+
   testPromise("an event produced by two write-sides is one node with two emit edges", async () => {
     let shop = structure(
       ~aggregates=[

package/tests/DomainGraphTest.res.mjs

@@ -71,25 +71,29 @@ function automation(name, consumesOpt, producesOpt, targetOpt) {
   };
 }
 
-function inbound(name, producesOpt, targetOpt) {
+function inbound(name, producesOpt, targetOpt, extOpt) {
   let produces = producesOpt !== undefined ? producesOpt : [];
   let target = targetOpt !== undefined ? targetOpt : "";
+  let ext = extOpt !== undefined ? Primitive_option.valFromOption(extOpt) : undefined;
   return {
     name: name,
     commandTypes: produces,
-    targetName: target
+    targetName: target,
+    externalSystem: ext
   };
 }
 
-function outbound(name, consumesOpt, producesOpt, targetOpt) {
+function outbound(name, consumesOpt, producesOpt, targetOpt, extOpt) {
   let consumes = consumesOpt !== undefined ? consumesOpt : [];
   let produces = producesOpt !== undefined ? producesOpt : [];
   let target = targetOpt !== undefined ? Primitive_option.valFromOption(targetOpt) : undefined;
+  let ext = extOpt !== undefined ? Primitive_option.valFromOption(extOpt) : undefined;
   return {
     name: name,
     consumedEventTypes: consumes,
     inboundCommandTypes: produces,
-    targetName: target
+    targetName: target,
+    externalSystem: ext
   };
 }
 
@@ -125,6 +129,16 @@ function hasEdge(g, from, to, kind) {
   });
 }
 
+function edgeLabel(g, from, to, kind) {
+  return Stdlib_Option.flatMap(g.edges.find(e => {
+    if (e.from === from && e.to === to) {
+      return e.kind === kind;
+    } else {
+      return false;
+    }
+  }), e => e.label);
+}
+
 function nodeKind(g, id) {
   return Stdlib_Option.map(g.nodes.find(n => n.id === id), n => n.kind);
 }
@@ -166,6 +180,26 @@ globalThis.describe("DomainGraph.build", () => {
     globalThis.expect(hasEdge(g, "Catalog:Category", "Catalog.Added", "emits")).toBe(true);
     globalThis.expect(hasEdge(g, "Catalog:Category", "Catalog.Archived", "emits")).toBe(true);
   });
+  globalThis.test("a payload-less event also projects into the aggregate's linked view", async () => {
+    let shop = structure([writable("Category", undefined, ["Catalog.Added"], undefined, ["Categories"], [
+        {
+          name: "Added",
+          schema: "",
+          references: []
+        },
+        {
+          name: "Archived",
+          schema: "",
+          references: []
+        }
+      ])], undefined, undefined, undefined, undefined, undefined, undefined, undefined);
+    let g = DomainGraph$ReventlessGwt.build([[
+        "Catalog",
+        shop
+      ]]);
+    globalThis.expect(hasEdge(g, "Catalog.Added", "Catalog:Categories", "projects")).toBe(true);
+    globalThis.expect(hasEdge(g, "Catalog.Archived", "Catalog:Categories", "projects")).toBe(true);
+  });
   globalThis.test("an Internal StateViewSlice still gets a node + projects edge (dev graph shows it)", async () => {
     let shop = structure([writable("Order", undefined, ["Shop.Placed"], undefined, undefined, undefined)], undefined, [queryable("AvailableView", ["Shop.Placed"], "Internal")], undefined, undefined, undefined, undefined, undefined);
     let g = DomainGraph$ReventlessGwt.build([[
@@ -209,7 +243,7 @@ globalThis.describe("DomainGraph.build", () => {
     globalThis.expect(hasEdge(g, "Shop:AutoShip", "Shop_Ship_Place", "delegatesTo")).toBe(false);
   });
   globalThis.test("an inbound translation routes to the command it raises on its target", async () => {
-    let shop = structure(undefined, undefined, undefined, [writable("Product", [command("Add", "Shop_Product_Add", undefined)], undefined, undefined, undefined, undefined)], undefined, undefined, [inbound("ImportProduct", ["ImportProduct.Add"], "Product")], undefined);
+    let shop = structure(undefined, undefined, undefined, [writable("Product", [command("Add", "Shop_Product_Add", undefined)], undefined, undefined, undefined, undefined)], undefined, undefined, [inbound("ImportProduct", ["ImportProduct.Add"], "Product", undefined)], undefined);
     let g = DomainGraph$ReventlessGwt.build([[
         "Shop",
         shop
@@ -218,13 +252,59 @@ globalThis.describe("DomainGraph.build", () => {
     globalThis.expect(hasEdge(g, "Shop:ImportProduct", "Shop_Product_Add", "delegatesTo")).toBe(true);
   });
   globalThis.test("an outbound translation with a target routes to the command it raises", async () => {
-    let shop = structure(undefined, undefined, undefined, [writable("Product", [command("Sync", "Shop_Product_Sync", undefined)], undefined, undefined, undefined, undefined)], undefined, [outbound("ExportProduct", ["Shop.Added"], ["ExportProduct.Sync"], "Product")], undefined, undefined);
+    let shop = structure(undefined, undefined, undefined, [writable("Product", [command("Sync", "Shop_Product_Sync", undefined)], undefined, undefined, undefined, undefined)], undefined, [outbound("ExportProduct", ["Shop.Added"], ["ExportProduct.Sync"], "Product", undefined)], undefined, undefined);
     let g = DomainGraph$ReventlessGwt.build([[
         "Shop",
         shop
       ]]);
     globalThis.expect(hasEdge(g, "Shop:ExportProduct", "Shop_Product_Sync", "delegatesTo")).toBe(true);
   });
+  globalThis.test("an inbound translation naming an external system draws a box feeding it", async () => {
+    let shop = structure(undefined, undefined, undefined, undefined, undefined, undefined, [inbound("ImportProduct", ["ImportProduct.Add"], "Product", "SupplierFeed")], undefined);
+    let g = DomainGraph$ReventlessGwt.build([[
+        "Shop",
+        shop
+      ]]);
+    globalThis.expect(nodeKind(g, "ext:SupplierFeed")).toEqual("ExternalSystem");
+    globalThis.expect(Stdlib_Option.map(g.nodes.find(n => n.id === "ext:SupplierFeed"), n => n.plugin)).toEqual("");
+    globalThis.expect(hasEdge(g, "ext:SupplierFeed", "Shop:ImportProduct", "translatesIn")).toBe(true);
+    globalThis.expect(edgeLabel(g, "ext:SupplierFeed", "Shop:ImportProduct", "translatesIn")).toEqual(undefined);
+  });
+  globalThis.test("an outbound translation naming an external system feeds the box", async () => {
+    let shop = structure(undefined, undefined, undefined, undefined, undefined, [outbound("SendEmail", ["Shop.Placed"], undefined, Primitive_option.some(undefined), "EmailService")], undefined, undefined);
+    let g = DomainGraph$ReventlessGwt.build([[
+        "Shop",
+        shop
+      ]]);
+    globalThis.expect(nodeKind(g, "ext:EmailService")).toEqual("ExternalSystem");
+    globalThis.expect(hasEdge(g, "Shop:SendEmail", "ext:EmailService", "translatesOut")).toBe(true);
+    globalThis.expect(edgeLabel(g, "Shop:SendEmail", "ext:EmailService", "translatesOut")).toEqual(undefined);
+  });
+  globalThis.test("translation slices with no external system draw no box (opt-in)", async () => {
+    let shop = structure(undefined, undefined, undefined, undefined, undefined, undefined, [inbound("ImportProduct", undefined, "Product", undefined)], undefined);
+    let g = DomainGraph$ReventlessGwt.build([[
+        "Shop",
+        shop
+      ]]);
+    globalThis.expect(g.nodes.some(n => n.kind === "ExternalSystem")).toBe(false);
+  });
+  globalThis.test("two slices naming the same external system share one deduped box", async () => {
+    let a = structure(undefined, undefined, undefined, undefined, undefined, [outbound("SendEmailA", ["A.X"], undefined, Primitive_option.some(undefined), "EmailService")], undefined, undefined);
+    let b = structure(undefined, undefined, undefined, undefined, undefined, undefined, [inbound("FromEmail", ["FromEmail.Record"], "Inbox", "EmailService")], undefined);
+    let g = DomainGraph$ReventlessGwt.build([
+      [
+        "PluginA",
+        a
+      ],
+      [
+        "PluginB",
+        b
+      ]
+    ]);
+    globalThis.expect(g.nodes.filter(n => n.id === "ext:EmailService").length).toBe(1);
+    globalThis.expect(hasEdge(g, "PluginA:SendEmailA", "ext:EmailService", "translatesOut")).toBe(true);
+    globalThis.expect(hasEdge(g, "ext:EmailService", "PluginB:FromEmail", "translatesIn")).toBe(true);
+  });
   globalThis.test("an event produced by two write-sides is one node with two emit edges", async () => {
     let shop = structure([
       writable("A", undefined, ["Shop.Touched"], undefined, undefined, undefined),
@@ -408,6 +488,7 @@ export {
   outbound,
   structure,
   hasEdge,
+  edgeLabel,
   nodeKind,
 }
 /*  Not a pure module */

package/tests/FlowGwtTest.res.mjs

@@ -307,7 +307,8 @@ let ConfirmSlice = {
   consumedEventSchema: consumedEventSchema$4,
   outboundItemSchema: outboundItemSchema,
   inboundCommandSchema: S.unit,
-  collect: collect$1
+  collect: collect$1,
+  externalSystem: undefined
 };
 
 let Place = Flow_GWT$ReventlessGwt.CommandStep(PlaceOrderSlice)({

package/tests/InboundTranslationGwtTest.res.mjs

@@ -46,7 +46,8 @@ let PaymentWebhookSlice = {
   externalInputSchema: externalInputSchema,
   commandSchema: commandSchema,
   translate: translate,
-  commandAuthorization: commandAuthorization
+  commandAuthorization: commandAuthorization,
+  externalSystem: undefined
 };
 
 let include = InboundTranslation_GWT$ReventlessGwt.Make(PaymentWebhookSlice);

package/tests/OutboundTranslationGwtTest.res.mjs

@@ -32,7 +32,8 @@ let SendTrackingEmailSlice = {
   consumedEventSchema: consumedEventSchema,
   outboundItemSchema: outboundItemSchema,
   inboundCommandSchema: inboundCommandSchema,
-  collect: collect
+  collect: collect,
+  externalSystem: undefined
 };
 
 let include = OutboundTranslation_GWT$ReventlessGwt.Make(SendTrackingEmailSlice);

package/tests/WatchDebounceTest.res

@@ -49,10 +49,11 @@ describe("Watch.debounce coalescing", () => {
     expect(calls.contents)->toEqual([Watch.Unlink])
   })
 
-  testPromise("interleaved .res.mjs unlinks don't steal the representative path", async () => {
+  testPromise("interleaved .res.mjs unlinks never surface; each distinct .res source does", async () => {
     // The real directory-mv burst chokidar emits: source AND generated files
-    // unlink interleaved. The coalesced path must be a `.res` source, not the
-    // last-seen `.res.mjs` (which would misclassify as a non-structural change).
+    // unlink interleaved. Only `.res` sources are emitted (never a `.res.mjs`),
+    // and every *distinct* source is emitted — two moved modules must both drive
+    // a rebuild, not collapse to one representative.
     let calls = ref([])
     let fire = Watch.debounce(40, (e, p) => calls := Array.concat(calls.contents, [(e, p)]))
     fire(Watch.Unlink, "/p/src/old/A.res")
@@ -62,10 +63,37 @@ describe("Watch.debounce coalescing", () => {
     fire(Watch.Add, "/p/src/new/A.res")
     fire(Watch.Add, "/p/src/new/A.res.mjs")
     await delay(120)
-    expect(calls.contents->Array.length)->toEqual(1)
-    let (e, p) = calls.contents->Array.getUnsafe(0)
-    expect(e)->toEqual(Watch.Unlink)
-    expect(Watch.isStructuralSource(e, p))->toEqual(true)
+    let paths = calls.contents->Array.map(((_, p)) => p)
+    expect(calls.contents->Array.every(((e, p)) => Watch.isStructuralSource(e, p)))->toEqual(true)
+    expect(paths->Array.includes("/p/src/old/A.res"))->toEqual(true)
+    expect(paths->Array.includes("/p/src/old/A_Behavior.res"))->toEqual(true)
+    expect(paths->Array.some(p => p->String.endsWith(".mjs")))->toEqual(false)
+    expect(calls.contents->Array.length)->toEqual(2)
+  })
+
+  testPromise("a burst spanning two packages emits an unlink per package (A4.1)", async () => {
+    // Regression: the old single-`bestPath` debounce clean-rebuilt only one
+    // package on a multi-package burst, stranding the other with stale .res.mjs.
+    let calls = ref([])
+    let fire = Watch.debounce(40, (e, p) => calls := Array.concat(calls.contents, [(e, p)]))
+    fire(Watch.Unlink, "/pkgA/src/Foo.res")
+    fire(Watch.Unlink, "/pkgB/src/Bar.res")
+    await delay(120)
+    let paths = calls.contents->Array.map(((_, p)) => p)
+    expect(paths->Array.includes("/pkgA/src/Foo.res"))->toEqual(true)
+    expect(paths->Array.includes("/pkgB/src/Bar.res"))->toEqual(true)
+    expect(calls.contents->Array.length)->toEqual(2)
+  })
+
+  testPromise("a structural signal suppresses a co-occurring plain change", async () => {
+    // A structural rebuild does its own re-run, so a plain edit in the same
+    // window must not also emit a separate Change (which would double-run).
+    let calls = ref([])
+    let fire = Watch.debounce(40, (e, _p) => calls := Array.concat(calls.contents, [e]))
+    fire(Watch.Change, "/p/src/Edited.res")
+    fire(Watch.Unlink, "/p/src/old/Moved.res")
+    await delay(120)
+    expect(calls.contents)->toEqual([Watch.Unlink])
   })
 
   testPromise("a lone change stays a change (incremental re-run)", async () => {

package/tests/WatchDebounceTest.res.mjs

@@ -55,7 +55,7 @@ globalThis.describe("Watch.debounce coalescing", () => {
     await delay(120);
     globalThis.expect(calls.contents).toEqual(["Unlink"]);
   });
-  globalThis.test("interleaved .res.mjs unlinks don't steal the representative path", async () => {
+  globalThis.test("interleaved .res.mjs unlinks never surface; each distinct .res source does", async () => {
     let calls = {
       contents: []
     };
@@ -72,11 +72,42 @@ globalThis.describe("Watch.debounce coalescing", () => {
     fire("Add", "/p/src/new/A.res");
     fire("Add", "/p/src/new/A.res.mjs");
     await delay(120);
-    globalThis.expect(calls.contents.length).toEqual(1);
-    let match = calls.contents[0];
-    let e = match[0];
-    globalThis.expect(e).toEqual("Unlink");
-    globalThis.expect(Watch$ReventlessGwt.isStructuralSource(e, match[1])).toEqual(true);
+    let paths = calls.contents.map(param => param[1]);
+    globalThis.expect(calls.contents.every(param => Watch$ReventlessGwt.isStructuralSource(param[0], param[1]))).toEqual(true);
+    globalThis.expect(paths.includes("/p/src/old/A.res")).toEqual(true);
+    globalThis.expect(paths.includes("/p/src/old/A_Behavior.res")).toEqual(true);
+    globalThis.expect(paths.some(p => p.endsWith(".mjs"))).toEqual(false);
+    globalThis.expect(calls.contents.length).toEqual(2);
+  });
+  globalThis.test("a burst spanning two packages emits an unlink per package (A4.1)", async () => {
+    let calls = {
+      contents: []
+    };
+    let fire = Watch$ReventlessGwt.debounce(40, (e, p) => {
+      calls.contents = calls.contents.concat([[
+          e,
+          p
+        ]]);
+    });
+    fire("Unlink", "/pkgA/src/Foo.res");
+    fire("Unlink", "/pkgB/src/Bar.res");
+    await delay(120);
+    let paths = calls.contents.map(param => param[1]);
+    globalThis.expect(paths.includes("/pkgA/src/Foo.res")).toEqual(true);
+    globalThis.expect(paths.includes("/pkgB/src/Bar.res")).toEqual(true);
+    globalThis.expect(calls.contents.length).toEqual(2);
+  });
+  globalThis.test("a structural signal suppresses a co-occurring plain change", async () => {
+    let calls = {
+      contents: []
+    };
+    let fire = Watch$ReventlessGwt.debounce(40, (e, _p) => {
+      calls.contents = calls.contents.concat([e]);
+    });
+    fire("Change", "/p/src/Edited.res");
+    fire("Unlink", "/p/src/old/Moved.res");
+    await delay(120);
+    globalThis.expect(calls.contents).toEqual(["Unlink"]);
   });
   globalThis.test("a lone change stays a change (incremental re-run)", async () => {
     let calls = {