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

package/src/BuildClassifier.res

@@ -74,11 +74,21 @@ let make = (~watchdogMs: int=120_000, cb: callbacks): (string => unit) => {
     buffer := []
   }
 
-  // After output settles, a compile that saw an error (and thus no "Finished"
-  // terminator) is reported failed, capturing a concise message.
+  // Cap the failure message so a pathological build can't emit an unbounded
+  // line. 20 was too tight — a multi-error build has several "We've found a bug"
+  // blocks and the tail (later errors) was silently dropped; keep enough to
+  // carry a handful of blocks.
+  let maxMessageLines = 200
+
+  // After output settles, a build that saw an error (and thus no "Finished"
+  // terminator) is reported failed, capturing a concise message. The condition
+  // is `hasError` alone — not `compiling && hasError` — so an error emitted
+  // *before* the first "Parsed …" line (a crashed toolchain, a pnpm/resolution
+  // failure) still settles into an `onFail` instead of leaving the consumer
+  // pinned at its previous state forever.
   let settle = () =>
-    if compiling.contents && hasError.contents {
-      let msg = buffer.contents->Array.slice(~start=0, ~end=20)->Array.join("\n")
+    if hasError.contents {
+      let msg = buffer.contents->Array.slice(~start=0, ~end=maxMessageLines)->Array.join("\n")
       clearWatchdog()
       cb.onFail(msg)
       reset()
@@ -126,7 +136,7 @@ let make = (~watchdogMs: int=120_000, cb: callbacks): (string => unit) => {
       }
     } else {
       if String.length(l) > 0 {
-        buffer := Array.concat(buffer.contents, [l])
+        buffer.contents->Array.push(l)
       }
       if isErrorMarker(l) {
         hasError := true

package/src/BuildClassifier.res.mjs

@@ -71,10 +71,10 @@ function make(watchdogMsOpt, cb) {
     buffer.contents = [];
   };
   let settle = () => {
-    if (!(compiling.contents && hasError.contents)) {
+    if (!hasError.contents) {
       return;
     }
-    let msg = buffer.contents.slice(0, 20).join("\n");
+    let msg = buffer.contents.slice(0, 200).join("\n");
     clearWatchdog();
     cb.onFail(msg);
     reset();
@@ -116,7 +116,7 @@ function make(watchdogMsOpt, cb) {
       }
     } else {
       if (l.length > 0) {
-        buffer.contents = buffer.contents.concat([l]);
+        buffer.contents.push(l);
       }
       if (isErrorMarker(l)) {
         hasError.contents = true;

package/src/Cli.res

@@ -31,12 +31,35 @@ type options = {
   // the VS Code extension to populate its active-app picker.
   listPlatforms: bool,
   toolVersion: string,
+  // When `Some`, `runOnce` runs exactly these compiled test paths instead of
+  // walking the tree. Set by the watch loop's worker passes (the parent owns
+  // discovery and narrows to the affected package); `None` for the one-shot
+  // `run`/`discover` commands, which discover from `roots`.
+  paths: option<array<string>>,
 }
 
 @val external argv: array<string> = "process.argv"
 
+// chokidar reports paths in the same form as its watched roots (relative when
+// roots are `["."]`), while `Discovery` returns absolute paths. Normalize a
+// changed path to absolute before mapping it to an owning package so the
+// prefix match against the discovered set holds.
+@module("node:path") external resolvePath: string => string = "resolve"
+
 @val external now: unit => float = "performance.now"
 
+type hash
+@module("node:crypto") external createHash: string => hash = "createHash"
+@send external hashUpdate: (hash, string) => hash = "update"
+@send external hashDigest: (hash, string) => string = "digest"
+let sha256 = (s: string): string => createHash("sha256")->hashUpdate(s)->hashDigest("hex")
+
+// Last-emitted domain-analysis fingerprint (deadCode + graph + definitions all
+// derive from the loaded plugin structures). Persists across a watch session's
+// repeated discovery emits so an unchanged graph isn't re-sent — a redundant
+// re-emit forces the client to re-render the domain view for nothing.
+let lastDomainHash: ref<option<string>> = ref(None)
+
 let dateNowIso: unit => string = %raw(`() => new Date().toISOString()`)
 
 let parseFormat = (s: string) =>
@@ -195,6 +218,7 @@ let parseArgv = (argv: array<string>): result<options, string> => {
         uiPorts: uiPorts.contents,
         listPlatforms: listPlatforms.contents,
         toolVersion,
+        paths: None,
       })
     }
   }
@@ -410,17 +434,63 @@ let emitResult = (opts: options, r: RunnerTypes.runResult) =>
     if opts.stream {
       FormatterJson.streamRunEnd(r)
     } else {
-      FormatterJson.emit(r, ~toolVersion=opts.toolVersion)
+      FormatterJson.emit(r, ~toolVersion=opts.toolVersion, ~schemaVersion=?opts.schemaVersion)
     }
   | Tap => FormatterTap.emit(r)
   | Junit => FormatterJunit.emit(r)
   | VsCode => FormatterVsCode.runEnd(r.summary)
   }
 
+// Watch re-run scope. A plain edit under a test-owning package narrows the pass
+// to that package's test files (`RunPackages`); structural rebuilds, new-file
+// adds, and any non-VsCode watch use `RunAll`. Scopes accumulate while a pass is
+// in flight — `RunAll` is absorbing (an all-run unioned with anything is an
+// all-run), and `RunPackages` unions its dirs.
+type runScope = RunAll | RunPackages(array<string>)
+
+let mergeScope = (a: runScope, b: runScope): runScope =>
+  switch (a, b) {
+  | (RunAll, _) | (_, RunAll) => RunAll
+  | (RunPackages(x), RunPackages(y)) =>
+    let seen = Dict.make()
+    let union = []
+    Array.concat(x, y)->Array.forEach(d =>
+      switch seen->Dict.get(d) {
+      | Some(_) => ()
+      | None => {
+          seen->Dict.set(d, true)
+          union->Array.push(d)
+        }
+      }
+    )
+    RunPackages(union)
+  }
+
+// True when `path` sits inside directory `dir` (dir is an ancestor). Lets a
+// package dir be mapped to its test files by prefix, with no per-path fs walk.
+let pathUnderDir = (path: string, dir: string): bool =>
+  String.startsWith(path, String.endsWith(dir, "/") ? dir : dir ++ "/")
+
+// The subset of `allPaths` a scope re-runs.
+let scopeSubset = (scope: runScope, allPaths: array<string>): array<string> =>
+  switch scope {
+  | RunAll => allPaths
+  | RunPackages(dirs) => allPaths->Array.filter(p => dirs->Array.some(d => pathUnderDir(p, d)))
+  }
+
 let runOnce = async (opts: options): int => {
-  let paths = await Discovery.discover(opts.roots)
+  // A watch worker pass supplies the exact path set (parent-owned discovery,
+  // narrowed to the affected package); the one-shot commands discover the tree.
+  let paths = switch opts.paths {
+  | Some(p) => p
+  | None => await Discovery.discover(opts.roots)
+  }
   if opts.format == Json && opts.stream {
-    FormatterJson.streamRunStart(~toolVersion=opts.toolVersion, ~startedAt=dateNowIso())
+    FormatterJson.streamRunStart(
+      ~toolVersion=opts.toolVersion,
+      ~startedAt=dateNowIso(),
+      ~schemaVersion=?opts.schemaVersion,
+    )
   }
   let onFileFinished: option<RunnerTypes.fileResult => unit> = switch (
     opts.format,
@@ -482,15 +552,22 @@ let emitDomainAnalysis = async (pkgs: array<PackageScan.pkg>): unit =>
     | Some(platformModulePath) =>
       try {
         let loaded = await LocalHost.loadGraph(~platformModulePath, ~plugins)
-        FormatterVsCode.deadCode(DomainDeadCode.analyze(~structures=loaded.structures))
-        FormatterVsCode.graph(DomainGraph.build(~structures=loaded.structures))
         // Field schemas for command/event/read-side state (Phase 6.3): the same
         // per-plugin entry the Platform_ComponentDefinitions GraphQL query returns.
-        FormatterVsCode.definitions(
+        let definitions =
           loaded.structures->Array.map(((pluginId, s)) =>
             ReventlessCore.Platform_ComponentDefinitionsApi.encodePluginStructureEntry(~pluginId, s)
-          ),
-        )
+          )
+        // deadCode + graph + definitions are all pure functions of `structures`,
+        // so the definitions JSON is a faithful fingerprint of all three. Skip
+        // the whole emit when it hasn't moved since the last discovery.
+        let fingerprint = sha256(JSON.stringify(JSON.Array(definitions)))
+        if lastDomainHash.contents != Some(fingerprint) {
+          lastDomainHash := Some(fingerprint)
+          FormatterVsCode.deadCode(DomainDeadCode.analyze(~structures=loaded.structures))
+          FormatterVsCode.graph(DomainGraph.build(~structures=loaded.structures))
+          FormatterVsCode.definitions(definitions)
+        }
       } catch {
       | _ => ()
       }
@@ -561,10 +638,18 @@ let startBuildWatchers = (paths: array<string>): unit => {
 
 let runWatch = async (opts: options): int => {
   let roots = opts.roots
+  // Parent-owned discovery set for the VS Code engine: walked once here and
+  // refreshed only on structural rebuilds / new-file adds. A plain edit's re-run
+  // pass reuses it (no per-pass tree re-walk) and narrows to the edited file's
+  // owning test package (`affectedScope`), so an unrelated plugin's tests aren't
+  // re-executed. The per-test NDJSON protocol keeps the client's other results
+  // untouched across a narrowed pass.
+  let discoveredPaths: ref<array<string>> = ref([])
   // For the VS Code client, watch mode is the whole engine: emit the test tree
   // and package set, take over the ReScript builds, then run + re-run on change.
   if opts.format == VsCode {
     let paths = await Discovery.discover(roots)
+    discoveredPaths := paths
     await emitDiscovery(paths)
     startBuildWatchers(paths)
   }
@@ -582,9 +667,12 @@ let runWatch = async (opts: options): int => {
     | None => ()
     }
   )
-  let runInWorker = (): promise<unit> =>
+  // Run one pass in a fresh worker over `paths`. `None` lets the worker discover
+  // the full tree itself — kept for a human terminal `watch`, whose full-summary
+  // output must always reflect every file.
+  let runInWorker = (paths: option<array<string>>): promise<unit> =>
     Promise.make((resolve, _reject) => {
-      let w = Worker.make(Worker.runWorkerUrl, {workerData: opts})
+      let w = Worker.make(Worker.runWorkerUrl, {workerData: {...opts, paths}})
       currentWorker := Some(w)
       let settled = ref(false)
       let settle = () =>
@@ -599,27 +687,50 @@ let runWatch = async (opts: options): int => {
         settle()
       })
     })
+  // Resolve a scope to the concrete path subset for a worker pass. The VS Code
+  // engine passes the parent-owned subset; a human terminal `watch` passes None
+  // (worker discovers), preserving its full-summary semantics.
+  let pathsForScope = (scope: runScope): option<array<string>> =>
+    opts.format == VsCode ? Some(scopeSubset(scope, discoveredPaths.contents)) : None
+  // Single-flight run state machine. A re-run requested while a pass is in flight
+  // coalesces into `pendingScope` (scopes merge; `RunAll` absorbing) and drains
+  // after the current pass. Holding `runInProgress` across the whole drain loop
+  // means only one worker ever runs at a time — a third concurrent request can't
+  // corrupt the run or interleave NDJSON.
   let runInProgress = ref(false)
-  let rerunPending = ref(false)
-  let run = async () => {
+  let pendingScope: ref<option<runScope>> = ref(None)
+  let requestRun = async (scope: runScope) =>
     if runInProgress.contents {
-      rerunPending := true
+      pendingScope :=
+        Some(
+          switch pendingScope.contents {
+          | Some(s) => mergeScope(s, scope)
+          | None => scope
+          },
+        )
     } else {
       runInProgress := true
-      let _ = await runInWorker()
-      // Drain every re-run request that arrived while a pass was in flight.
-      // Clearing `runInProgress` before awaiting the pending pass (the previous
-      // shape) let a third concurrent `run` start mid-drain, which corrupts the
-      // module-global `Collector` and interleaves NDJSON events. Hold the flag
-      // across the whole drain loop so only one pass ever runs at a time.
-      while rerunPending.contents {
-        rerunPending := false
-        let _ = await runInWorker()
-      }
-      runInProgress := false
+      let _ = await runInWorker(pathsForScope(scope))
+      let rec drain = async () =>
+        switch pendingScope.contents {
+        | Some(next) => {
+            pendingScope := None
+            let _ = await runInWorker(pathsForScope(next))
+            await drain()
+          }
+        | None => runInProgress := false
+        }
+      await drain()
+    }
+  let _ = await requestRun(RunAll)
+  // Re-walk discovery (VS Code) then re-run everything. Used after a structural
+  // clean-rebuild, whose relocation may have changed the discovered test set.
+  let rediscoverAndRun = async () => {
+    if opts.format == VsCode {
+      discoveredPaths := (await Discovery.discover(roots))
     }
+    let _ = await requestRun(RunAll)
   }
-  let _ = await run()
   // A *relocation* (a module moved to another directory — a chapter rename /
   // ungroup / move-to-chapter in the extension, or a terminal `mv`) leaves
   // dependents' emitted `.res.mjs` pointing at the old path: incremental
@@ -640,7 +751,7 @@ let runWatch = async (opts: options): int => {
   let rebuilding: Dict.t<bool> = Dict.make()
   let structuralRebuild = (path: string): unit =>
     switch PackageScan.findOwning(path) {
-    | None => ignore(run())
+    | None => ignore(requestRun(RunAll))
     | Some(pkg) if rebuilding->Dict.get(pkg.dir)->Option.getOr(false) => ()
     | Some(pkg) =>
       rebuilding->Dict.set(pkg.dir, true)
@@ -674,7 +785,7 @@ let runWatch = async (opts: options): int => {
           } else if !sawError.contents {
             FormatterVsCode.buildFail(pkg.dir, "clean rebuild failed")
           }
-          ignore(run())
+          ignore(rediscoverAndRun())
         },
       )
     }
@@ -684,17 +795,34 @@ let runWatch = async (opts: options): int => {
   // (re)claim build watchers for any new package before re-running.
   let refreshDiscovery = async () => {
     let paths = await Discovery.discover(roots)
+    discoveredPaths := paths
     await emitDiscovery(paths)
     startBuildWatchers(paths)
-    ignore(run())
+    let _ = await requestRun(RunAll)
   }
+  // Narrow a plain edit's re-run to the edited file's owning test package (VS
+  // Code only). `RunAll` when the file has no owning package, or the owner isn't
+  // one of the discovered test packages (e.g. a framework edit that ripples into
+  // several plugins — full re-run is the safe choice there). A human terminal
+  // `watch` always re-runs everything (full-summary output).
+  let affectedScope = (path: string): runScope =>
+    if opts.format == VsCode {
+      let abs = resolvePath(path)
+      switch PackageScan.findOwning(PackageScan.dirname(abs)) {
+      | Some(pkg) if discoveredPaths.contents->Array.some(p => pathUnderDir(p, pkg.dir)) =>
+        RunPackages([pkg.dir])
+      | _ => RunAll
+      }
+    } else {
+      RunAll
+    }
   let _watcher = Watch.start(roots, (event, path) =>
     if opts.format == VsCode && Watch.isStructuralSource(event, path) {
       structuralRebuild(path)
     } else if opts.format == VsCode && event == Watch.Add && path->String.endsWith(".res") {
       ignore(refreshDiscovery())
     } else {
-      ignore(run())
+      ignore(requestRun(affectedScope(path)))
     }
   )
   // Keep the process alive until cancelled. Awaiting here (rather than letting

package/src/Cli.res.mjs

@@ -1,8 +1,11 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as Nodepath from "node:path";
+import * as Nodecrypto from "node:crypto";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.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 Watch$ReventlessGwt from "./Watch.res.mjs";
 import * as Nodeworker_threads from "node:worker_threads";
@@ -33,6 +36,14 @@ import * as Platform_ComponentDefinitionsApi$ReventlessCore from "@reventlessdev
 
 let toolVersion = "0.1.0";
 
+function sha256(s) {
+  return Nodecrypto.createHash("sha256").update(s).digest("hex");
+}
+
+let lastDomainHash = {
+  contents: undefined
+};
+
 let dateNowIso = (() => new Date().toISOString());
 
 function parseFormat(s) {
@@ -294,7 +305,8 @@ Exit code is 1 if any test failed, 0 otherwise.
         backend: backend,
         uiPorts: uiPorts,
         listPlatforms: listPlatforms,
-        toolVersion: toolVersion
+        toolVersion: toolVersion,
+        paths: undefined
       }
     };
   }
@@ -496,7 +508,7 @@ function emitResult(opts, r) {
       if (opts.stream) {
         return FormatterJson$ReventlessGwt.streamRunEnd(r);
       } else {
-        return FormatterJson$ReventlessGwt.emit(r, opts.toolVersion);
+        return FormatterJson$ReventlessGwt.emit(r, opts.toolVersion, opts.schemaVersion);
       }
     case "Tap" :
       return FormatterTap$ReventlessGwt.emit(r);
@@ -507,10 +519,48 @@ function emitResult(opts, r) {
   }
 }
 
+function mergeScope(a, b) {
+  if (typeof a !== "object") {
+    return "RunAll";
+  }
+  if (typeof b !== "object") {
+    return "RunAll";
+  }
+  let seen = {};
+  let union = [];
+  a._0.concat(b._0).forEach(d => {
+    let match = seen[d];
+    if (match !== undefined) {
+      return;
+    } else {
+      seen[d] = true;
+      union.push(d);
+      return;
+    }
+  });
+  return {
+    TAG: "RunPackages",
+    _0: union
+  };
+}
+
+function pathUnderDir(path, dir) {
+  return path.startsWith(dir.endsWith("/") ? dir : dir + "/");
+}
+
+function scopeSubset(scope, allPaths) {
+  if (typeof scope !== "object") {
+    return allPaths;
+  }
+  let dirs = scope._0;
+  return allPaths.filter(p => dirs.some(d => pathUnderDir(p, d)));
+}
+
 async function runOnce(opts) {
-  let paths = await Discovery$ReventlessGwt.discover(opts.roots);
+  let p = opts.paths;
+  let paths = p !== undefined ? p : await Discovery$ReventlessGwt.discover(opts.roots);
   if (opts.format === "Json" && opts.stream) {
-    FormatterJson$ReventlessGwt.streamRunStart(opts.toolVersion, dateNowIso());
+    FormatterJson$ReventlessGwt.streamRunStart(opts.toolVersion, dateNowIso(), opts.schemaVersion);
   }
   let match = opts.format;
   let match$1 = opts.stream;
@@ -557,9 +607,16 @@ async function emitDomainAnalysis(pkgs) {
   }
   try {
     let loaded = await LocalHost$ReventlessGwt.loadGraph(platformModulePath, plugins);
-    FormatterVsCode$ReventlessGwt.deadCode(DomainDeadCode$ReventlessGwt.analyze(loaded.structures));
-    FormatterVsCode$ReventlessGwt.graph(DomainGraph$ReventlessGwt.build(loaded.structures));
-    return FormatterVsCode$ReventlessGwt.definitions(loaded.structures.map(param => Platform_ComponentDefinitionsApi$ReventlessCore.encodePluginStructureEntry(param[0], param[1])));
+    let definitions = loaded.structures.map(param => Platform_ComponentDefinitionsApi$ReventlessCore.encodePluginStructureEntry(param[0], param[1]));
+    let fingerprint = sha256(JSON.stringify(definitions));
+    if (Primitive_object.notequal(lastDomainHash.contents, fingerprint)) {
+      lastDomainHash.contents = fingerprint;
+      FormatterVsCode$ReventlessGwt.deadCode(DomainDeadCode$ReventlessGwt.analyze(loaded.structures));
+      FormatterVsCode$ReventlessGwt.graph(DomainGraph$ReventlessGwt.build(loaded.structures));
+      return FormatterVsCode$ReventlessGwt.definitions(definitions);
+    } else {
+      return;
+    }
   } catch (exn) {
     return;
   }
@@ -620,8 +677,12 @@ function startBuildWatchers(paths) {
 
 async function runWatch(opts) {
   let roots = opts.roots;
+  let discoveredPaths = {
+    contents: []
+  };
   if (opts.format === "VsCode") {
     let paths = await Discovery$ReventlessGwt.discover(roots);
+    discoveredPaths.contents = paths;
     await emitDiscovery(paths);
     startBuildWatchers(paths);
   }
@@ -635,9 +696,22 @@ async function runWatch(opts) {
       return;
     }
   });
-  let runInWorker = () => new Promise((resolve, _reject) => {
+  let runInWorker = paths => new Promise((resolve, _reject) => {
     let w = new Nodeworker_threads.Worker(Worker$ReventlessGwt.runWorkerUrl, {
-      workerData: opts
+      workerData: {
+        subcommand: opts.subcommand,
+        format: opts.format,
+        stream: opts.stream,
+        watch: opts.watch,
+        filters: opts.filters,
+        schemaVersion: opts.schemaVersion,
+        roots: opts.roots,
+        backend: opts.backend,
+        uiPorts: opts.uiPorts,
+        listPlatforms: opts.listPlatforms,
+        toolVersion: opts.toolVersion,
+        paths: paths
+      }
     });
     currentWorker.contents = Primitive_option.some(w);
     let settled = {
@@ -656,32 +730,67 @@ async function runWatch(opts) {
       settle();
     });
   });
+  let pathsForScope = scope => {
+    if (opts.format === "VsCode") {
+      return scopeSubset(scope, discoveredPaths.contents);
+    }
+  };
   let runInProgress = {
     contents: false
   };
-  let rerunPending = {
-    contents: false
+  let pendingScope = {
+    contents: undefined
   };
-  let run = async () => {
+  let requestRun = async scope => {
     if (runInProgress.contents) {
-      rerunPending.contents = true;
+      let s = pendingScope.contents;
+      pendingScope.contents = s !== undefined ? mergeScope(s, scope) : scope;
       return;
     }
     runInProgress.contents = true;
-    await runInWorker();
-    while (rerunPending.contents) {
-      rerunPending.contents = false;
-      await runInWorker();
+    await runInWorker(pathsForScope(scope));
+    let drain = async () => {
+      let next = pendingScope.contents;
+      if (next !== undefined) {
+        pendingScope.contents = undefined;
+        await runInWorker(pathsForScope(next));
+        return await drain();
+      } else {
+        runInProgress.contents = false;
+        return;
+      }
     };
-    runInProgress.contents = false;
+    return await drain();
+  };
+  await requestRun("RunAll");
+  let rediscoverAndRun = async () => {
+    if (opts.format === "VsCode") {
+      discoveredPaths.contents = await Discovery$ReventlessGwt.discover(roots);
+    }
+    await requestRun("RunAll");
   };
-  await run();
   let rebuilding = {};
   let refreshDiscovery = async () => {
     let paths = await Discovery$ReventlessGwt.discover(roots);
+    discoveredPaths.contents = paths;
     await emitDiscovery(paths);
     startBuildWatchers(paths);
-    run();
+    await requestRun("RunAll");
+  };
+  let affectedScope = path => {
+    if (opts.format !== "VsCode") {
+      return "RunAll";
+    }
+    let abs = Nodepath.resolve(path);
+    let pkg = PackageScan$ReventlessGwt.findOwning(Nodepath.dirname(abs));
+    if (pkg !== undefined && discoveredPaths.contents.some(p => pathUnderDir(p, pkg.dir))) {
+      return {
+        TAG: "RunPackages",
+        _0: [pkg.dir]
+      };
+    } else {
+      return "RunAll";
+    }
   };
   Watch$ReventlessGwt.start(roots, (event, path) => {
     if (opts.format === "VsCode" && Watch$ReventlessGwt.isStructuralSource(event, path)) {
@@ -711,16 +820,16 @@ async function runWatch(opts) {
           } else if (!sawError.contents) {
             FormatterVsCode$ReventlessGwt.buildFail(pkg.dir, "clean rebuild failed");
           }
-          run();
+          rediscoverAndRun();
         });
       }
-      run();
+      requestRun("RunAll");
       return;
     } else {
       if (opts.format === "VsCode" && event === "Add" && path.endsWith(".res")) {
         refreshDiscovery();
       } else {
-        run();
+        requestRun(affectedScope(path));
       }
       return;
     }
@@ -812,6 +921,8 @@ let defaultTimeoutMs = 5000;
 
 export {
   toolVersion,
+  sha256,
+  lastDomainHash,
   dateNowIso,
   parseFormat,
   defaultRoots,
@@ -825,6 +936,9 @@ export {
   loadAndCollect,
   runFiles,
   emitResult,
+  mergeScope,
+  pathUnderDir,
+  scopeSubset,
   runOnce,
   emitDomainAnalysis,
   emitDiscovery,
@@ -835,4 +949,4 @@ export {
   listPlatforms,
   main,
 }
-/* Stdlib_JsExn Not a pure module */
+/* node:path Not a pure module */

package/src/Collector.res

@@ -108,7 +108,7 @@ let push = (
     location,
     timeout,
   }
-  entries := Array.concat(entries.contents, [entry])
+  entries.contents->Array.push(entry)
 }
 
 // A `todo` placeholder: a spec-less slice still ships a discoverable, compiling
@@ -127,7 +127,7 @@ let pushTodo = (name: string) => {
     location: None,
     timeout: None,
   }
-  entries := Array.concat(entries.contents, [entry])
+  entries.contents->Array.push(entry)
 }
 
 let drain = () => {

package/src/Collector.res.mjs

@@ -105,7 +105,7 @@ function push(slice, location, timeout, name, body) {
     location: location,
     timeout: timeout
   };
-  entries.contents = entries.contents.concat([entry]);
+  entries.contents.push(entry);
 }
 
 function pushTodo(name) {
@@ -122,7 +122,7 @@ function pushTodo(name) {
     location: undefined,
     timeout: undefined
   };
-  entries.contents = entries.contents.concat([entry]);
+  entries.contents.push(entry);
 }
 
 function drain() {