@pyreon/reactivity 0.22.0 → 0.24.0

package/src/reactive-devtools.ts

@@ -27,6 +27,26 @@
 
 export type ReactiveNodeKind = 'signal' | 'derived' | 'effect'
 
+/**
+ * Source location of a reactive node's creation — captured at registration
+ * time from the user's call stack. Powers "Live Program Inlay Hints" — the
+ * editor surfaces fire counts at the source line where the node was created.
+ *
+ * Captured ONLY when devtools is active (`_active === true`). Stack parsing
+ * is best-effort across V8 / JSC / SpiderMonkey; returns undefined when the
+ * stack format isn't recognized (older runtimes, minified prod, web workers
+ * without source maps). Dev gate is the existing `process.env.NODE_ENV` at
+ * each caller — production paths never run the capture.
+ */
+export interface SourceLocation {
+  /** Absolute path or file URL parsed from the stack frame. */
+  file: string
+  /** 1-based line number. */
+  line: number
+  /** 1-based column number. */
+  col: number
+}
+
 export interface ReactiveNode {
   id: number
   kind: ReactiveNodeKind
@@ -40,6 +60,13 @@ export interface ReactiveNode {
   fires: number
   /** `performance.now()` of the most recent fire, or null. */
   lastFire: number | null
+  /**
+   * Source location of the creation call (`signal(0)` / `computed(...)` /
+   * `effect(...)`). Undefined when devtools wasn't active at creation
+   * time OR the stack format wasn't parseable. Editor inlay-hint surfaces
+   * consume this to merge live fire counts onto static spans.
+   */
+  loc?: SourceLocation
 }
 
 export interface ReactiveEdge {
@@ -60,6 +87,46 @@ export interface ReactiveFire {
   ts: number
 }
 
+/**
+ * Per-source-location fire-count summary. Aggregated from the fire ring
+ * buffer + node registry. The shape an editor / LSP inlay-hint consumer
+ * needs to merge "this signal at line N fires K times" onto static
+ * Reactivity-Lens spans. Pure data, JSON-serializable, no node refs.
+ */
+export interface FireSummary {
+  loc: SourceLocation
+  /** Total fires in the visible ring buffer at this location. */
+  count: number
+  /** Most recent fire `performance.now()` at this location, or null. */
+  lastFire: number | null
+  /** Node kind that fired most recently at this location. */
+  kind: ReactiveNodeKind
+  /**
+   * Exponentially-weighted moving average of the fire rate at this
+   * location, in fires per second. Decayed to "now" at read time so a
+   * node that stopped firing N seconds ago shows a rate that's
+   * exponentially smaller than its steady-state value.
+   *
+   * Calculation uses a 1-second time constant (`LPIH_RATE_TAU_MS`):
+   * - On each fire: `r = r * exp(-dt/TAU) + 1`
+   *   - Steady state at λ fires/sec converges to ≈ λ (when λ × TAU ≫ 1)
+   * - On read: `r_now = r * exp(-dt_since_last/TAU)`
+   *
+   * 0 when there have been no fires (or all fires were >>TAU ago).
+   */
+  rate1s: number
+}
+
+/**
+ * Time constant for the rate1s EWMA (milliseconds). Tuned for the "hot
+ * path debugging" use case: a 1-second time constant means a burst of
+ * fires shows up immediately, then decays to 1/e (~0.37×) after one
+ * second of silence, ~5% after 3 seconds, ~0.7% after 5 seconds.
+ *
+ * @internal — exported for tests + tunability.
+ */
+export const LPIH_RATE_TAU_MS = 1000
+
 // ── Internal node record ─────────────────────────────────────────────────
 
 interface NodeRec {
@@ -72,6 +139,13 @@ interface NodeRec {
   hostRef: WeakRef<{ _s: Set<() => void> | null }> | null
   fires: number
   lastFire: number | null
+  /** Source location captured at registration. Undefined if stack parse failed. */
+  loc?: SourceLocation | undefined
+  /**
+   * EWMA-tracked fire rate (~fires/sec, 1s time constant). Updated on
+   * every fire; decayed to "now" at read time. See `FireSummary.rate1s`.
+   */
+  rate1s: number
 }
 
 let _active = false
@@ -154,6 +228,70 @@ export function isReactiveDevtoolsActive(): boolean {
 // ── Instrumentation entry points (called from the hot paths, but only
 //    after the existing prod gate; each is a no-op until activated) ──────
 
+/**
+ * Parse the user's call site from `new Error().stack`. Returns undefined
+ * when devtools isn't active (zero-cost early-return — no Error allocated)
+ * OR when the stack format isn't recognized.
+ *
+ * `skipFrames` is the number of caller-frames to skip past _captureCallerLocation
+ * itself. The framework's hot-path callers (signal / computedLazy / effect)
+ * pass their own depth so the captured frame is the USER's call to
+ * `signal()` / `computed()` / `effect()`, not the framework's internals.
+ *
+ * Recognized stack formats:
+ *   - V8 (Chrome / Node / Bun):     `    at fn (file:line:col)`
+ *   - V8 (anonymous):               `    at file:line:col`
+ *   - JSC (Safari) + SpiderMonkey:  `fn@file:line:col`
+ *
+ * @internal
+ */
+export function _captureCallerLocation(skipFrames: number): SourceLocation | undefined {
+  if (!_active) return undefined
+  const err = new Error()
+  const raw = err.stack
+  if (!raw) return undefined
+  const lines = raw.split('\n')
+  // V8 prepends "Error\n"; JSC doesn't. Detect and offset.
+  const startIdx = lines[0] && lines[0].trim().startsWith('Error') ? 1 : 0
+  // Skip past _captureCallerLocation's own frame (always +1) + caller's depth.
+  const target = lines[startIdx + 1 + skipFrames]
+  if (!target) return undefined
+  return parseStackLine(target)
+}
+
+/** @internal — exported for unit testing across runtimes. */
+export function _parseStackLine(line: string): SourceLocation | undefined {
+  return parseStackLine(line)
+}
+
+function parseStackLine(line: string): SourceLocation | undefined {
+  // V8 parenthesized form: "    at fnName (file:line:col)"
+  const v8Paren = line.match(/\(([^()]+):(\d+):(\d+)\)\s*$/)
+  if (v8Paren && v8Paren[1] && v8Paren[2] && v8Paren[3]) {
+    const file = v8Paren[1]
+    const lineN = Number.parseInt(v8Paren[2], 10)
+    const col = Number.parseInt(v8Paren[3], 10)
+    if (Number.isFinite(lineN) && Number.isFinite(col)) return { file, line: lineN, col }
+  }
+  // V8 anonymous form: "    at file:line:col"
+  const v8Bare = line.match(/at\s+([^\s()]+):(\d+):(\d+)\s*$/)
+  if (v8Bare && v8Bare[1] && v8Bare[2] && v8Bare[3]) {
+    const file = v8Bare[1]
+    const lineN = Number.parseInt(v8Bare[2], 10)
+    const col = Number.parseInt(v8Bare[3], 10)
+    if (Number.isFinite(lineN) && Number.isFinite(col)) return { file, line: lineN, col }
+  }
+  // JSC / SpiderMonkey form: "fnName@file:line:col"
+  const jsc = line.match(/@([^@\s]+):(\d+):(\d+)\s*$/)
+  if (jsc && jsc[1] && jsc[2] && jsc[3]) {
+    const file = jsc[1]
+    const lineN = Number.parseInt(jsc[2], 10)
+    const col = Number.parseInt(jsc[3], 10)
+    if (Number.isFinite(lineN) && Number.isFinite(col)) return { file, line: lineN, col }
+  }
+  return undefined
+}
+
 /**
  * Register a signal/computed/effect node. `host` is the object carrying
  * the `_s` subscriber Set (the signal read fn itself, or a computed's
@@ -168,6 +306,7 @@ export function _rdRegister(
   host: { _s: Set<() => void> | null } | null,
   sub: object | null,
   label: string | undefined,
+  loc?: SourceLocation,
 ): number | undefined {
   if (!_active) return undefined
   const id = _nextId++
@@ -179,6 +318,8 @@ export function _rdRegister(
     hostRef: host ? new WeakRef(host) : null,
     fires: 0,
     lastFire: null,
+    loc,
+    rate1s: 0,
   })
   if (sub) _subId.set(sub, id)
   _finalizer.register(node, id)
@@ -212,6 +353,20 @@ export function _rdRecordFire(node: object): void {
       : Date.now()
   if (rec) {
     rec.fires++
+    // EWMA rate update — decay the prior estimate by exp(-dt/TAU), then
+    // add 1 for this fire. At steady state of λ fires/sec, rate1s
+    // converges to ≈ λ when λ·TAU ≫ 1. For TAU=1000ms, that means
+    // "fires per second" in the natural sense.
+    if (rec.lastFire !== null) {
+      const dt = ts - rec.lastFire
+      const decay = Math.exp(-dt / LPIH_RATE_TAU_MS)
+      rec.rate1s = rec.rate1s * decay + 1
+    } else {
+      // First-ever fire: a single isolated fire reads as "1 fire/s" until
+      // the decay-at-read brings it down. Caller can interpret 1.0 as
+      // "at least one recent fire."
+      rec.rate1s = 1
+    }
     rec.lastFire = ts
   }
   if (_fireBuf === null) _fireBuf = new Array<ReactiveFire>(FIRE_CAP)
@@ -255,6 +410,7 @@ export function getReactiveGraph(): ReactiveGraph {
       subscribers: subs?.size ?? 0,
       fires: rec.fires,
       lastFire: rec.lastFire,
+      ...(rec.loc ? { loc: rec.loc } : {}),
     })
     if (subs) {
       for (const cb of subs) {
@@ -266,6 +422,63 @@ export function getReactiveGraph(): ReactiveGraph {
   return { nodes, edges }
 }
 
+/**
+ * Aggregate fire counts by source-location — powers Live Program Inlay
+ * Hints. Walks the live node registry, keys each node by its captured
+ * `loc`, and returns one summary per unique `file:line:col`. Nodes
+ * without a captured location are skipped (their fires are still
+ * visible via `getReactiveGraph()` and `getReactiveFires()` for the
+ * existing graph / timeline surfaces).
+ *
+ * Returns a fresh array, JSON-serializable, safe to ship across the
+ * devtools-host bridge or to write into an LSP cache file.
+ */
+export function getFireSummaries(): FireSummary[] {
+  const byKey = new Map<string, FireSummary>()
+  // Snapshot "now" once per call — decay-at-read uses a consistent timestamp
+  // for all nodes, so two locations firing at the same rate show the same
+  // rate1s value even if iteration walks them in different orders.
+  const nowTs =
+    typeof performance !== 'undefined' && typeof performance.now === 'function'
+      ? performance.now()
+      : Date.now()
+  for (const rec of _byId.values()) {
+    if (!rec.loc) continue
+    if (!rec.ref.deref()) continue
+    const k = `${rec.loc.file}:${rec.loc.line}:${rec.loc.col}`
+    // Decay rate1s to "now" — a node that hasn't fired in 5×TAU shows
+    // ≈0.7% of its steady-state rate; in 10×TAU, basically 0. This is
+    // what makes "stopped firing" visible in the editor.
+    const decayedRate =
+      rec.lastFire !== null
+        ? rec.rate1s * Math.exp(-(nowTs - rec.lastFire) / LPIH_RATE_TAU_MS)
+        : 0
+    const existing = byKey.get(k)
+    if (existing) {
+      existing.count += rec.fires
+      // Sum rates at same location (e.g. two distinct signals on one
+      // line via destructuring). Latest-fire wins for kind / lastFire.
+      existing.rate1s += decayedRate
+      if (
+        rec.lastFire !== null &&
+        (existing.lastFire === null || rec.lastFire > existing.lastFire)
+      ) {
+        existing.lastFire = rec.lastFire
+        existing.kind = rec.kind
+      }
+    } else {
+      byKey.set(k, {
+        loc: rec.loc,
+        count: rec.fires,
+        lastFire: rec.lastFire,
+        kind: rec.kind,
+        rate1s: decayedRate,
+      })
+    }
+  }
+  return [...byKey.values()]
+}
+
 /** Bounded recent-fire timeline (oldest → newest). Fresh copy. */
 export function getReactiveFires(): ReactiveFire[] {
   if (_fireBuf === null || _fireCount === 0) return []

package/src/signal.ts

@@ -1,6 +1,6 @@
 import { batch, enqueuePendingNotification, isBatching } from './batch'
 import { _notifyTraceListeners, isTracing } from './debug'
-import { _rdRecordFire, _rdRegister } from './reactive-devtools'
+import { _captureCallerLocation, _rdRecordFire, _rdRegister } from './reactive-devtools'
 import { _recordSignalWrite } from './reactive-trace'
 import { notifySubscribers, trackSubscriber } from './tracking'
 
@@ -55,6 +55,17 @@ export interface Signal<T> {
 export interface SignalOptions {
   /** Debug name for this signal — shows up in devtools and debug() output. */
   name?: string
+  /**
+   * @internal — source location injected by `@pyreon/vite-plugin` at build
+   * time. When present, the runtime skips the `new Error().stack` capture
+   * in `_rdRegister` — saves ~2.2µs per signal creation when devtools is
+   * active. Plain user code should NOT set this; the field is opaque
+   * (no public type) so it's not part of the public API surface.
+   *
+   * Shape: `{ file: string; line: number; col: number }` matching
+   * `@pyreon/reactivity`'s `SourceLocation`.
+   */
+  __sourceLocation?: { file: string; line: number; col: number }
 }
 
 // Internal shape of a signal function — state stored as properties on the
@@ -234,8 +245,17 @@ export function signal<T>(initialValue: T, options?: SignalOptions): Signal<T> {
   read.debug = _debug as () => SignalDebugInfo<T>
   read.label = options?.name
 
-  if (process.env.NODE_ENV !== 'production')
-    _rdRegister(read, 'signal', read, null, read.label)
+  if (process.env.NODE_ENV !== 'production') {
+    // Prefer build-time-injected location (zero runtime cost) over the
+    // ~2.2µs stack-capture fallback. @pyreon/vite-plugin's
+    // `injectSignalLocations` rewrites `signal(0)` to
+    // `signal(0, { __sourceLocation: {...} })` at transform time so most
+    // dev-mode signals never pay the stack-capture cost.
+    const loc = options?.__sourceLocation
+      ? options.__sourceLocation
+      : _captureCallerLocation(1)
+    _rdRegister(read, 'signal', read, null, read.label, loc)
+  }
 
   return read as unknown as Signal<T>
 }

package/src/tests/lpih-source-location.test.ts

@@ -0,0 +1,277 @@
+/**
+ * Live Program Inlay Hints — source-location capture for signal/computed/effect.
+ *
+ * Validates that:
+ *   1. When devtools is INACTIVE, no stack capture happens (zero cost).
+ *   2. When devtools is ACTIVE, every reactive creation captures the
+ *      USER's call site (not the framework's internal frames).
+ *   3. `getFireSummaries()` aggregates fires by location with the right
+ *      shape (count, lastFire, kind) and dedupes multiple nodes at the
+ *      same location.
+ *   4. Stack-line parsing handles V8, JSC, and Firefox formats.
+ *   5. `loc` field on `ReactiveNode` is surfaced via `getReactiveGraph()`.
+ */
+import { afterEach, describe, expect, it } from 'vitest'
+import { computed } from '../computed'
+import { effect } from '../effect'
+import {
+  _captureCallerLocation,
+  _parseStackLine,
+  activateReactiveDevtools,
+  deactivateReactiveDevtools,
+  getFireSummaries,
+  getReactiveGraph,
+} from '../reactive-devtools'
+import { signal } from '../signal'
+
+afterEach(() => {
+  deactivateReactiveDevtools()
+})
+
+describe('LPIH — stack-line parser', () => {
+  it('parses V8 parenthesized form', () => {
+    const loc = _parseStackLine(
+      '    at userCode (/Users/test/app.ts:42:7)',
+    )
+    expect(loc).toEqual({ file: '/Users/test/app.ts', line: 42, col: 7 })
+  })
+
+  it('parses V8 anonymous form', () => {
+    const loc = _parseStackLine('    at /Users/test/app.ts:42:7')
+    expect(loc).toEqual({ file: '/Users/test/app.ts', line: 42, col: 7 })
+  })
+
+  it('parses JSC / SpiderMonkey form', () => {
+    const loc = _parseStackLine('userCode@/Users/test/app.ts:42:7')
+    expect(loc).toEqual({ file: '/Users/test/app.ts', line: 42, col: 7 })
+  })
+
+  it('returns undefined for unparseable lines', () => {
+    expect(_parseStackLine('garbage')).toBeUndefined()
+    expect(_parseStackLine('')).toBeUndefined()
+  })
+
+  it('handles file paths with colons (Windows-like or URL schemes)', () => {
+    const loc = _parseStackLine(
+      '    at userCode (file:///Users/test/app.ts:42:7)',
+    )
+    // The regex captures the LAST ":line:col" pair — `file` includes any
+    // earlier colons (file:/// prefix preserved). Editors handle that.
+    expect(loc?.line).toBe(42)
+    expect(loc?.col).toBe(7)
+    expect(loc?.file).toContain('app.ts')
+  })
+})
+
+describe('LPIH — zero-cost when inactive', () => {
+  it('_captureCallerLocation returns undefined when inactive', () => {
+    expect(_captureCallerLocation(0)).toBeUndefined()
+    expect(_captureCallerLocation(5)).toBeUndefined()
+  })
+
+  it('node creation does not allocate Error when inactive', () => {
+    // Indirect proof: capture happens INSIDE the active guard.
+    // No throw, no stack, no observable cost in the path.
+    const s = signal(0)
+    s.set(1)
+    const c = computed(() => s() + 1)
+    c()
+    // No nodes registered because inactive.
+    expect(getReactiveGraph().nodes).toEqual([])
+  })
+})
+
+describe('LPIH — __sourceLocation option (R4 build-time injection)', () => {
+  it('signal() prefers __sourceLocation over stack capture', () => {
+    activateReactiveDevtools()
+    // Simulate what @pyreon/vite-plugin's injectSignalNames emits:
+    const injected = { file: '/some/build/path.tsx', line: 99, col: 42 }
+    const s = signal(0, { name: 'test', __sourceLocation: injected })
+    const nodes = getReactiveGraph().nodes
+    expect(nodes).toHaveLength(1)
+    // The captured location is the INJECTED one, not the test file's location.
+    expect(nodes[0]?.loc?.file).toBe('/some/build/path.tsx')
+    expect(nodes[0]?.loc?.line).toBe(99)
+    expect(nodes[0]?.loc?.col).toBe(42)
+    void s
+  })
+
+  it('signal() falls back to stack capture when __sourceLocation is absent', () => {
+    activateReactiveDevtools()
+    const s = signal(0)
+    const nodes = getReactiveGraph().nodes
+    expect(nodes).toHaveLength(1)
+    // Stack capture → location is the test file.
+    expect(nodes[0]?.loc?.file).toContain('lpih-source-location.test.ts')
+    void s
+  })
+})
+
+describe('LPIH — source-location capture for signals', () => {
+  it('captures the user call site for signal()', () => {
+    activateReactiveDevtools()
+    const s = signal(0) // ← this line
+    const nodes = getReactiveGraph().nodes
+    expect(nodes).toHaveLength(1)
+    expect(nodes[0]?.loc).toBeDefined()
+    expect(nodes[0]?.loc?.file).toContain('lpih-source-location.test.ts')
+    // The line number should point at THIS source file, not signal.ts internals.
+    expect(nodes[0]?.loc?.line).toBeGreaterThan(0)
+    void s
+  })
+
+  it('different signals get different locations', () => {
+    activateReactiveDevtools()
+    const a = signal(0)
+    const b = signal(0)
+    const nodes = getReactiveGraph().nodes
+    expect(nodes).toHaveLength(2)
+    const lineA = nodes[0]?.loc?.line
+    const lineB = nodes[1]?.loc?.line
+    expect(lineA).toBeDefined()
+    expect(lineB).toBeDefined()
+    expect(lineA).not.toBe(lineB)
+    void a
+    void b
+  })
+})
+
+describe('LPIH — source-location capture for computed', () => {
+  it('captures the user call site for computed()', () => {
+    activateReactiveDevtools()
+    const s = signal(1)
+    const c = computed(() => s() * 2) // ← user site
+    c()
+    const nodes = getReactiveGraph().nodes
+    const derived = nodes.find((n) => n.kind === 'derived')
+    expect(derived?.loc).toBeDefined()
+    expect(derived?.loc?.file).toContain('lpih-source-location.test.ts')
+  })
+})
+
+describe('LPIH — source-location capture for effect', () => {
+  it('captures the user call site for effect()', () => {
+    activateReactiveDevtools()
+    const s = signal(0)
+    const e = effect(() => {
+      s()
+    })
+    const nodes = getReactiveGraph().nodes
+    const eff = nodes.find((n) => n.kind === 'effect')
+    expect(eff?.loc).toBeDefined()
+    expect(eff?.loc?.file).toContain('lpih-source-location.test.ts')
+    e.dispose()
+  })
+})
+
+describe('LPIH — getFireSummaries()', () => {
+  it('returns empty when no nodes have locations', () => {
+    activateReactiveDevtools()
+    // No creations yet
+    expect(getFireSummaries()).toEqual([])
+  })
+
+  it('aggregates fires by location', () => {
+    activateReactiveDevtools()
+    const s = signal(0)
+    s.set(1)
+    s.set(2)
+    s.set(3)
+    const summaries = getFireSummaries()
+    expect(summaries).toHaveLength(1)
+    expect(summaries[0]?.count).toBe(3)
+    expect(summaries[0]?.kind).toBe('signal')
+    expect(summaries[0]?.lastFire).not.toBeNull()
+    expect(summaries[0]?.loc.file).toContain('lpih-source-location.test.ts')
+    void s
+  })
+
+  it('produces one summary per unique location', () => {
+    activateReactiveDevtools()
+    const a = signal(0)
+    const b = signal(0)
+    a.set(1)
+    a.set(2)
+    b.set(1)
+    const summaries = getFireSummaries()
+    expect(summaries).toHaveLength(2)
+    const total = summaries.reduce((acc, s) => acc + s.count, 0)
+    expect(total).toBe(3)
+    void a
+    void b
+  })
+
+  it('captures fires across signal + computed + effect', () => {
+    activateReactiveDevtools()
+    const s = signal(0)
+    const c = computed(() => s() * 2)
+    let observed = 0
+    const e = effect(() => {
+      observed = c()
+    })
+    s.set(5)
+    s.set(10)
+    const summaries = getFireSummaries()
+    // Expect at least 3 distinct locations (signal, computed, effect).
+    expect(summaries.length).toBeGreaterThanOrEqual(3)
+    const kinds = new Set(summaries.map((sum) => sum.kind))
+    expect(kinds.has('signal')).toBe(true)
+    expect(kinds.has('derived')).toBe(true)
+    expect(kinds.has('effect')).toBe(true)
+    expect(observed).toBe(20)
+    e.dispose()
+  })
+})
+
+describe('LPIH — rate1s EWMA tracking', () => {
+  it('rate1s is 0 for a node that has not fired', () => {
+    activateReactiveDevtools()
+    const s = signal(0)
+    const summaries = getFireSummaries()
+    // Signal was created but never written → rate1s = 0
+    const summary = summaries.find((x) => x.kind === 'signal')
+    expect(summary?.rate1s).toBe(0)
+    void s
+  })
+
+  it('rate1s rises with rapid fires', () => {
+    activateReactiveDevtools()
+    const s = signal(0)
+    for (let i = 0; i < 10; i++) s.set(i + 1)
+    const summaries = getFireSummaries()
+    const summary = summaries.find((x) => x.kind === 'signal')
+    expect(summary?.rate1s).toBeGreaterThan(0)
+    void s
+  })
+
+  it('rate1s for many rapid fires reflects fire density (>1)', () => {
+    activateReactiveDevtools()
+    const s = signal(0)
+    // 100 fires in rapid succession — dt → 0, decay ≈ 1.0, so each fire
+    // adds ~+1 to rate1s. At read time the value is decayed by the small
+    // elapsed time → still well above the threshold.
+    for (let i = 0; i < 100; i++) s.set(i + 1)
+    const summaries = getFireSummaries()
+    const summary = summaries.find((x) => x.kind === 'signal')
+    expect(summary?.rate1s).toBeGreaterThan(10)
+    void s
+  })
+
+  it('rate1s decays to ≈0 after the time constant elapses', async () => {
+    activateReactiveDevtools()
+    const s = signal(0)
+    s.set(1)
+    const initial = getFireSummaries().find((x) => x.kind === 'signal')
+    expect(initial?.rate1s).toBeGreaterThan(0.5)
+    // 1.5s = 1.5× TAU → rate1s should drop to exp(-1.5) ≈ 0.22× initial.
+    await new Promise((r) => setTimeout(r, 1500))
+    const decayed = getFireSummaries().find((x) => x.kind === 'signal')
+    expect(decayed?.rate1s).toBeLessThan(0.5)
+    void s
+  })
+
+  it('exported LPIH_RATE_TAU_MS constant equals 1000 (1 second)', async () => {
+    const { LPIH_RATE_TAU_MS } = await import('../reactive-devtools')
+    expect(LPIH_RATE_TAU_MS).toBe(1000)
+  })
+})