@pyreon/core 0.16.0 → 0.19.0

package/src/tests/reactive-props.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest'
-import { makeReactiveProps, REACTIVE_PROP, _rp } from '../props'
+import { makeReactiveProps, REACTIVE_PROP, _rp, _wrapSpread } from '../props'
 
 describe('makeReactiveProps', () => {
   it('returns raw object when no reactive props exist (fast path)', () => {
@@ -85,3 +85,73 @@ describe('_rp', () => {
     expect(branded()).toBe('hello')
   })
 })
+
+describe('_wrapSpread', () => {
+  it('returns null/undefined unchanged (primitive guard)', () => {
+    expect(_wrapSpread(null)).toBe(null)
+    expect(_wrapSpread(undefined)).toBe(undefined)
+  })
+
+  it('returns source unchanged when no getter descriptors exist (fast path)', () => {
+    const source = { a: 1, b: 'x', c: true }
+    expect(_wrapSpread(source)).toBe(source)
+  })
+
+  it('returns source unchanged for empty objects', () => {
+    const source = {}
+    expect(_wrapSpread(source)).toBe(source)
+  })
+
+  it('wraps getter-shaped reactive props as _rp-branded thunks', () => {
+    let liveValue = 'a'
+    const source = {} as Record<string, unknown>
+    Object.defineProperty(source, 'x', {
+      get: () => liveValue,
+      enumerable: true,
+      configurable: true,
+    })
+
+    const result = _wrapSpread(source) as Record<string, unknown>
+    expect(result).not.toBe(source) // new object allocated
+
+    const wrappedX = result.x as () => unknown
+    expect(typeof wrappedX).toBe('function')
+    expect((wrappedX as unknown as Record<symbol, unknown>)[REACTIVE_PROP]).toBe(true)
+
+    // Lazy read — each call reads the current source[x] getter value
+    expect(wrappedX()).toBe('a')
+    liveValue = 'b'
+    expect(wrappedX()).toBe('b') // live re-read, not captured
+  })
+
+  it('preserves data properties as-is when mixed with getters', () => {
+    const source = { plain: 'data' } as Record<string, unknown>
+    Object.defineProperty(source, 'reactive', {
+      get: () => 'live',
+      enumerable: true,
+      configurable: true,
+    })
+
+    const result = _wrapSpread(source) as Record<string, unknown>
+    expect(result.plain).toBe('data') // copied through
+    expect(typeof result.reactive).toBe('function') // wrapped as thunk
+  })
+
+  it('preserves Reflect.ownKeys symbol-keyed properties', () => {
+    const sym = Symbol('marker')
+    const source = { regular: 'x' } as Record<string | symbol, unknown>
+    Object.defineProperty(source, 'reactive', {
+      get: () => 'live',
+      enumerable: true,
+      configurable: true,
+    })
+    source[sym] = 'symbol-value'
+
+    const result = _wrapSpread(source) as Record<string | symbol, unknown>
+    expect(result.regular).toBe('x')
+    // Note: symbol keys go through Reflect.ownKeys; the wrap path indexes
+    // via `key as string` for type narrowing but the runtime carries them
+    // forward as data properties.
+    expect(typeof result.reactive).toBe('function')
+  })
+})

package/src/tests/telemetry.test.ts

@@ -1,3 +1,4 @@
+import { clearReactiveTrace, signal } from '@pyreon/reactivity'
 import type { ErrorContext } from '../telemetry'
 import { registerErrorHandler, reportError } from '../telemetry'
 
@@ -201,3 +202,96 @@ describe('registerErrorHandler — reactivity bridge (regression)', () => {
     unsub2()
   })
 })
+
+describe('reportError — reactiveTrace enrichment', () => {
+  beforeEach(() => clearReactiveTrace())
+
+  test('attaches recent signal writes to the error context (dev)', () => {
+    const s = signal(0, { name: 'enrichTest' })
+    s.set(1)
+    s.set(2)
+
+    let captured: ErrorContext | undefined
+    const unsub = registerErrorHandler((ctx) => {
+      captured = ctx
+    })
+    reportError({
+      component: 'C',
+      phase: 'render',
+      error: new Error('boom'),
+      timestamp: Date.now(),
+    })
+    unsub()
+
+    expect(captured?.reactiveTrace).toBeDefined()
+    expect(captured!.reactiveTrace).toHaveLength(2)
+    expect(captured!.reactiveTrace![0]).toMatchObject({
+      name: 'enrichTest',
+      prev: '0',
+      next: '1',
+    })
+    expect(captured!.reactiveTrace![1]).toMatchObject({ prev: '1', next: '2' })
+  })
+
+  test('does not overwrite a caller-supplied reactiveTrace', () => {
+    const s = signal(0, { name: 'x' })
+    s.set(99)
+
+    let captured: ErrorContext | undefined
+    const unsub = registerErrorHandler((ctx) => {
+      captured = ctx
+    })
+    const supplied = [{ name: 'manual', prev: 'a', next: 'b', timestamp: 1 }]
+    reportError({
+      component: 'C',
+      phase: 'effect',
+      error: new Error('boom'),
+      timestamp: Date.now(),
+      reactiveTrace: supplied,
+    })
+    unsub()
+
+    expect(captured!.reactiveTrace).toBe(supplied)
+  })
+
+  test('no trace field when there were no signal writes', () => {
+    let captured: ErrorContext | undefined
+    const unsub = registerErrorHandler((ctx) => {
+      captured = ctx
+    })
+    reportError({
+      component: 'C',
+      phase: 'mount',
+      error: new Error('boom'),
+      timestamp: Date.now(),
+    })
+    unsub()
+
+    // Empty buffer → field stays undefined (don't attach a noisy []).
+    expect(captured?.reactiveTrace).toBeUndefined()
+  })
+
+  test('the effect-error bridge path is also enriched', () => {
+    const s = signal('idle', { name: 'phase' })
+    s.set('running')
+
+    let captured: ErrorContext | undefined
+    const unsub = registerErrorHandler((ctx) => {
+      captured = ctx
+    })
+    // Drive the reactivity → core bridge the same way an effect throw does.
+    const bridge = (
+      globalThis as { __pyreon_report_error__?: (e: unknown, p: 'effect') => void }
+    ).__pyreon_report_error__
+    bridge?.(new Error('effect boom'), 'effect')
+    unsub()
+
+    expect(captured?.component).toBe('Effect')
+    expect(captured?.reactiveTrace).toBeDefined()
+    expect(captured!.reactiveTrace![0]).toMatchObject({
+      name: 'phase',
+      prev: '"idle"',
+      next: '"running"',
+    })
+  })
+})