fix(oracle-gaps): Windows static and e2e failures, by class (follow-up to #58)

.github/workflows/pr.yml

@@ -168,10 +168,11 @@ jobs:
       - test-oracle-gaps-fast
       - test-oracle-gaps-end-to-end
       - test-vitest-5
-      # The blocking Windows jobs (the non-blocking static and e2e jobs are not
-      # a dependency until they are green).
+      # The blocking Windows jobs (the non-blocking end-to-end job is not a
+      # dependency until it is green).
       - windows-unit
       - windows-gap-classify
+      - windows-gap-oracles
       - windows-gap-cli
     runs-on: ubuntu-latest
     steps:
@@ -223,10 +224,6 @@ jobs:
   windows-gap-oracles:
     name: Windows gap report static oracle (${{ matrix.shard }}/6)
     runs-on: windows-latest
-    # Not blocking yet: these suites fail on Windows, tracked by class in
-    # https://github.com/TanStack/oracles/issues/72. Remove this line when they
-    # are green.
-    continue-on-error: true
     timeout-minutes: 20
     strategy:
       fail-fast: false
@@ -287,7 +284,8 @@ jobs:
         working-directory: packages/oracles
         env:
           SHARD: ${{ matrix.shard }}
-        run: pnpm exec vitest --run --config oracle-gaps/vitest.config.mjs gap-report-oracle -t "$(node scripts/pr-shards.mjs pattern oracle-gaps-fixed-seed-windows "$SHARD")"
+        # The verbose reporter prints each test with its duration, which sizes the shards.
+        run: pnpm exec vitest --run --reporter=verbose --config oracle-gaps/vitest.config.mjs gap-report-oracle -t "$(node scripts/pr-shards.mjs pattern oracle-gaps-fixed-seed-windows "$SHARD")"
   windows-gap-cli:
     name: Windows gap CLI on a fixture
     runs-on: windows-latest

packages/oracles/oracle-gaps/capture-setup.mjs

@@ -953,23 +953,29 @@ if (state.capture || idleProfile) {
   let since
   let last
   let longest = 0
+  // Profiling only: how many samples each condition blocked the idle clock.
+  let blocked = new Map()
+  // The test whose samples are being recorded (profiling).
+  let key
   let use = realUse()
   let reported = false
   beforeEach(() => {
     if (continuing) return
     baseTimers = timersListed(process.getActiveResourcesInfo())
     since = undefined
     longest = 0
+    blocked = new Map()
     sawIo = false
   })
   beforeEach((context) => {
     if (continuing) return
+    key = testKey(context.task)
     context.onTestFinished(() => {
       baseTimers = undefined
       if (idleProfile)
         appendFileSync(
           idleProfile,
-          `${JSON.stringify({ key: testKey(context.task), longest })}\n`,
+          `${JSON.stringify({ key: testKey(context.task), longest, blocked: Object.fromEntries(blocked) })}\n`,
         )
     })
   })
@@ -988,14 +994,27 @@ if (state.capture || idleProfile) {
     // a timeout at the limit anyway (a collection's five-minute GC timer).
     const horizon = now + (state.idleHorizonMs ?? Infinity)
     const timerDue = [...pending.values()].some((due) => due <= horizon)
-    if (
-      late ||
-      io ||
-      used.utilization > 0.05 ||
-      timerDue ||
-      timersListed(kinds) > baseTimers
-    ) {
+    const blocker = late
+      ? `late`
+      : io
+        ? `io ${kinds.filter((kind) => !quiet.has(kind)).join(`,`)}`
+        : used.utilization > 0.05
+          ? `busy`
+          : timerDue
+            ? `timer due`
+            : timersListed(kinds) > baseTimers
+              ? `timers listed`
+              : undefined
+    // Each sample of a copy that can be cut off is written as it happens, so
+    // a copy the watchdog kills keeps its samples (profiling).
+    if (idleProfile && state.idleMs)
+      appendFileSync(
+        idleProfile,
+        `${JSON.stringify({ sample: blocker ?? `idle`, key, at: Math.round(now) })}\n`,
+      )
+    if (blocker !== undefined) {
       since = undefined
+      if (idleProfile) blocked.set(blocker, (blocked.get(blocker) ?? 0) + 1)
       return
     }
     since ??= now

packages/oracles/oracle-gaps/check.mjs

@@ -778,7 +778,7 @@ export default async (env) => {
       for (const path of paths) {
         const hash = servedHash(path, index)
         if (served.get(path) === hash) continue
-        context.invalidateFile(path)
+        context.invalidateFile(posix(path))
         served.set(path, hash)
       }
     }
@@ -1457,7 +1457,7 @@ export default async (env) => {
         const hash = started.get(path) ?? now
         const read = served.get(path) ?? hash
         // The context may hold other text than the path's text now.
-        if (read !== now || hash !== now) context.invalidateFile(path)
+        if (read !== now || hash !== now) context.invalidateFile(posix(path))
         if (hash !== now) stable = false
         served.set(path, now)
         return [path, hash]

packages/oracles/oracle-gaps/daemon.mjs

@@ -29,6 +29,7 @@
 import { spawn } from 'node:child_process'
 import { randomUUID } from 'node:crypto'
 import {
+  existsSync,
   linkSync,
   mkdirSync,
   openSync,
@@ -370,6 +371,22 @@ async function serve(pkg) {
             stderr.push(`${line}\n`),
           )
           await store.flush()
+          // A test-only pause (ORACLE_GAPS_TEST_PAUSE_AT=daemon-reply, as
+          // ORACLE_GAPS_TEST_STOP): the check is done and its reply is held,
+          // so the CLI waits as it would for a daemon that is slow and dies.
+          // The pause is marked in the check's output directory, with this
+          // daemon's pid, for the oracle to kill it by (no signal pauses a
+          // process on win32).
+          // Once: a daemon that the CLI restarts after this one died inherits the
+          // variable, and must answer, or the CLI waits as long as the run allows.
+          const mark = join(options.out, `paused`)
+          if (
+            process.env.ORACLE_GAPS_TEST_PAUSE_AT === `daemon-reply` &&
+            !existsSync(mark)
+          ) {
+            writeFileSync(mark, `${process.pid}`)
+            await new Promise(() => {})
+          }
         } catch (error) {
           failed = sent(error)
         }