@reventlessdev/reventless-gwt 1.0.0-alpha.75 → 1.0.0-alpha.77

package/src/Bind.res.mjs

@@ -6,12 +6,12 @@ let describe = Collector$ReventlessGwt.pushDescribe;
 
 function test(slice, name, body) {
   let location = Collector$ReventlessGwt.captureLocation(1);
-  Collector$ReventlessGwt.push(slice, location, name, () => Promise.resolve(body()));
+  Collector$ReventlessGwt.push(slice, location, undefined, name, () => Promise.resolve(body()));
 }
 
 function testPromise(slice, name, body) {
   let location = Collector$ReventlessGwt.captureLocation(1);
-  Collector$ReventlessGwt.push(slice, location, name, body);
+  Collector$ReventlessGwt.push(slice, location, undefined, name, body);
 }
 
 export {

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/Cancellation.res

@@ -24,6 +24,12 @@ let install = () => {
         | _ => ()
         }
       )
+    } else {
+      // Second signal: the first requested a graceful drain, but a hung await
+      // can keep the process alive indefinitely. Honour the operator's repeat
+      // SIGINT/SIGTERM as a hard exit (130 = terminated by SIGINT) so only the
+      // one signal — not SIGKILL — is needed to break out.
+      process->exit(130)
     }
   }
   process->onSignal("SIGINT", handler)

package/src/Cancellation.res.mjs

@@ -19,7 +19,9 @@ function onCancel(handler) {
 
 function install() {
   let handler = () => {
-    if (!cancelled.contents) {
+    if (cancelled.contents) {
+      process.exit(130);
+    } else {
       cancelled.contents = true;
       handlers.contents.forEach(h => {
         try {
@@ -28,7 +30,6 @@ function install() {
           return;
         }
       });
-      return;
     }
   };
   process.on("SIGINT", handler);

package/src/ChildProcess.res

@@ -35,7 +35,9 @@ let mergeEnv = (overrides: option<Dict.t<string>>): Dict.t<string> => {
 @get external _stderr: t => stream = "stderr"
 @send external _streamSetEncoding: (stream, string) => unit = "setEncoding"
 @send external _streamOn: (stream, string, string => unit) => unit = "on"
+@send external _streamOnEnd: (stream, string, unit => unit) => unit = "on"
 @send external _procOnClose: (t, string, Nullable.t<int> => unit) => unit = "on"
+@send external _procOnError: (t, string, JsExn.t => unit) => unit = "on"
 @send external _kill: (t, string) => bool = "kill"
 @val external _processKill: (int, string) => unit = "process.kill"
 
@@ -45,7 +47,10 @@ let spawn = (cmd: string, args: array<string>, ~cwd: string, ~env: option<Dict.t
 let pid = (proc: t): option<int> => proc->_pid->Nullable.toOption
 
 // Subscribe to a stream line-by-line (stdout or stderr), buffering partial
-// chunks. Used to classify ReScript compiler markers in Phase 5.
+// chunks. Used to classify ReScript compiler markers in Phase 5. On stream
+// `end` the final unterminated line is flushed — crash/panic messages
+// typically lack a trailing newline, so without this the last (often most
+// diagnostic) line was silently dropped.
 let onLines = (s: stream, cb: string => unit): unit => {
   _streamSetEncoding(s, "utf8")
   let buf = ref("")
@@ -63,6 +68,13 @@ let onLines = (s: stream, cb: string => unit): unit => {
       }
     drain()
   })
+  _streamOnEnd(s, "end", () =>
+    if buf.contents != "" {
+      let last = buf.contents
+      buf := ""
+      cb(last)
+    }
+  )
 }
 
 let onStdoutLine = (proc: t, cb: string => unit): unit => onLines(proc->_stdout, cb)
@@ -70,6 +82,12 @@ let onStderrLine = (proc: t, cb: string => unit): unit => onLines(proc->_stderr,
 let onClose = (proc: t, cb: option<int> => unit): unit =>
   _procOnClose(proc, "close", code => cb(code->Nullable.toOption))
 
+// A spawn failure (ENOENT for a missing binary, EACCES, …) emits `"error"` on
+// the child, not `"close"`. Without a listener Node re-throws it as an uncaught
+// exception and crashes the whole CLI. Route the message to the caller instead.
+let onError = (proc: t, cb: string => unit): unit =>
+  _procOnError(proc, "error", e => cb(e->JsExn.message->Option.getOr("spawn failed")))
+
 // Kill the child's whole process group (negative pid) so the rescript watcher
 // pnpm spawned dies too. Falls back to a direct kill if the pid is gone.
 let killTree = (proc: t, signal: string): unit =>

package/src/ChildProcess.res.mjs

@@ -1,5 +1,7 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+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_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as Nodechild_process from "node:child_process";
 
@@ -49,6 +51,14 @@ function onLines(s, cb) {
     };
     drain();
   });
+  s.on("end", () => {
+    if (buf.contents === "") {
+      return;
+    }
+    let last = buf.contents;
+    buf.contents = "";
+    cb(last);
+  });
 }
 
 function onStdoutLine(proc, cb) {
@@ -63,6 +73,10 @@ function onClose(proc, cb) {
   proc.on("close", code => cb((code == null) ? undefined : Primitive_option.some(code)));
 }
 
+function onError(proc, cb) {
+  proc.on("error", e => cb(Stdlib_Option.getOr(Stdlib_JsExn.message(e), "spawn failed")));
+}
+
 function killTree(proc, signal) {
   let p = Primitive_option.fromNullable(proc.pid);
   if (p !== undefined) {
@@ -87,6 +101,7 @@ export {
   onStdoutLine,
   onStderrLine,
   onClose,
+  onError,
   killTree,
 }
-/* node:child_process Not a pure module */
+/* Stdlib_JsExn Not a pure module */

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,
       })
     }
   }
@@ -222,6 +246,42 @@ let exnMessage: exn => string = %raw(`function(e) {
   return "unknown error"
 }`)
 
+// Default per-test deadline (ms) when a test body doesn't set `~timeout`.
+// Mirrors Jest's default so behaviour is consistent across both runners.
+let defaultTimeoutMs = 5000
+
+// Resolve to a timeout `Outcome` after `ms`. Raced against the test body so a
+// hung await reports a failure instead of wedging the entire run.
+type timeoutHandle
+@val external setTimeout: (unit => unit, int) => timeoutHandle = "setTimeout"
+@val external clearTimeout: timeoutHandle => unit = "clearTimeout"
+let raceWithTimeout = (body: unit => promise<Outcome.outcome>, ms: int): promise<
+  Outcome.outcome,
+> => {
+  let handleRef: ref<option<timeoutHandle>> = ref(None)
+  let timeout = Promise.make((resolve, _reject) => {
+    handleRef :=
+      Some(
+        setTimeout(
+          () =>
+            resolve(
+              Outcome.fail(
+                Throw({error: `timed out after ${Int.toString(ms)}ms`, stack: ""}),
+              ),
+            ),
+          ms,
+        ),
+      )
+  })
+  Promise.race([body(), timeout])->Promise.then(o => {
+    switch handleRef.contents {
+    | Some(h) => clearTimeout(h)
+    | None => ()
+    }
+    Promise.resolve(o)
+  })
+}
+
 // Execute a single entry, catching exceptions and thrown values so a
 // misbehaved slice doesn't abort the rest of the suite.
 let runEntry = async (entry: Collector.entry): RunnerTypes.testResult => {
@@ -232,7 +292,8 @@ let runEntry = async (entry: Collector.entry): RunnerTypes.testResult => {
   | Collector.Skipped => status := Skip
   | _ =>
     try {
-      let outcome = await entry.body()
+      let deadline = entry.timeout->Option.getOr(defaultTimeoutMs)
+      let outcome = await raceWithTimeout(entry.body, deadline)
       switch outcome {
       | Ok() => status := Pass
       | Error(m) => {
@@ -373,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,
@@ -445,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 {
       | _ => ()
       }
@@ -524,30 +638,99 @@ 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)
   }
+  // Each re-run pass executes in a short-lived Worker so it gets a fresh ESM
+  // module registry (recompiled implementation modules are re-imported instead
+  // of served stale from Node's never-evicting cache) and reclaims the imported
+  // graph on exit. The worker's stdout is piped to ours, so its NDJSON reaches
+  // the client unchanged. One worker per pass; the parent keeps ownership of the
+  // build watchers and chokidar.
+  let currentWorker: ref<option<Worker.t>> = ref(None)
+  Cancellation.onCancel(() =>
+    switch currentWorker.contents {
+    | Some(w) =>
+      let _ = Worker.terminate(w)
+    | None => ()
+    }
+  )
+  // 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, paths}})
+      currentWorker := Some(w)
+      let settled = ref(false)
+      let settle = () =>
+        if !settled.contents {
+          settled := true
+          currentWorker := None
+          resolve()
+        }
+      w->Worker.on("exit", (_code: int) => settle())
+      w->Worker.on("error", e => {
+        Console.error2("gwt run worker error:", e)
+        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 runOnce(opts)
-      runInProgress := false
-      if rerunPending.contents {
-        rerunPending := false
-        let _ = await runOnce(opts)
-        ()
-      }
+      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
@@ -560,35 +743,86 @@ let runWatch = async (opts: options): int => {
   // completion. Edits and adds stay on the lean incremental re-run. VS Code
   // only: a human terminal `watch` keeps the re-run-only loop (it doesn't own
   // the builds, so there's nothing to clean-rebuild).
+  // Guards against two structural paths from the *same* burst (a multi-file move
+  // within one package) each launching a concurrent clean-rebuild of that
+  // package. The first sets the flag; siblings coalesce into its completion
+  // re-run. Watch now emits one callback per distinct structural path, so this
+  // is what makes "rebuild every distinct owning package" (not per-file) true.
+  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)
       let t0 = Date.now()
       FormatterVsCode.buildStart(pkg.dir)
       // Surface a compile error during the rebuild (the clean/build stream is
       // classified for the error marker); the re-run is gated on completion
       // below, not on the classifier, since a one-shot `rescript build` has no
       // "Finished … compilation" terminator.
+      let sawError = ref(false)
       let feed = BuildClassifier.make({
         onStart: () => (),
         onOk: _ms => (),
-        onFail: msg => FormatterVsCode.buildFail(pkg.dir, msg),
+        onFail: msg => {
+          sawError := true
+          FormatterVsCode.buildFail(pkg.dir, msg)
+        },
       })
       ProcessManager.cleanRebuild(
         pkg,
         ~onStdout=(_dir, line) => feed(line),
-        ~onDone=() => {
-          FormatterVsCode.buildOk(pkg.dir, Date.now() -. t0)
-          ignore(run())
+        ~onDone=ok => {
+          rebuilding->Dict.set(pkg.dir, false)
+          // Only report success when the build actually succeeded. On failure
+          // the classifier's `onFail` has usually already emitted the compiler
+          // error; emit a fallback `buildFail` only if it didn't (e.g. a crash
+          // with no recognisable marker), so we never claim `buildOk` over a
+          // broken build and re-run against stale `.res.mjs`.
+          if ok {
+            FormatterVsCode.buildOk(pkg.dir, Date.now() -. t0)
+          } else if !sawError.contents {
+            FormatterVsCode.buildFail(pkg.dir, "clean rebuild failed")
+          }
+          ignore(rediscoverAndRun())
         },
       )
     }
+  // A test file added mid-session runs (discover re-scans each pass) but never
+  // appears in the client's tree, which was emitted once at start. On an `Add`
+  // of a *source* `.res` re-emit the discovery stream (idempotent snapshot) and
+  // (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)
+    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