fix(tests): keep a real-wait flagged before the fake-timer install in its own hook

A beforeEach/beforeAll that installs fake timers covered its whole suite,
including waits earlier in the same hook body, which run on the real clock.
Only waits after the install in that hook are exempt now; tests and other
hooks in the suite keep the exemption.

Author: waleedlatif1

scripts/check-test-patterns.test.ts

@@ -146,6 +146,20 @@ describe('real-wait', () => {
       ],
       ['sleep() #1'],
     ],
+    [
+      'a sleep before the install in the hook that installs fake timers',
+      [
+        HELPERS,
+        "describe('d', () => {",
+        '  beforeEach(async () => {',
+        '    await sleep(100)',
+        '    vi.useFakeTimers()',
+        '  })',
+        "  it('t', async () => { await sleep(10) })",
+        '})',
+      ],
+      ['sleep() #1'],
+    ],
     [
       'every occurrence, numbered per kind',
       [HELPERS, 'await sleep(10)', 'await new Promise((r) => setTimeout(r, 5))', 'await sleep(20)'],
@@ -201,6 +215,10 @@ describe('real-wait', () => {
       'a sleep under a module-level beforeAll that installs fake timers',
       [HELPERS, "it('t', async () => { await sleep(10) })", 'beforeAll(() => vi.useFakeTimers())'],
     ],
+    [
+      'a sleep after the install in the hook that installs fake timers',
+      [HELPERS, 'beforeAll(async () => {', '  vi.useFakeTimers()', '  await sleep(100)', '})'],
+    ],
   ])('ignores %s', (_name, lines) => {
     expect(waits(lines.join('\n'))).toEqual([])
   })

scripts/check-test-patterns.ts

@@ -329,7 +329,7 @@ function isTimedPromise(node: Node): boolean {
  * Vitest's fake clock fakes each of these whenever it fakes `setTimeout`, and then the wait costs
  * no wall-clock time. Fake timers are in scope when the call sits inside a function (or
  * the module) that installed them in an earlier statement, or inside a `describe` (or the module)
- * whose `beforeEach`/`beforeAll` installs them. A file that mocks `@sim/utils/helpers` gets the
+ * whose `beforeEach`/`beforeAll` installs them, except before the install in that hook's own body. A file that mocks `@sim/utils/helpers` gets the
  * mock's `sleep`, so its imports are not real waits. Each occurrence is its own numbered entry, so
  * the baseline caps the count per file.
  */
@@ -363,7 +363,8 @@ export function findRealWaitViolations(
   }
 
   const programRange: [number, number] = [program.start ?? 0, program.end ?? 0]
-  const fakeClocks: Array<{ scope: [number, number]; after: number }> = []
+  // `real` is the stretch of the scope that runs before the clock is installed.
+  const fakeClocks: Array<{ scope: [number, number]; real: [number, number] }> = []
   const waits: Array<{ node: Node; label: string }> = []
   walkWithAncestors(program, (node, ancestors) => {
     if (isViCall(node, 'useFakeTimers') && fakesSetTimeout(node)) {
@@ -380,9 +381,13 @@ export function findRealWaitViolations(
         (hook.arguments as Node[])[0] === fn
       ) {
         const owner = ancestors[nearestFunctionIndex(ancestors, fnIndex - 1)]
-        fakeClocks.push({ scope: owner ? nodeRange(owner) : programRange, after: -1 })
+        fakeClocks.push({
+          scope: owner ? nodeRange(owner) : programRange,
+          real: [fn.start as number, node.start as number],
+        })
       } else {
-        fakeClocks.push({ scope: fn ? nodeRange(fn) : programRange, after: node.start as number })
+        const scope = fn ? nodeRange(fn) : programRange
+        fakeClocks.push({ scope, real: [scope[0], node.start as number] })
       }
       return
     }
@@ -399,7 +404,8 @@ export function findRealWaitViolations(
   for (const { node, label } of waits) {
     const start = node.start as number
     const faked = fakeClocks.some(
-      ({ scope, after }) => scope[0] <= start && start < scope[1] && start > after
+      ({ scope, real }) =>
+        scope[0] <= start && start < scope[1] && !(real[0] <= start && start < real[1])
     )
     if (faked) continue
     const count = (counts.get(label) ?? 0) + 1