fix(core): keep constructor unbound on withEventMeta proxies

packages/core/src/event-stream/meta.test.ts

@@ -32,6 +32,31 @@ it('withEventMeta only proxy when make sense', () => {
   expect(withEventMeta(data, { id: undefined })).toBe(data)
 })
 
+it('withEventMeta keeps the container visible shape', () => {
+  const data = { value: 123 }
+  const applied = withEventMeta(data, { id: '123' })
+  expect(applied.constructor).toBe(Object)
+  expect(applied).toStrictEqual({ value: 123 })
+
+  class Foo {
+    static bar = 'bar'
+    #value = 123
+    getValue() {
+      return this.#value
+    }
+  }
+  const foo = withEventMeta(new Foo(), { id: '123' })
+  expect(foo.constructor).toBe(Foo)
+  expect((foo.constructor as typeof Foo).bar).toBe('bar')
+  expect(foo).toBeInstanceOf(Foo)
+  expect(foo.getValue()).toBe(123)
+
+  const map = withEventMeta(new Map([['key', 'value']]), { id: '123' })
+  expect(map.constructor).toBe(Map)
+  expect(map.get('key')).toBe('value')
+  expect(map.size).toBe(1)
+})
+
 it('getEventMeta remove unknown meta', () => {
   const data = { value: 123, meta: undefined }
   const meta = { id: '123', unknown: 'value1' }

packages/core/src/event-stream/meta.ts

@@ -45,7 +45,7 @@ export function withEventMeta<T extends object>(container: T, meta: EventMeta):
         return assertedMeta
       }
 
-      return getOrBind(target, prop)
+      return getOrBind(target, prop, { bind: prop !== 'constructor' })
     },
   })
 }

packages/fetch/src/event-stream.test.ts

@@ -29,23 +29,23 @@ describe('toAsyncIteratorObject', () => {
 
     expect(await generator.next()).toSatisfy(({ done, value }) => {
       expect(done).toEqual(false)
-      expect(value).toEqual({ order: 1 })
+      expect(value).toStrictEqual({ order: 1 })
       expect(getEventMeta(value)).toEqual({ id: 'id-1', retry: 10000 })
 
       return true
     })
 
     expect(await generator.next()).toSatisfy(({ done, value }) => {
       expect(done).toEqual(false)
-      expect(value).toEqual({ order: 2 })
+      expect(value).toStrictEqual({ order: 2 })
       expect(getEventMeta(value)).toEqual({ id: 'id-2' })
 
       return true
     })
 
     expect(await generator.next()).toSatisfy(({ done, value }) => {
       expect(done).toEqual(true)
-      expect(value).toEqual({ order: 3 })
+      expect(value).toStrictEqual({ order: 3 })
       expect(getEventMeta(value)).toEqual({ id: 'id-3', retry: 30000 })
 
       return true

packages/peer/src/event-stream.test.ts

@@ -33,6 +33,7 @@ describe('toAsyncIteratorObject', () => {
     queue.push({ id: '1', kind: 'event-stream', json: { event: 'close', data: undefined } })
 
     const r1 = await iter.next()
+    expect(r1.value).toStrictEqual({ val: 42 })
     const [data, meta] = unwrapEvent(r1.value)
     expect(data).toEqual({ val: 42 })
     expect(meta).toEqual({ id: 'ev-1' })