@reventlessdev/reventless-gwt 1.0.0-alpha.115 → 1.0.0-alpha.116

package/tests/RunnerUnitTest.res

@@ -1,219 +0,0 @@
-// Runner-side self-tests. Constructs synthetic `Outcome` values and feeds
-// them through `RenderRescript`, `Diff`, and `FormatterJson` / `FormatterTap`
-// to assert the rendered shapes. This is the unit-test layer — CLI-level
-// integration is covered by running `node bin/reventless-gwt.mjs run tests/`
-// against the DSL worked-example suites.
-
-open JestGlobals
-
-let encodeString = (s: string): JSON.t => JSON.Encode.string(s)
-
-let makeTaggedEvent = (~tag: string, ~payload: JSON.t): JSON.t => {
-  let d = Dict.make()
-  d->Dict.set("TAG", JSON.Encode.string(tag))
-  d->Dict.set("_0", payload)
-  JSON.Encode.object(d)
-}
-
-describe("RenderRescript", () => {
-  testPromise("renders tagged variants with BuckleScript representation", async () => {
-    let payload = Dict.make()
-    payload->Dict.set("name", encodeString("Electronics"))
-    let ev = makeTaggedEvent(~tag="CategoryAdded", ~payload=JSON.Encode.object(payload))
-    let rendered = RenderRescript.render(ev)
-    expect(rendered)->toEqual(`CategoryAdded({name: "Electronics"})`)
-  })
-
-  testPromise("renders payload-less variants as bare strings", async () => {
-    let ev = JSON.Encode.string("CategoryArchived")
-    expect(RenderRescript.render(ev))->toEqual(`"CategoryArchived"`)
-  })
-
-  testPromise("renders plain records in field order", async () => {
-    let d = Dict.make()
-    d->Dict.set("id", encodeString("c1"))
-    d->Dict.set("count", JSON.Encode.int(3))
-    let rendered = RenderRescript.render(JSON.Encode.object(d))
-    expect(rendered)->toEqual(`{id: "c1", count: 3}`)
-  })
-
-  testPromise("renderMany splits large arrays across lines", async () => {
-    let a = makeTaggedEvent(~tag="A", ~payload=JSON.Encode.object(Dict.make()))
-    let b = makeTaggedEvent(~tag="B", ~payload=JSON.Encode.object(Dict.make()))
-    let rendered = RenderRescript.renderMany([a, b])
-    expect(rendered->String.includes("A({})"))->toEqual(true)
-    expect(rendered->String.includes("B({})"))->toEqual(true)
-  })
-
-  // Inline-record variants (`Name({...})`) are flattened by ReScript: the record
-  // fields sit beside TAG, not under `_0`. Regression for the dropped-payload bug
-  // where `ProductsNotAvailable({missing: [...]})` rendered as bare
-  // `ProductsNotAvailable`, making error diffs read `X != X`.
-  testPromise("renders inline-record variants with their flattened payload", async () => {
-    let d = Dict.make()
-    d->Dict.set("TAG", encodeString("ProductsNotAvailable"))
-    d->Dict.set("missing", JSON.Encode.array([encodeString("p1x")]))
-    let rendered = RenderRescript.render(JSON.Encode.object(d))
-    expect(rendered)->toEqual(`ProductsNotAvailable({missing: ["p1x"]})`)
-  })
-
-  testPromise("renders multi-field inline-record variants", async () => {
-    let d = Dict.make()
-    d->Dict.set("TAG", encodeString("Conflict"))
-    d->Dict.set("expected", JSON.Encode.int(1))
-    d->Dict.set("got", JSON.Encode.int(2))
-    let rendered = RenderRescript.render(JSON.Encode.object(d))
-    expect(rendered)->toEqual(`Conflict({expected: 1, got: 2})`)
-  })
-})
-
-describe("Diff", () => {
-  testPromise("emits one entry per differing leaf", async () => {
-    let d1 = Dict.make()
-    d1->Dict.set("name", encodeString("A"))
-    d1->Dict.set("count", JSON.Encode.int(1))
-    let d2 = Dict.make()
-    d2->Dict.set("name", encodeString("B"))
-    d2->Dict.set("count", JSON.Encode.int(1))
-    let diff = Diff.diff(JSON.Encode.object(d1), JSON.Encode.object(d2))
-    expect(diff->Array.length)->toEqual(1)
-    let first = diff->Array.getUnsafe(0)
-    expect(first.path)->toEqual("name")
-  })
-
-  testPromise("emits zero entries when values are identical", async () => {
-    let d = Dict.make()
-    d->Dict.set("a", JSON.Encode.int(1))
-    let left = JSON.Encode.object(d)
-    let d2 = Dict.make()
-    d2->Dict.set("a", JSON.Encode.int(1))
-    let right = JSON.Encode.object(d2)
-    expect(Diff.diff(left, right)->Array.length)->toEqual(0)
-  })
-})
-
-describe("FormatterJson.mismatchJson", () => {
-  testPromise("ErrorMismatch carries dual-rendered expected + actualEvents", async () => {
-    // Payload-less variants encode to a bare JSON string — matches sury's
-    // default representation.
-    let expectedError = JSON.Encode.string("CategoryAlreadyExists")
-    let actualEvent = {
-      let p = Dict.make()
-      p->Dict.set("categoryId", encodeString("c1"))
-      p->Dict.set("name", encodeString("X"))
-      makeTaggedEvent(~tag="CategoryAdded", ~payload=JSON.Encode.object(p))
-    }
-    let m = Outcome.ErrorMismatch({
-      expected: expectedError,
-      actual: None,
-      actualEvents: [actualEvent],
-    })
-    let j = FormatterJson.mismatchJson(m, Some("AddCategory"))
-    let str = JSON.stringify(j)
-    expect(str->String.includes(`"kind":"ErrorMismatch"`))->toEqual(true)
-    // Payload-less variant's `type` field carries the constructor name.
-    expect(str->String.includes(`"type":"CategoryAlreadyExists"`))->toEqual(true)
-    expect(
-      str->String.includes(`CategoryAdded({categoryId: \\\"c1\\\", name: \\\"X\\\"})`),
-    )->toEqual(true)
-    expect(str->String.includes(`"locus":"AddCategory.decide"`))->toEqual(true)
-  })
-
-  testPromise("EventsMismatch includes a fieldDiff derived from payloads", async () => {
-    let expected = {
-      let p = Dict.make()
-      p->Dict.set("name", encodeString("Electronics"))
-      [makeTaggedEvent(~tag="Added", ~payload=JSON.Encode.object(p))]
-    }
-    let actual = {
-      let p = Dict.make()
-      p->Dict.set("name", encodeString("Books"))
-      [makeTaggedEvent(~tag="Added", ~payload=JSON.Encode.object(p))]
-    }
-    let m = Outcome.EventsMismatch({expected, actual})
-    let j = FormatterJson.mismatchJson(m, None)
-    let str = JSON.stringify(j)
-    expect(str->String.includes(`"fieldDiff"`))->toEqual(true)
-    expect(str->String.includes(`"path":"0._0.name"`))->toEqual(true)
-  })
-})
-
-describe("Cli.parseArgv", () => {
-  testPromise("parses run subcommand with --format=json --filter=Foo", async () => {
-    let argv = [
-      "/bin/node",
-      "/path/to/bin",
-      "run",
-      "--format=json",
-      "--filter=Foo",
-      "tests/",
-    ]
-    switch Cli.parseArgv(argv) {
-    | Ok(opts) => {
-        expect(opts.subcommand == Run)->toEqual(true)
-        expect(opts.format == Json)->toEqual(true)
-        expect(opts.filters)->toEqual(["Foo"])
-        expect(opts.roots)->toEqual(["tests/"])
-      }
-    | Error(msg) => JsError.throwWithMessage("expected Ok, got: " ++ msg)
-    }
-  })
-
-  testPromise("discover subcommand defaults to vscode format", async () => {
-    let argv = ["/bin/node", "/path/to/bin", "discover"]
-    switch Cli.parseArgv(argv) {
-    | Ok(opts) => {
-        expect(opts.subcommand == Discover)->toEqual(true)
-        expect(opts.format == VsCode)->toEqual(true)
-      }
-    | Error(msg) => JsError.throwWithMessage("expected Ok, got: " ++ msg)
-    }
-  })
-
-  testPromise("unknown flag reports an error", async () => {
-    let argv = ["/bin/node", "/path/to/bin", "run", "--nonsense"]
-    switch Cli.parseArgv(argv) {
-    | Ok(_) => JsError.throwWithMessage("expected Error")
-    | Error(msg) => expect(msg->String.includes("Unknown flag"))->toEqual(true)
-    }
-  })
-
-  testPromise("no path argument defaults to the cwd subtree (auto-discovery)", async () => {
-    let argv = ["/bin/node", "/path/to/bin", "watch", "--format=vscode"]
-    switch Cli.parseArgv(argv) {
-    | Ok(opts) => {
-        expect(opts.subcommand == Watch)->toEqual(true)
-        expect(opts.roots)->toEqual(["."])
-      }
-    | Error(msg) => JsError.throwWithMessage("expected Ok, got: " ++ msg)
-    }
-  })
-
-  testPromise("platform backend defaults to memory; --backend overrides", async () => {
-    switch Cli.parseArgv(["/bin/node", "/path/to/bin", "platform", "--format=vscode"]) {
-    | Ok(opts) => {
-        expect(opts.subcommand == Platform)->toEqual(true)
-        expect(opts.backend)->toEqual("memory")
-      }
-    | Error(msg) => JsError.throwWithMessage("expected Ok, got: " ++ msg)
-    }
-    switch Cli.parseArgv(["/bin/node", "/path/to/bin", "platform", "--backend=sqlite:./db?reset"]) {
-    | Ok(opts) => expect(opts.backend)->toEqual("sqlite:./db?reset")
-    | Error(msg) => JsError.throwWithMessage("expected Ok, got: " ++ msg)
-    }
-  })
-
-  testPromise("platform --ui-ports defaults false; flag sets it true", async () => {
-    switch Cli.parseArgv(["/bin/node", "/path/to/bin", "platform", "--format=vscode"]) {
-    | Ok(opts) => expect(opts.uiPorts)->toEqual(false)
-    | Error(msg) => JsError.throwWithMessage("expected Ok, got: " ++ msg)
-    }
-    switch Cli.parseArgv(["/bin/node", "/path/to/bin", "platform", "--ui-ports"]) {
-    | Ok(opts) => {
-        expect(opts.subcommand == Platform)->toEqual(true)
-        expect(opts.uiPorts)->toEqual(true)
-      }
-    | Error(msg) => JsError.throwWithMessage("expected Ok, got: " ++ msg)
-    }
-  })
-})

package/tests/RunnerUnitTest.res.mjs

@@ -1,244 +0,0 @@
-// 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 Diff$ReventlessGwt from "../src/Diff.res.mjs";
-import * as FormatterJson$ReventlessGwt from "../src/FormatterJson.res.mjs";
-import * as RenderRescript$ReventlessGwt from "../src/RenderRescript.res.mjs";
-
-function encodeString(s) {
-  return s;
-}
-
-function makeTaggedEvent(tag, payload) {
-  let d = {};
-  d["TAG"] = tag;
-  d["_0"] = payload;
-  return d;
-}
-
-globalThis.describe("RenderRescript", () => {
-  globalThis.test("renders tagged variants with BuckleScript representation", async () => {
-    let payload = {};
-    payload["name"] = "Electronics";
-    let ev = makeTaggedEvent("CategoryAdded", payload);
-    let rendered = RenderRescript$ReventlessGwt.render(undefined, ev);
-    globalThis.expect(rendered).toEqual(`CategoryAdded({name: "Electronics"})`);
-  });
-  globalThis.test("renders payload-less variants as bare strings", async () => {
-    globalThis.expect(RenderRescript$ReventlessGwt.render(undefined, "CategoryArchived")).toEqual(`"CategoryArchived"`);
-  });
-  globalThis.test("renders plain records in field order", async () => {
-    let d = {};
-    d["id"] = "c1";
-    d["count"] = 3;
-    let rendered = RenderRescript$ReventlessGwt.render(undefined, d);
-    globalThis.expect(rendered).toEqual(`{id: "c1", count: 3}`);
-  });
-  globalThis.test("renderMany splits large arrays across lines", async () => {
-    let a = makeTaggedEvent("A", {});
-    let b = makeTaggedEvent("B", {});
-    let rendered = RenderRescript$ReventlessGwt.renderMany([
-      a,
-      b
-    ]);
-    globalThis.expect(rendered.includes("A({})")).toEqual(true);
-    globalThis.expect(rendered.includes("B({})")).toEqual(true);
-  });
-  globalThis.test("renders inline-record variants with their flattened payload", async () => {
-    let d = {};
-    d["TAG"] = "ProductsNotAvailable";
-    d["missing"] = ["p1x"];
-    let rendered = RenderRescript$ReventlessGwt.render(undefined, d);
-    globalThis.expect(rendered).toEqual(`ProductsNotAvailable({missing: ["p1x"]})`);
-  });
-  globalThis.test("renders multi-field inline-record variants", async () => {
-    let d = {};
-    d["TAG"] = "Conflict";
-    d["expected"] = 1;
-    d["got"] = 2;
-    let rendered = RenderRescript$ReventlessGwt.render(undefined, d);
-    globalThis.expect(rendered).toEqual(`Conflict({expected: 1, got: 2})`);
-  });
-});
-
-globalThis.describe("Diff", () => {
-  globalThis.test("emits one entry per differing leaf", async () => {
-    let d1 = {};
-    d1["name"] = "A";
-    d1["count"] = 1;
-    let d2 = {};
-    d2["name"] = "B";
-    d2["count"] = 1;
-    let diff = Diff$ReventlessGwt.diff(d1, d2);
-    globalThis.expect(diff.length).toEqual(1);
-    let first = diff[0];
-    globalThis.expect(first.path).toEqual("name");
-  });
-  globalThis.test("emits zero entries when values are identical", async () => {
-    let d = {};
-    d["a"] = 1;
-    let d2 = {};
-    d2["a"] = 1;
-    globalThis.expect(Diff$ReventlessGwt.diff(d, d2).length).toEqual(0);
-  });
-});
-
-globalThis.describe("FormatterJson.mismatchJson", () => {
-  globalThis.test("ErrorMismatch carries dual-rendered expected + actualEvents", async () => {
-    let p = {};
-    p["categoryId"] = "c1";
-    p["name"] = "X";
-    let actualEvent = makeTaggedEvent("CategoryAdded", p);
-    let m_2 = [actualEvent];
-    let m = {
-      TAG: "ErrorMismatch",
-      expected: "CategoryAlreadyExists",
-      actual: undefined,
-      actualEvents: m_2
-    };
-    let j = FormatterJson$ReventlessGwt.mismatchJson(m, "AddCategory");
-    let str = JSON.stringify(j);
-    globalThis.expect(str.includes(`"kind":"ErrorMismatch"`)).toEqual(true);
-    globalThis.expect(str.includes(`"type":"CategoryAlreadyExists"`)).toEqual(true);
-    globalThis.expect(str.includes(`CategoryAdded({categoryId: \\\"c1\\\", name: \\\"X\\\"})`)).toEqual(true);
-    globalThis.expect(str.includes(`"locus":"AddCategory.decide"`)).toEqual(true);
-  });
-  globalThis.test("EventsMismatch includes a fieldDiff derived from payloads", async () => {
-    let p = {};
-    p["name"] = "Electronics";
-    let expected = [makeTaggedEvent("Added", p)];
-    let p$1 = {};
-    p$1["name"] = "Books";
-    let actual = [makeTaggedEvent("Added", p$1)];
-    let m = {
-      TAG: "EventsMismatch",
-      expected: expected,
-      actual: actual
-    };
-    let j = FormatterJson$ReventlessGwt.mismatchJson(m, undefined);
-    let str = JSON.stringify(j);
-    globalThis.expect(str.includes(`"fieldDiff"`)).toEqual(true);
-    globalThis.expect(str.includes(`"path":"0._0.name"`)).toEqual(true);
-  });
-});
-
-globalThis.describe("Cli.parseArgv", () => {
-  globalThis.test("parses run subcommand with --format=json --filter=Foo", async () => {
-    let argv = [
-      "/bin/node",
-      "/path/to/bin",
-      "run",
-      "--format=json",
-      "--filter=Foo",
-      "tests/"
-    ];
-    let opts = Cli$ReventlessGwt.parseArgv(argv);
-    if (opts.TAG !== "Ok") {
-      return Stdlib_JsError.throwWithMessage("expected Ok, got: " + opts._0);
-    }
-    let opts$1 = opts._0;
-    globalThis.expect(opts$1.subcommand === "Run").toEqual(true);
-    globalThis.expect(opts$1.format === "Json").toEqual(true);
-    globalThis.expect(opts$1.filters).toEqual(["Foo"]);
-    globalThis.expect(opts$1.roots).toEqual(["tests/"]);
-  });
-  globalThis.test("discover subcommand defaults to vscode format", async () => {
-    let argv = [
-      "/bin/node",
-      "/path/to/bin",
-      "discover"
-    ];
-    let opts = Cli$ReventlessGwt.parseArgv(argv);
-    if (opts.TAG !== "Ok") {
-      return Stdlib_JsError.throwWithMessage("expected Ok, got: " + opts._0);
-    }
-    let opts$1 = opts._0;
-    globalThis.expect(opts$1.subcommand === "Discover").toEqual(true);
-    globalThis.expect(opts$1.format === "VsCode").toEqual(true);
-  });
-  globalThis.test("unknown flag reports an error", async () => {
-    let argv = [
-      "/bin/node",
-      "/path/to/bin",
-      "run",
-      "--nonsense"
-    ];
-    let msg = Cli$ReventlessGwt.parseArgv(argv);
-    if (msg.TAG === "Ok") {
-      return Stdlib_JsError.throwWithMessage("expected Error");
-    }
-    globalThis.expect(msg._0.includes("Unknown flag")).toEqual(true);
-  });
-  globalThis.test("no path argument defaults to the cwd subtree (auto-discovery)", async () => {
-    let argv = [
-      "/bin/node",
-      "/path/to/bin",
-      "watch",
-      "--format=vscode"
-    ];
-    let opts = Cli$ReventlessGwt.parseArgv(argv);
-    if (opts.TAG !== "Ok") {
-      return Stdlib_JsError.throwWithMessage("expected Ok, got: " + opts._0);
-    }
-    let opts$1 = opts._0;
-    globalThis.expect(opts$1.subcommand === "Watch").toEqual(true);
-    globalThis.expect(opts$1.roots).toEqual(["."]);
-  });
-  globalThis.test("platform backend defaults to memory; --backend overrides", async () => {
-    let opts = Cli$ReventlessGwt.parseArgv([
-      "/bin/node",
-      "/path/to/bin",
-      "platform",
-      "--format=vscode"
-    ]);
-    if (opts.TAG === "Ok") {
-      let opts$1 = opts._0;
-      globalThis.expect(opts$1.subcommand === "Platform").toEqual(true);
-      globalThis.expect(opts$1.backend).toEqual("memory");
-    } else {
-      Stdlib_JsError.throwWithMessage("expected Ok, got: " + opts._0);
-    }
-    let opts$2 = Cli$ReventlessGwt.parseArgv([
-      "/bin/node",
-      "/path/to/bin",
-      "platform",
-      "--backend=sqlite:./db?reset"
-    ]);
-    if (opts$2.TAG !== "Ok") {
-      return Stdlib_JsError.throwWithMessage("expected Ok, got: " + opts$2._0);
-    }
-    globalThis.expect(opts$2._0.backend).toEqual("sqlite:./db?reset");
-  });
-  globalThis.test("platform --ui-ports defaults false; flag sets it true", async () => {
-    let opts = Cli$ReventlessGwt.parseArgv([
-      "/bin/node",
-      "/path/to/bin",
-      "platform",
-      "--format=vscode"
-    ]);
-    if (opts.TAG === "Ok") {
-      globalThis.expect(opts._0.uiPorts).toEqual(false);
-    } else {
-      Stdlib_JsError.throwWithMessage("expected Ok, got: " + opts._0);
-    }
-    let opts$1 = Cli$ReventlessGwt.parseArgv([
-      "/bin/node",
-      "/path/to/bin",
-      "platform",
-      "--ui-ports"
-    ]);
-    if (opts$1.TAG !== "Ok") {
-      return Stdlib_JsError.throwWithMessage("expected Ok, got: " + opts$1._0);
-    }
-    let opts$2 = opts$1._0;
-    globalThis.expect(opts$2.subcommand === "Platform").toEqual(true);
-    globalThis.expect(opts$2.uiPorts).toEqual(true);
-  });
-});
-
-export {
-  encodeString,
-  makeTaggedEvent,
-}
-/*  Not a pure module */

package/tests/WatchDebounceTest.res

@@ -1,106 +0,0 @@
-// Unit tests for Watch's event coalescing — the part Phase 12 added so a
-// relocation's structural `unlink` survives a debounce window that also carries
-// the trailing `add`/`change` of the same `mv`. The debounce uses real
-// setTimeout(120ms), so these await past the window.
-
-open JestGlobals
-
-@val external setTimeout: (unit => unit, int) => unit = "setTimeout"
-let delay = (ms: int): promise<unit> =>
-  Promise.make((resolve, _reject) => setTimeout(() => resolve(), ms))
-
-describe("Watch.isStructuralSource", () => {
-  testPromise("an unlink of a .res source is structural", async () =>
-    expect(Watch.isStructuralSource(Unlink, "/p/src/Foo/Bar.res"))->toEqual(true)
-  )
-  testPromise("a generated .res.mjs unlink is NOT structural (ends in .mjs)", async () =>
-    expect(Watch.isStructuralSource(Unlink, "/p/src/Foo/Bar.res.mjs"))->toEqual(false)
-  )
-  testPromise("an add of a .res source is not structural (incremental handles it)", async () =>
-    expect(Watch.isStructuralSource(Add, "/p/src/Foo/Bar.res"))->toEqual(false)
-  )
-  testPromise("a change of a .res source is not structural", async () =>
-    expect(Watch.isStructuralSource(Change, "/p/src/Foo/Bar.res"))->toEqual(false)
-  )
-})
-
-describe("Watch.debounce coalescing", () => {
-  testPromise("a burst collapses to one call carrying the strongest event", async () => {
-    let calls = ref([])
-    let fire = Watch.debounce(40, (e, p) => calls := Array.concat(calls.contents, [(e, p)]))
-    // A move/ungroup: the new file is created, an edit lands, then the old file
-    // is unlinked — all inside one window. The unlink must win.
-    fire(Watch.Change, "/p/src/A.res")
-    fire(Watch.Add, "/p/src/new/A.res")
-    fire(Watch.Unlink, "/p/src/old/A.res")
-    await delay(120)
-    expect(calls.contents->Array.length)->toEqual(1)
-    let (e, p) = calls.contents->Array.getUnsafe(0)
-    expect(e)->toEqual(Watch.Unlink)
-    expect(p)->toEqual("/p/src/old/A.res")
-  })
-
-  testPromise("a later weaker event does not mask an earlier unlink", async () => {
-    let calls = ref([])
-    let fire = Watch.debounce(40, (e, _p) => calls := Array.concat(calls.contents, [e]))
-    fire(Watch.Unlink, "/p/src/old/A.res")
-    fire(Watch.Change, "/p/src/A.res")
-    await delay(120)
-    expect(calls.contents)->toEqual([Watch.Unlink])
-  })
-
-  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. 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")
-    fire(Watch.Unlink, "/p/src/old/A.res.mjs")
-    fire(Watch.Unlink, "/p/src/old/A_Behavior.res")
-    fire(Watch.Unlink, "/p/src/old/A_Behavior.res.mjs")
-    fire(Watch.Add, "/p/src/new/A.res")
-    fire(Watch.Add, "/p/src/new/A.res.mjs")
-    await delay(120)
-    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 () => {
-    let calls = ref([])
-    let fire = Watch.debounce(40, (e, _p) => calls := Array.concat(calls.contents, [e]))
-    fire(Watch.Change, "/p/src/A.res")
-    await delay(120)
-    expect(calls.contents)->toEqual([Watch.Change])
-  })
-})