@pyreon/reactivity 0.15.0 → 0.18.0

package/src/store.ts

@@ -17,8 +17,60 @@ import { type Signal, signal } from './signal'
 
 // WeakMap: raw object → its reactive proxy (ensures each raw object gets one proxy)
 const proxyCache = new WeakMap<object, object>()
+// Separate cache for shallow proxies — same raw can produce different proxies
+// depending on shallow vs deep mode, so we can't share proxyCache.
+const shallowProxyCache = new WeakMap<object, object>()
 
 const IS_STORE = Symbol('pyreon.store')
+const IS_RAW = Symbol('pyreon.raw')
+
+/**
+ * Mark an object as RAW — `createStore` and `shallowReactive` will return it
+ * unwrapped. Useful when storing class instances, third-party objects, or
+ * other shapes that shouldn't be deeply proxied (Vue 3 parity).
+ *
+ * @example
+ * const cm = markRaw(new CodeMirrorView(...))
+ * const store = createStore({ editor: cm })
+ * store.editor === cm  // true (not wrapped)
+ *
+ * Note: marking is one-way — there's no `unmarkRaw`. Mark BEFORE the object
+ * enters a store; marking after wrap doesn't unwrap an existing proxy.
+ */
+export function markRaw<T extends object>(value: T): T {
+  Object.defineProperty(value, IS_RAW, {
+    value: true,
+    enumerable: false,
+    configurable: true,
+    writable: false,
+  })
+  return value
+}
+
+/** Returns true if the value was marked with `markRaw()`. */
+function isMarkedRaw(value: object): boolean {
+  return (value as Record<symbol, unknown>)[IS_RAW] === true
+}
+
+// Built-in object types that have internal slots and fail the Proxy
+// internal-slot check on every method call (`Map.prototype.set` called on a
+// Proxy → `TypeError: Method ... called on incompatible receiver`). Returning
+// the raw instance keeps these usable but at the cost of fine-grained
+// reactivity for their contents — write replace-the-whole-Map style if you
+// need reactivity (`store.users = new Map(store.users)`). A future PR can
+// add Vue-style collection-aware wrapping for Map/Set if demand emerges.
+function isBuiltinNonProxiable(obj: object): boolean {
+  return (
+    obj instanceof Map ||
+    obj instanceof Set ||
+    obj instanceof WeakMap ||
+    obj instanceof WeakSet ||
+    obj instanceof Date ||
+    obj instanceof RegExp ||
+    obj instanceof Promise ||
+    obj instanceof Error
+  )
+}
 
 /** Returns true if the value is a createStore proxy. */
 export function isStore(value: unknown): boolean {
@@ -34,11 +86,41 @@ export function isStore(value: unknown): boolean {
  * Returns a proxy — mutations to the proxy trigger fine-grained reactive updates.
  */
 export function createStore<T extends object>(initial: T): T {
-  return wrap(initial) as T
+  return wrap(initial, false) as T
+}
+
+/**
+ * Create a SHALLOW reactive store — only top-level mutations trigger updates.
+ * Nested objects are NOT auto-wrapped; reading a nested object returns the
+ * raw reference. Use when:
+ *   - the nested objects are immutable (frozen API responses)
+ *   - you want explicit control over which subtrees are reactive
+ *   - you need to store class instances or third-party objects without
+ *     paying the deep-proxy overhead
+ *
+ * @example
+ * const store = shallowReactive({ user: { name: 'Alice' }, count: 0 })
+ * effect(() => console.log(store.user))  // tracks store.user reference
+ * effect(() => console.log(store.count)) // tracks store.count
+ * store.user.name = 'Bob'                // does NOT trigger any effect
+ * store.count = 5                        // triggers the count effect
+ * store.user = { name: 'Bob' }           // triggers the user effect
+ */
+export function shallowReactive<T extends object>(initial: T): T {
+  return wrap(initial, true) as T
 }
 
-function wrap(raw: object): object {
-  const cached = proxyCache.get(raw)
+function wrap(raw: object, shallow: boolean): object {
+  // Built-ins with internal slots (Map, Set, Date, …) can't be proxied: their
+  // methods fail the receiver check when called on the proxy. Return raw.
+  if (isBuiltinNonProxiable(raw)) return raw
+  // Vue parity — `markRaw()` opts an object out of proxying entirely. Useful
+  // for class instances, third-party objects, or any shape the consumer
+  // wants to keep unwrapped.
+  if (isMarkedRaw(raw)) return raw
+
+  const cache = shallow ? shallowProxyCache : proxyCache
+  const cached = cache.get(raw)
   if (cached) return cached
 
   // Per-property signals. Lazily created on first access.
@@ -63,19 +145,29 @@ function wrap(raw: object): object {
       // Array length — tracked via dedicated signal for push/pop/splice reactivity
       if (isArray && key === 'length') return lengthSig?.()
 
-      // Non-own properties: prototype methods (forEach, map, push, …)
-      // These must be returned untracked so array methods work normally.
-      // Array methods will then go through set/get on indices via the proxy.
+      // Non-own properties without a tracked signal: prototype methods
+      // (forEach, map, push, …) returned untracked so array methods work.
+      // BUT if a signal already exists for this key, the property was tracked
+      // before — most likely the property is currently absent because of a
+      // `delete` operation. Continue tracking via the existing signal so that
+      // a subsequent reassign (`state.b = 99`) re-runs effects that read the
+      // key during its absent window. Without this branch, the `delete` →
+      // notify-undefined → effect-re-runs-and-reads-`undefined`-via-this-fast-
+      // path → effect-loses-subscription chain breaks reactivity for any
+      // delete-then-reassign cycle.
       if (!Object.hasOwn(target, key)) {
+        if (propSignals.has(key)) return propSignals.get(key)?.()
         return (target as Record<PropertyKey, unknown>)[key]
       }
 
       // Track via per-property signal
       const value = getOrCreateSignal(key)()
 
-      // Deep reactivity: wrap nested objects/arrays transparently
-      if (value !== null && typeof value === 'object') {
-        return wrap(value as object)
+      // Deep reactivity: wrap nested objects/arrays transparently. Shallow
+      // mode skips this — nested objects are returned raw so consumers can
+      // mutate them outside the proxy without triggering effects.
+      if (!shallow && value !== null && typeof value === 'object') {
+        return wrap(value as object, false)
       }
 
       return value
@@ -113,9 +205,17 @@ function wrap(raw: object): object {
 
     deleteProperty(target, key) {
       delete (target as Record<PropertyKey, unknown>)[key]
+      // Notify subscribers that the property is now undefined, but KEEP the
+      // signal in `propSignals`. If we delete the entry, a later `set` on the
+      // same key creates a fresh signal — but every effect that previously
+      // read this key tracked the old (dropped) signal and never re-runs on
+      // the reassign. Keeping the entry preserves signal identity across
+      // delete-then-reassign cycles. The trade-off is that long-lived stores
+      // with high churn on transient keys retain those signal entries; for
+      // workloads where that's a real leak, reassign to undefined instead of
+      // delete.
       if (typeof key !== 'symbol' && propSignals.has(key)) {
         propSignals.get(key)?.set(undefined)
-        propSignals.delete(key)
       }
       if (isArray) lengthSig?.set((target as unknown[]).length)
       return true
@@ -134,6 +234,6 @@ function wrap(raw: object): object {
     },
   })
 
-  proxyCache.set(raw, proxy)
+  cache.set(raw, proxy)
   return proxy
 }

package/src/tests/batch.test.ts

@@ -562,3 +562,190 @@ describe('batch — subscriber-throw stale-Set leak (audit bug #19)', () => {
     expect(fires).toBe(3)
   })
 })
+
+// Regression: pre-fix, MAX_PASSES=32 exhaustion was a bisect blind spot — no
+// test verified the warning fires AND that the queue is cleared so the next
+// batch starts clean. Without queue clearing, the offending effect immediately
+// re-trips MAX_PASSES on every subsequent batch, masking the original cause.
+describe('batch — MAX_PASSES exhaustion (regression)', () => {
+  test('infinite re-enqueue loop is contained: warns, drops, next batch clean', () => {
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+
+    // Two signals — the offending effect reads `a` and writes `b`, and a
+    // sibling effect reads `b` and writes `a`. This is the classic
+    // ping-pong infinite loop. Within a single batch, each pass re-enqueues
+    // both effects; MAX_PASSES caps the cascade.
+    const a = signal(0)
+    const b = signal(0)
+    let aReads = 0
+    let bReads = 0
+
+    effect(() => {
+      aReads++
+      // Write to `b` based on `a` — re-enqueues the b-reading effect.
+      b.set(a() + 1)
+    })
+    effect(() => {
+      bReads++
+      // Write to `a` based on `b` — re-enqueues the a-reading effect.
+      a.set(b() + 1)
+    })
+
+    // Initial reads.
+    expect(aReads).toBeGreaterThan(0)
+    expect(bReads).toBeGreaterThan(0)
+    aReads = 0
+    bReads = 0
+
+    // Trigger the loop. The batch should max out at MAX_PASSES and warn.
+    batch(() => {
+      a.set(100)
+    })
+
+    // Warning fires with the actionable hint.
+    expect(warnSpy).toHaveBeenCalledWith(
+      expect.stringContaining('exceeded MAX_PASSES'),
+    )
+    expect(warnSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Common cause'),
+    )
+
+    // Bisect contract: the queue is cleared after the cap, so a fresh
+    // unrelated batch is NOT immediately re-tripped. Without the clear,
+    // any subsequent batch would re-encounter the still-pending effects
+    // and re-fire the warning instantly.
+    warnSpy.mockClear()
+    const unrelated = signal(0)
+    let unrelatedRuns = 0
+    effect(() => {
+      unrelatedRuns++
+      void unrelated()
+    })
+    const baseline = unrelatedRuns
+    batch(() => {
+      unrelated.set(1)
+    })
+    expect(unrelatedRuns).toBe(baseline + 1)
+    expect(warnSpy).not.toHaveBeenCalledWith(
+      expect.stringContaining('exceeded MAX_PASSES'),
+    )
+
+    warnSpy.mockRestore()
+  })
+})
+
+// M6 audit gap (b): writing a signal from inside a `signal.subscribe` listener
+// (raw subscriber, not effect). Writes during dispatch must batch correctly
+// AND not infinite-loop the dispatcher.
+describe('batch — write from raw signal.subscribe listener (regression)', () => {
+  test('listener that writes another signal does not infinite-loop', () => {
+    const a = signal(0)
+    const b = signal(0)
+    const seen: number[] = []
+    a.subscribe(() => {
+      // Write a different signal from inside the dispatch
+      b.set(a.peek() + 100)
+    })
+    b.subscribe(() => {
+      seen.push(b.peek())
+    })
+
+    a.set(5)
+    expect(b.peek()).toBe(105)
+    expect(seen).toEqual([105])
+
+    a.set(7)
+    expect(b.peek()).toBe(107)
+    expect(seen).toEqual([105, 107])
+  })
+
+  test('listener writing the SAME signal short-circuits via Object.is dedup', () => {
+    const s = signal(0)
+    let listenerRuns = 0
+    s.subscribe(() => {
+      listenerRuns++
+      // Re-write same value — _set short-circuits via Object.is
+      s.set(s.peek())
+    })
+
+    s.set(5)
+    // Listener fires once for the user write; the in-listener re-write is
+    // a no-op via Object.is. Without the no-op, this would infinite-loop.
+    expect(listenerRuns).toBe(1)
+  })
+
+  test('listener writing a DIFFERENT value to its own signal is contained by MAX_PASSES', () => {
+    // This IS an infinite re-write loop — listener writes increment, which
+    // re-fires the listener, which writes increment, etc. The MAX_PASSES cap
+    // (PR #462) keeps it bounded. Without it, this test hangs.
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+    const s = signal(0)
+    let listenerRuns = 0
+    s.subscribe(() => {
+      listenerRuns++
+      if (listenerRuns < 1000) s.set(s.peek() + 1)
+    })
+
+    s.set(1)
+    // Bounded — bisect-verifiable: the contract is "doesn't hang" rather
+    // than "fires N times" (the exact count depends on MAX_PASSES timing).
+    expect(listenerRuns).toBeGreaterThan(0)
+    expect(listenerRuns).toBeLessThan(10000) // would be infinite without the cap
+    warnSpy.mockRestore()
+  })
+})
+
+// M6 audit gap (d): cross-batch interleaving — outer batch starts flushing,
+// an inner batch begins inside an effect that fired during flush. The inner
+// batch must drain its own writes correctly without leaking into the outer.
+describe('batch — cross-batch interleaving (regression)', () => {
+  test('inner batch inside effect drains independently', () => {
+    const a = signal(0)
+    const b = signal(0)
+    const c = signal(0)
+    const seen: { a: number; b: number; c: number }[] = []
+
+    effect(() => {
+      const av = a()
+      const bv = b()
+      const cv = c()
+      seen.push({ a: av, b: bv, c: cv })
+      if (av > 0) {
+        batch(() => {
+          b.set(av * 10)
+          c.set(av * 100)
+        })
+      }
+    })
+    seen.length = 0
+
+    batch(() => {
+      a.set(1)
+    })
+
+    // Inner batch's b/c writes should have applied. The effect re-ran with
+    // propagated values (subject to dedup). Final state proves drain.
+    const final = seen[seen.length - 1]
+    expect(final).toEqual({ a: 1, b: 10, c: 100 })
+  })
+
+  test('nested batch with overlapping writes does not double-flush', () => {
+    const s = signal(0)
+    let runs = 0
+    effect(() => {
+      void s()
+      runs++
+    })
+    runs = 0
+
+    batch(() => {
+      s.set(1)
+      batch(() => {
+        s.set(2)
+      })
+      s.set(3)
+    })
+    expect(runs).toBe(1)
+    expect(s.peek()).toBe(3)
+  })
+})

package/src/tests/computed.test.ts

@@ -348,4 +348,58 @@ describe('computed', () => {
       expect(warns.some((m) => m.includes('async function'))).toBe(false)
     })
   })
+
+  // M6 audit gap (c): creating a computed inside another computed's recompute
+  // body. Edge case — the inner computed registers its `recompute` as a
+  // signal subscriber DURING the outer's evaluation. The new computed should
+  // track the outer's source dependency correctly and not crash the recompute.
+  describe('computed-in-computed recompute (regression)', () => {
+    test('creating a computed inside a computed body is safe and tracks correctly', () => {
+      const source = signal(1)
+      let innerCreated = 0
+
+      // Outer computed creates a new computed each time it runs.
+      const outer = computed(() => {
+        const v = source()
+        innerCreated++
+        const inner = computed(() => v * 2)
+        return inner()
+      })
+
+      // First read — outer creates inner #1, returns 2.
+      expect(outer()).toBe(2)
+      expect(innerCreated).toBe(1)
+
+      // Source change — outer recomputes, creates inner #2, returns 4.
+      source.set(2)
+      expect(outer()).toBe(4)
+      expect(innerCreated).toBe(2)
+
+      // Verify the previously-created inner computeds didn't capture stale
+      // tracking — the latest outer() value reflects the latest source.
+      source.set(10)
+      expect(outer()).toBe(20)
+      expect(innerCreated).toBe(3)
+    })
+
+    test('inner computed reads outer source signal — no double-track or recompute leak', () => {
+      const source = signal(1)
+      let outerRuns = 0
+
+      const outer = computed(() => {
+        outerRuns++
+        const v = source()
+        // Inner reads the same source — should not double-subscribe outer.
+        const inner = computed(() => source() + v)
+        return inner()
+      })
+
+      expect(outer()).toBe(2)
+      expect(outerRuns).toBe(1)
+
+      source.set(5)
+      expect(outer()).toBe(10)
+      expect(outerRuns).toBe(2) // not 3 or more (no double-fire)
+    })
+  })
 })

package/src/tests/createSelector.test.ts

@@ -229,4 +229,63 @@ describe('createSelector', () => {
       expect(isSelected(2)).toBe(false)
     })
   })
+
+  // Regression: pre-fix, the source-tracking effect ran forever AND the
+  // per-value subs/hosts Maps grew unboundedly. With dynamic value spaces
+  // (UUIDs, ephemeral IDs) this leaked memory for the lifetime of the
+  // program. dispose() now stops the effect AND clears both Maps.
+  describe('dispose', () => {
+    test('stops source-tracking after dispose', () => {
+      const selected = signal(0)
+      const isSelected = createSelector(() => selected())
+      const runs: number[] = []
+      effect(() => {
+        runs.push(isSelected(1) ? 1 : 0)
+      })
+      expect(runs).toEqual([0])
+      selected.set(1)
+      expect(runs).toEqual([0, 1])
+
+      isSelected.dispose()
+      // Source change after dispose — the effect that tracks `isSelected(1)`
+      // should NOT re-run because the selector's internal effect was stopped.
+      selected.set(2)
+      expect(runs).toEqual([0, 1])
+    })
+
+    test('post-dispose calls return last-known result without tracking', () => {
+      const selected = signal(0)
+      const isSelected = createSelector(() => selected())
+      isSelected.dispose()
+      // Last known value was 0 — calls return its match against the query.
+      expect(isSelected(0)).toBe(true)
+      expect(isSelected(1)).toBe(false)
+    })
+
+    test('dispose is idempotent', () => {
+      const selected = signal(0)
+      const isSelected = createSelector(() => selected())
+      expect(() => {
+        isSelected.dispose()
+        isSelected.dispose()
+        isSelected.dispose()
+      }).not.toThrow()
+    })
+
+    test('post-dispose: source no longer propagates to selector', () => {
+      // Observable consequence of stopping the internal effect — proves
+      // the per-value Maps are no longer being populated either (because
+      // the tracking path is bypassed entirely after dispose).
+      const selected = signal('initial')
+      const isSelected = createSelector(() => selected())
+      // Build up the cache by querying many unique values.
+      for (let i = 0; i < 100; i++) isSelected(`uuid-${i}`)
+      isSelected.dispose()
+      // After dispose, the source is no longer tracked — changing it
+      // doesn't propagate to the selector's internal `current` value.
+      selected.set('changed')
+      expect(isSelected('initial')).toBe(true) // last-known wins
+      expect(isSelected('changed')).toBe(false) // never propagated
+    })
+  })
 })

package/src/tests/fanout-repro.test.ts

@@ -0,0 +1,179 @@
+/**
+ * Reproduction of the deferred bug from PR #490 (queryReactiveKey-1000 journey).
+ *
+ * Symptom from real-app stress: a `reactKey` signal subscribed to by ~100
+ * effects (each useQuery's setOptions effect) sees `signalWrite` increment
+ * on every `.set(i)` in a tight external loop, but only 1 of N effect runs
+ * propagates per .set — `effectRun` stays at the initial-mount count.
+ *
+ * Hypothesis to test: `notifySubscribers` in tracking.ts iterates the live
+ * Set with `originalSize` cap. If an effect's body calls cleanupEffect (which
+ * removes itself from the Set) AND re-subscribes (adds itself back at the
+ * end), the iteration order shifts so subsequent effects' positions move
+ * BEFORE `i`, causing them to be skipped on this pass.
+ *
+ * See packages/core/reactivity/src/tracking.ts:77-105 (notifySubscribers).
+ */
+import { describe, expect, it } from 'vitest'
+import { effect, effectScope, signal } from '../index'
+
+describe('signal fan-out under tight external write loop', () => {
+  it('100 effects subscribing to same signal — each fires on every external .set', () => {
+    const sig = signal(0)
+    const counts = new Array(100).fill(0)
+
+    for (let i = 0; i < 100; i++) {
+      const idx = i
+      effect(() => {
+        sig() // subscribe
+        counts[idx]++
+      })
+    }
+
+    // Each effect ran ONCE at registration.
+    for (const c of counts) expect(c).toBe(1)
+
+    // 10 external writes from outside any batch.
+    for (let i = 1; i <= 10; i++) sig.set(i)
+
+    // Each effect should have re-fired 10 times → total = 11.
+    for (let i = 0; i < counts.length; i++) {
+      expect(counts[i], `effect[${i}] runs after 10 sets`).toBe(11)
+    }
+  })
+
+  it('1 effect — fires on every external .set (control)', () => {
+    const sig = signal(0)
+    let count = 0
+
+    effect(() => {
+      sig()
+      count++
+    })
+
+    expect(count).toBe(1)
+    for (let i = 1; i <= 10; i++) sig.set(i)
+    expect(count).toBe(11)
+  })
+
+  it('5 effects + 5 external sets — each effect fires per set', () => {
+    const sig = signal(0)
+    const counts = new Array(5).fill(0)
+
+    for (let i = 0; i < 5; i++) {
+      const idx = i
+      effect(() => {
+        sig()
+        counts[idx]++
+      })
+    }
+
+    for (let i = 1; i <= 5; i++) sig.set(i)
+
+    // Each effect: 1 initial + 5 re-runs = 6.
+    for (let i = 0; i < counts.length; i++) {
+      expect(counts[i], `effect[${i}]`).toBe(6)
+    }
+  })
+
+  it('100 effects inside an EffectScope — each fires on every external .set', () => {
+    const sig = signal(0)
+    const counts = new Array(100).fill(0)
+    const scope = effectScope()
+
+    scope.runInScope(() => {
+      for (let i = 0; i < 100; i++) {
+        const idx = i
+        effect(() => {
+          sig()
+          counts[idx]++
+        })
+      }
+    })
+
+    for (const c of counts) expect(c).toBe(1)
+
+    for (let i = 1; i <= 10; i++) sig.set(i)
+
+    for (let i = 0; i < counts.length; i++) {
+      expect(counts[i], `effect[${i}] runs after 10 sets`).toBe(11)
+    }
+  })
+
+  it('1000 effects subscribing to same signal — each fires per .set', () => {
+    const sig = signal(0)
+    const counts = new Array(1000).fill(0)
+    for (let i = 0; i < 1000; i++) {
+      const idx = i
+      effect(() => {
+        sig()
+        counts[idx]++
+      })
+    }
+    for (let i = 1; i <= 10; i++) sig.set(i)
+    let failed = 0
+    for (let i = 0; i < counts.length; i++) {
+      if (counts[i] !== 11) failed++
+    }
+    expect(failed, `effects with wrong count`).toBe(0)
+  })
+
+  it('effects created INSIDE another effect run (inner-effect collector path)', () => {
+    const trigger = signal(0)
+    const sig = signal(0)
+    const counts = new Array(50).fill(0)
+    let outerRuns = 0
+
+    // Outer effect creates 50 INNER effects on each run.
+    effect(() => {
+      trigger()
+      outerRuns++
+      for (let i = 0; i < 50; i++) {
+        const idx = i
+        effect(() => {
+          sig()
+          counts[idx]++
+        })
+      }
+    })
+
+    // Reset counts after initial outer run created the inners with their initial run.
+    expect(outerRuns).toBe(1)
+    for (const c of counts) expect(c).toBe(1)
+
+    // Now flip sig 10 times — every inner should fire 10 more times.
+    for (let i = 1; i <= 10; i++) sig.set(i)
+
+    let failed = 0
+    for (let i = 0; i < counts.length; i++) {
+      if (counts[i] !== 11) failed++
+    }
+    expect(failed, `inner effects with wrong count`).toBe(0)
+  })
+
+  it('100 effects whose body writes to an unrelated signal during run', () => {
+    // Mirrors useQuery's effect: body calls observer.setOptions(options())
+    // which fires the observer's subscribe callback, which calls batch()
+    // and writes to N "result slot" signals (which may have 0 or N subscribers).
+    const sig = signal(0)
+    const slot = signal('')
+    const counts = new Array(100).fill(0)
+
+    for (let i = 0; i < 100; i++) {
+      const idx = i
+      effect(() => {
+        sig() // subscribe to sig
+        // Simulate observer.setOptions's downstream subscribe-callback work:
+        // an inner write to a different signal that has no subscribers.
+        slot.set(`run-${idx}`) // 100 different values, each Object.is fails
+        counts[idx]++
+      })
+    }
+
+    for (let i = 1; i <= 10; i++) sig.set(i)
+
+    for (let i = 0; i < counts.length; i++) {
+      expect(counts[i], `effect[${i}] runs after 10 sets`).toBe(11)
+    }
+  })
+})

package/src/tests/manifest-snapshot.test.ts

@@ -68,11 +68,27 @@ describe('gen-docs — reactivity snapshot', () => {
 
   it('renders @pyreon/reactivity to MCP api-reference entries — one per api[] item', () => {
     const record = renderApiReferenceEntries(reactivityManifest)
-    expect(Object.keys(record).length).toBe(8)
+    // 25 entries: 8 original (signal/computed/effect/batch/onCleanup/watch/
+    // createStore/untrack) + 1 createResource (PR #459) + 13 from M1
+    // enrichment (renderEffect, nextTick, createSelector, cell, reconcile,
+    // isStore, effectScope, getCurrentScope, setCurrentScope,
+    // onSignalUpdate, inspectSignal, why, setErrorHandler) + 3 from M4
+    // Vue parity (markRaw, shallowReactive, onScopeDispose).
+    expect(Object.keys(record).length).toBe(25)
     expect(Object.keys(record)).toContain('reactivity/signal')
+    expect(Object.keys(record)).toContain('reactivity/createResource')
     // Spot-check the flagship API — signal is the core primitive
     const signal = record['reactivity/signal']!
     expect(signal.mistakes?.split('\n').length).toBe(6)
     expect(signal.notes).toContain('CALLABLE FUNCTION')
+    // Spot-check createResource has the dispose mistake (regression for H3)
+    const resource = record['reactivity/createResource']!
+    expect(resource.mistakes).toContain('Forgetting `dispose()`')
+    // Spot-check newly-added entries surface their key foot-guns
+    expect(record['reactivity/createSelector']!.mistakes).toContain(
+      'every row subscribes to source',
+    )
+    expect(record['reactivity/effectScope']!.mistakes).toContain('leak')
+    expect(record['reactivity/cell']!.notes).toContain('NOT callable')
   })
 })