@planet-matrix/mobius-model 0.5.0 → 0.9.0

package/tests/unit/event/class-event-proxy.spec.ts

@@ -0,0 +1,225 @@
+import { expect, test, vi } from "vitest"
+
+import type { BuildEvents, ClassEventProxyOptions } from "#Source/event/index.ts"
+import {
+  ClassEventProxy,
+  EventManager,
+} from "#Source/event/index.ts"
+
+type TestEvents = BuildEvents<{
+  change: (value: number) => void
+  close: (reason: string) => void
+}>
+
+interface TestTarget {
+  events: EventManager<TestEvents>
+}
+
+const createTarget = (): TestTarget => {
+  return { events: new EventManager<TestEvents>() }
+}
+
+const createClassEventProxyHarness = (options?: {
+  onSubscriberError?: (error: unknown) => void
+}): {
+  targetA: TestTarget
+  targetB: TestTarget
+  classEventProxy: ClassEventProxy<TestTarget, TestEvents>
+} => {
+  const targetA = createTarget()
+  const targetB = createTarget()
+  const classEventProxyOptions: ClassEventProxyOptions<TestTarget, TestEvents> = {
+    targetAdapter: {
+      emit: (target, event, ...args): boolean => {
+        return target.events.emit(event, ...args)
+      },
+      subscribe: (target, event, subscriber): void => {
+        target.events.subscribe(event, subscriber)
+      },
+      unsubscribe: (target, event, subscriber): void => {
+        target.events.unsubscribe(event, subscriber)
+      },
+    },
+    ...(options?.onSubscriberError === undefined
+      ? {}
+      : {
+        onSubscriberError: (_subscriberEntry, error): void => {
+          options.onSubscriberError?.(error)
+        },
+      }),
+  }
+  const classEventProxy = new ClassEventProxy<TestTarget, TestEvents>(classEventProxyOptions)
+
+  return {
+    targetA,
+    targetB,
+    classEventProxy,
+  }
+}
+
+test("ClassEventProxy.has reports whether a managed subscriber exists on a target", () => {
+  const { targetA, classEventProxy } = createClassEventProxyHarness()
+  const subscriber = (value: number): void => {
+    void value
+  }
+
+  expect(classEventProxy.has(targetA, "change", subscriber)).toBe(false)
+
+  classEventProxy.subscribe(targetA, "change", subscriber)
+  expect(classEventProxy.has(targetA, "change", subscriber)).toBe(true)
+
+  classEventProxy.unsubscribe(targetA, "change", subscriber)
+  expect(classEventProxy.has(targetA, "change", subscriber)).toBe(false)
+})
+
+test("ClassEventProxy.subscribe creates one bridge per target event and returns a stable entry", () => {
+  const { targetA, targetB, classEventProxy } = createClassEventProxyHarness()
+  const subscribeSpy = vi.spyOn(targetA.events, "subscribe")
+  const valuesA: number[] = []
+  const valuesB: number[] = []
+  const subscriberA = (value: number): void => {
+    valuesA.push(value)
+  }
+  const subscriberB = (value: number): void => {
+    valuesB.push(value)
+  }
+
+  const entryA = classEventProxy.subscribe(targetA, "change", subscriberA)
+  const duplicateEntryA = classEventProxy.subscribe(targetA, "change", subscriberA)
+  classEventProxy.subscribe(targetB, "change", subscriberB)
+
+  expect(duplicateEntryA).toBe(entryA)
+  expect(entryA.once).toBe(false)
+  expect(subscribeSpy).toHaveBeenCalledTimes(1)
+
+  expect(classEventProxy.emit(targetA, "change", 1)).toBe(true)
+  expect(classEventProxy.emit(targetB, "change", 2)).toBe(true)
+  expect(valuesA).toEqual([1])
+  expect(valuesB).toEqual([2])
+})
+
+test("ClassEventProxy.subscribeOnce removes the managed subscriber after the first bridge emission", () => {
+  const handledErrors: unknown[] = []
+  const { targetA, classEventProxy } = createClassEventProxyHarness({
+    onSubscriberError: (error): void => {
+      handledErrors.push(error)
+    },
+  })
+  const onceSubscriber = (): void => {
+    throw new Error("class-proxy-once-failed")
+  }
+
+  const entry = classEventProxy.subscribeOnce(targetA, "change", onceSubscriber)
+
+  expect(entry.once).toBe(true)
+  expect(classEventProxy.emit(targetA, "change", 1)).toBe(true)
+  expect(classEventProxy.has(targetA, "change", onceSubscriber)).toBe(false)
+  expect(handledErrors).toHaveLength(1)
+  expect(targetA.events.emit("change", 2)).toBe(false)
+})
+
+test("ClassEventProxy.unsubscribe removes only the specified managed subscriber", () => {
+  const { targetA, classEventProxy } = createClassEventProxyHarness()
+  const unsubscribeSpy = vi.spyOn(targetA.events, "unsubscribe")
+  const values: number[] = []
+  const keptSubscriber = (value: number): void => {
+    values.push(value)
+  }
+  const removedSubscriber = (value: number): void => {
+    values.push(value * 10)
+  }
+
+  classEventProxy.subscribe(targetA, "change", keptSubscriber)
+  classEventProxy.subscribe(targetA, "change", removedSubscriber)
+
+  expect(classEventProxy.unsubscribe(targetA, "change", removedSubscriber)).toBe(classEventProxy)
+  expect(classEventProxy.emit(targetA, "change", 2)).toBe(true)
+  expect(values).toEqual([2])
+  expect(unsubscribeSpy).not.toHaveBeenCalled()
+
+  classEventProxy.unsubscribe(targetA, "change", keptSubscriber)
+  expect(unsubscribeSpy).toHaveBeenCalledTimes(1)
+})
+
+test("ClassEventProxy.removeSubscribersOfEvent clears one bridged event on one target", () => {
+  const { targetA, classEventProxy } = createClassEventProxyHarness()
+  const unsubscribeSpy = vi.spyOn(targetA.events, "unsubscribe")
+  const closeReasons: string[] = []
+
+  classEventProxy.subscribe(targetA, "change", () => undefined)
+  classEventProxy.subscribe(targetA, "close", (reason) => {
+    closeReasons.push(reason)
+  })
+
+  expect(classEventProxy.removeSubscribersOfEvent(targetA, "change")).toBe(classEventProxy)
+  expect(classEventProxy.emit(targetA, "change", 1)).toBe(false)
+  expect(classEventProxy.emit(targetA, "close", "kept")).toBe(true)
+  expect(closeReasons).toEqual(["kept"])
+  expect(unsubscribeSpy).toHaveBeenCalledTimes(1)
+})
+
+test("ClassEventProxy.removeSubscribersOfTarget clears every bridged event of one target", () => {
+  const { targetA, targetB, classEventProxy } = createClassEventProxyHarness()
+  const unsubscribeSpy = vi.spyOn(targetA.events, "unsubscribe")
+  const keptValues: number[] = []
+
+  classEventProxy.subscribe(targetA, "change", () => undefined)
+  classEventProxy.subscribe(targetA, "close", () => undefined)
+  classEventProxy.subscribe(targetB, "change", (value) => {
+    keptValues.push(value)
+  })
+
+  expect(classEventProxy.removeSubscribersOfTarget(targetA)).toBe(classEventProxy)
+  expect(classEventProxy.emit(targetA, "change", 1)).toBe(false)
+  expect(classEventProxy.emit(targetB, "change", 2)).toBe(true)
+  expect(keptValues).toEqual([2])
+  expect(unsubscribeSpy).toHaveBeenCalledTimes(2)
+})
+
+test("ClassEventProxy.removeAllSubscribers clears every bridged target", () => {
+  const { targetA, targetB, classEventProxy } = createClassEventProxyHarness()
+  const subscriberA = (): void => undefined
+  const subscriberB = (): void => undefined
+
+  classEventProxy.subscribe(targetA, "change", subscriberA)
+  classEventProxy.subscribe(targetB, "close", subscriberB)
+
+  expect(classEventProxy.removeAllSubscribers()).toBe(classEventProxy)
+  expect(classEventProxy.has(targetA, "change", subscriberA)).toBe(false)
+  expect(classEventProxy.has(targetB, "close", subscriberB)).toBe(false)
+  expect(classEventProxy.emit(targetA, "change", 1)).toBe(false)
+  expect(classEventProxy.emit(targetB, "close", "done")).toBe(false)
+})
+
+test("ClassEventProxy.emit delegates to the target adapter and handles managed subscriber errors", () => {
+  const handledErrors: unknown[] = []
+  const { targetA, classEventProxy } = createClassEventProxyHarness({
+    onSubscriberError: (error): void => {
+      handledErrors.push(error)
+    },
+  })
+  const emitSpy = vi.spyOn(targetA.events, "emit")
+
+  classEventProxy.subscribe(targetA, "close", () => {
+    throw new Error("class-proxy-failed")
+  })
+
+  expect(classEventProxy.emit(targetA, "close", "boom")).toBe(true)
+  expect(emitSpy).toHaveBeenCalledTimes(1)
+  expect(handledErrors).toHaveLength(1)
+
+  const consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => undefined)
+
+  try {
+    const { targetA: unmanagedTarget, classEventProxy: unmanagedClassEventProxy } = createClassEventProxyHarness()
+    unmanagedClassEventProxy.subscribe(unmanagedTarget, "close", () => {
+      throw new Error("class-proxy-unhandled")
+    })
+
+    expect(unmanagedClassEventProxy.emit(unmanagedTarget, "close", "boom")).toBe(true)
+    expect(consoleErrorSpy).toHaveBeenCalledTimes(1)
+  }
+  finally {
+    consoleErrorSpy.mockRestore()
+  }
+})

package/tests/unit/event/event-manager.spec.ts

@@ -0,0 +1,246 @@
+import { expect, test, vi } from "vitest"
+
+import type { BuildEvents } from "#Source/event/index.ts"
+import { EventManager } from "#Source/event/index.ts"
+
+type TestEvents = BuildEvents<{
+  ready: (value: number) => void | Promise<void>
+  done: (label: string) => void | Promise<void>
+}>
+const createEventManager = (): EventManager<TestEvents> => {
+  return new EventManager<TestEvents>()
+}
+
+test("EventManager.has reports whether a subscriber is registered", () => {
+  const eventManager = createEventManager()
+  const subscriber = (value: number): void => {
+    void value
+  }
+
+  expect(eventManager.has("ready", subscriber)).toBe(false)
+
+  eventManager.subscribe("ready", subscriber)
+  expect(eventManager.has("ready", subscriber)).toBe(true)
+
+  eventManager.unsubscribe("ready", subscriber)
+  expect(eventManager.has("ready", subscriber)).toBe(false)
+})
+
+test("EventManager.subscribe returns a stable entry and keeps regular subscribers active", () => {
+  const eventManager = createEventManager()
+  const values: number[] = []
+  const subscriber = (value: number): void => {
+    values.push(value)
+  }
+
+  const firstEntry = eventManager.subscribe("ready", subscriber)
+  const duplicateEntry = eventManager.subscribe("ready", subscriber)
+
+  expect(duplicateEntry).toBe(firstEntry)
+  expect(firstEntry.once).toBe(false)
+
+  expect(eventManager.emit("ready", 1)).toBe(true)
+  expect(eventManager.emit("ready", 2)).toBe(true)
+  expect(values).toEqual([1, 2])
+})
+
+test("EventManager.subscribeOnce removes the subscriber after the first emission", () => {
+  const eventManager = createEventManager()
+  const values: number[] = []
+  const subscriber = (value: number): void => {
+    values.push(value)
+  }
+
+  const entry = eventManager.subscribeOnce("ready", subscriber)
+
+  expect(entry.once).toBe(true)
+  expect(eventManager.emit("ready", 1)).toBe(true)
+  expect(eventManager.emit("ready", 2)).toBe(false)
+  expect(values).toEqual([1])
+  expect(eventManager.has("ready", subscriber)).toBe(false)
+})
+
+test("EventManager.unsubscribe removes only the specified subscriber", () => {
+  const eventManager = createEventManager()
+  const values: number[] = []
+  const keptSubscriber = (value: number): void => {
+    values.push(value)
+  }
+  const removedSubscriber = (value: number): void => {
+    values.push(value * 10)
+  }
+
+  eventManager.subscribe("ready", keptSubscriber)
+  eventManager.subscribe("ready", removedSubscriber)
+
+  expect(eventManager.unsubscribe("ready", removedSubscriber)).toBe(eventManager)
+  expect(eventManager.emit("ready", 2)).toBe(true)
+  expect(values).toEqual([2])
+})
+
+test("EventManager.removeSubscribersOfEvent clears subscribers of only one event", () => {
+  const eventManager = createEventManager()
+  const doneValues: string[] = []
+
+  eventManager.subscribe("ready", () => {
+    throw new Error("should-not-run")
+  })
+  eventManager.subscribe("done", (label) => {
+    doneValues.push(label)
+  })
+
+  expect(eventManager.removeSubscribersOfEvent("ready")).toBe(eventManager)
+  expect(eventManager.emit("ready", 1)).toBe(false)
+  expect(eventManager.emit("done", "kept")).toBe(true)
+  expect(doneValues).toEqual(["kept"])
+})
+
+test("EventManager.removeAllSubscribers clears every event subscription", () => {
+  const eventManager = createEventManager()
+
+  eventManager.subscribe("ready", () => undefined)
+  eventManager.subscribe("done", () => undefined)
+
+  expect(eventManager.removeAllSubscribers()).toBe(eventManager)
+  expect(eventManager.emit("ready", 1)).toBe(false)
+  expect(eventManager.emit("done", "done")).toBe(false)
+})
+
+test("EventManager.emit invokes subscribers synchronously and handles sync errors", () => {
+  const handledErrors: unknown[] = []
+  const eventManager = new EventManager<TestEvents>({
+    onSubscriberError: (_subscriberEntry, error): void => {
+      handledErrors.push(error)
+    },
+  })
+  const callOrder: string[] = []
+  const onceSubscriber = (): void => {
+    callOrder.push("once")
+    throw new Error("once-failed")
+  }
+
+  eventManager.subscribe("ready", (value) => {
+    callOrder.push(`regular-${value}`)
+  })
+  eventManager.subscribeOnce("ready", onceSubscriber)
+  eventManager.subscribe("done", () => {
+    throw new Error("sync-failed")
+  })
+
+  expect(eventManager.emit("ready", 1)).toBe(true)
+  expect(eventManager.emit("ready", 2)).toBe(true)
+  expect(callOrder).toEqual(["regular-1", "once", "regular-2"])
+  expect(eventManager.has("ready", onceSubscriber)).toBe(false)
+
+  expect(eventManager.emit("done", "alpha")).toBe(true)
+  expect(handledErrors).toHaveLength(2)
+
+  const consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => undefined)
+
+  try {
+    const unmanagedEventManager = createEventManager()
+    unmanagedEventManager.subscribe("done", () => {
+      throw new Error("unhandled")
+    })
+
+    expect(unmanagedEventManager.emit("done", "beta")).toBe(true)
+    expect(consoleErrorSpy).toHaveBeenCalledTimes(1)
+  }
+  finally {
+    consoleErrorSpy.mockRestore()
+  }
+})
+
+test("EventManager.emitAsync awaits subscribers in registration order and handles async errors", async () => {
+  const handledErrors: unknown[] = []
+  const eventManager = new EventManager<TestEvents>({
+    onSubscriberError: (_subscriberEntry, error): void => {
+      handledErrors.push(error)
+    },
+  })
+  const orderedSteps: string[] = []
+  // oxlint-disable-next-line require-await
+  const onceSubscriber = async (): Promise<void> => {
+    throw new Error("async-failed")
+  }
+
+  eventManager.subscribe("ready", async (value) => {
+    orderedSteps.push(`first-start-${value}`)
+    await Promise.resolve()
+    orderedSteps.push(`first-end-${value}`)
+  })
+  eventManager.subscribe("ready", async (value) => {
+    orderedSteps.push(`second-start-${value}`)
+    await Promise.resolve()
+    orderedSteps.push(`second-end-${value}`)
+  })
+  eventManager.subscribeOnce("ready", onceSubscriber)
+
+  expect(await eventManager.emitAsync("ready", 7)).toBe(true)
+  expect(orderedSteps).toEqual([
+    "first-start-7",
+    "first-end-7",
+    "second-start-7",
+    "second-end-7",
+  ])
+  expect(handledErrors).toHaveLength(1)
+  expect(eventManager.has("ready", onceSubscriber)).toBe(false)
+})
+
+test("EventManager.emitConcurrentAsync awaits subscribers concurrently and handles async errors", async () => {
+  const handledErrors: unknown[] = []
+  const eventManager = new EventManager<TestEvents>({
+    onSubscriberError: (_subscriberEntry, error): void => {
+      handledErrors.push(error)
+    },
+  })
+  const orderedSteps: string[] = []
+  let resolveFirst = (): void => undefined
+  let resolveSecond = (): void => undefined
+  const firstPromise = new Promise<void>((resolve) => {
+    resolveFirst = resolve
+  })
+  const secondPromise = new Promise<void>((resolve) => {
+    resolveSecond = resolve
+  })
+
+  eventManager.subscribe("ready", async () => {
+    orderedSteps.push("first-start")
+    await firstPromise
+    orderedSteps.push("first-end")
+  })
+  eventManager.subscribe("ready", async () => {
+    orderedSteps.push("second-start")
+    await secondPromise
+    orderedSteps.push("second-end")
+  })
+
+  const emitPromise = eventManager.emitConcurrentAsync("ready", 8)
+  await Promise.resolve()
+  expect(orderedSteps).toEqual(["first-start", "second-start"])
+
+  resolveSecond()
+  await Promise.resolve()
+  resolveFirst()
+
+  expect(await emitPromise).toBe(true)
+  expect(orderedSteps).toEqual(["first-start", "second-start", "second-end", "first-end"])
+
+  eventManager.removeAllSubscribers()
+  orderedSteps.length = 0
+
+  eventManager.subscribe("ready", async () => {
+    orderedSteps.push("third-start")
+    await Promise.resolve()
+    orderedSteps.push("third-end")
+  })
+  eventManager.subscribe("ready", async () => {
+    orderedSteps.push("fourth-start")
+    await Promise.resolve()
+    throw new Error("concurrent-failed")
+  })
+
+  expect(await eventManager.emitConcurrentAsync("ready", 9)).toBe(true)
+  expect(orderedSteps).toEqual(["third-start", "fourth-start", "third-end"])
+  expect(handledErrors).toHaveLength(1)
+})

package/tests/unit/event/instance-event-proxy.spec.ts

@@ -0,0 +1,187 @@
+import { expect, test, vi } from "vitest"
+
+import type { BuildEvents, InstanceEventProxyOptions } from "#Source/event/index.ts"
+import {
+  EventManager,
+  InstanceEventProxy,
+} from "#Source/event/index.ts"
+
+type TestEvents = BuildEvents<{
+  change: (value: number) => void
+  error: (message: string) => void
+}>
+
+const createInstanceEventProxyHarness = (options?: {
+  onSubscriberError?: (error: unknown) => void
+}): {
+  target: EventManager<TestEvents>
+  eventProxy: InstanceEventProxy<TestEvents>
+} => {
+  const target = new EventManager<TestEvents>()
+  const eventProxyOptions: InstanceEventProxyOptions<TestEvents> = {
+    targetAdapter: {
+      emit: (event, ...args): boolean => {
+        return target.emit(event, ...args)
+      },
+      subscribe: (event, subscriber): void => {
+        target.subscribe(event, subscriber)
+      },
+      unsubscribe: (event, subscriber): void => {
+        target.unsubscribe(event, subscriber)
+      },
+    },
+    ...(options?.onSubscriberError === undefined
+      ? {}
+      : {
+        onSubscriberError: (_subscriberEntry, error): void => {
+          options.onSubscriberError?.(error)
+        },
+      }),
+  }
+  const eventProxy = new InstanceEventProxy<TestEvents>(eventProxyOptions)
+
+  return {
+    target,
+    eventProxy,
+  }
+}
+
+test("InstanceEventProxy.has reports whether a managed subscriber exists", () => {
+  const { eventProxy } = createInstanceEventProxyHarness()
+  const subscriber = (value: number): void => {
+    void value
+  }
+
+  expect(eventProxy.has("change", subscriber)).toBe(false)
+
+  eventProxy.subscribe("change", subscriber)
+  expect(eventProxy.has("change", subscriber)).toBe(true)
+
+  eventProxy.unsubscribe("change", subscriber)
+  expect(eventProxy.has("change", subscriber)).toBe(false)
+})
+
+test("InstanceEventProxy.subscribe creates one bridge subscriber and returns a stable entry", () => {
+  const { target, eventProxy } = createInstanceEventProxyHarness()
+  const subscribeSpy = vi.spyOn(target, "subscribe")
+  const values: number[] = []
+  const subscriber = (value: number): void => {
+    values.push(value)
+  }
+
+  const firstEntry = eventProxy.subscribe("change", subscriber)
+  const duplicateEntry = eventProxy.subscribe("change", subscriber)
+
+  expect(duplicateEntry).toBe(firstEntry)
+  expect(firstEntry.once).toBe(false)
+  expect(subscribeSpy).toHaveBeenCalledTimes(1)
+
+  expect(eventProxy.emit("change", 1)).toBe(true)
+  expect(values).toEqual([1])
+})
+
+test("InstanceEventProxy.subscribeOnce removes the managed subscriber after the first bridge emission", () => {
+  const handledErrors: unknown[] = []
+  const { eventProxy, target } = createInstanceEventProxyHarness({
+    onSubscriberError: (error): void => {
+      handledErrors.push(error)
+    },
+  })
+  const onceSubscriber = (): void => {
+    throw new Error("proxy-once-failed")
+  }
+
+  const entry = eventProxy.subscribeOnce("change", onceSubscriber)
+
+  expect(entry.once).toBe(true)
+  expect(eventProxy.emit("change", 1)).toBe(true)
+  expect(eventProxy.has("change", onceSubscriber)).toBe(false)
+  expect(handledErrors).toHaveLength(1)
+  expect(target.emit("change", 2)).toBe(false)
+})
+
+test("InstanceEventProxy.unsubscribe removes only the specified managed subscriber", () => {
+  const { target, eventProxy } = createInstanceEventProxyHarness()
+  const unsubscribeSpy = vi.spyOn(target, "unsubscribe")
+  const values: number[] = []
+  const keptSubscriber = (value: number): void => {
+    values.push(value)
+  }
+  const removedSubscriber = (value: number): void => {
+    values.push(value * 10)
+  }
+
+  eventProxy.subscribe("change", keptSubscriber)
+  eventProxy.subscribe("change", removedSubscriber)
+
+  expect(eventProxy.unsubscribe("change", removedSubscriber)).toBe(eventProxy)
+  expect(eventProxy.emit("change", 2)).toBe(true)
+  expect(values).toEqual([2])
+  expect(unsubscribeSpy).not.toHaveBeenCalled()
+
+  eventProxy.unsubscribe("change", keptSubscriber)
+  expect(unsubscribeSpy).toHaveBeenCalledTimes(1)
+})
+
+test("InstanceEventProxy.removeSubscribersOfEvent clears one bridged event", () => {
+  const { target, eventProxy } = createInstanceEventProxyHarness()
+  const unsubscribeSpy = vi.spyOn(target, "unsubscribe")
+  const errors: string[] = []
+
+  eventProxy.subscribe("change", () => undefined)
+  eventProxy.subscribe("error", (message) => {
+    errors.push(message)
+  })
+
+  expect(eventProxy.removeSubscribersOfEvent("change")).toBe(eventProxy)
+  expect(eventProxy.emit("change", 1)).toBe(false)
+  expect(eventProxy.emit("error", "kept")).toBe(true)
+  expect(errors).toEqual(["kept"])
+  expect(unsubscribeSpy).toHaveBeenCalledTimes(1)
+})
+
+test("InstanceEventProxy.removeAllSubscribers clears every bridged event", () => {
+  const { target, eventProxy } = createInstanceEventProxyHarness()
+  const unsubscribeSpy = vi.spyOn(target, "unsubscribe")
+
+  eventProxy.subscribe("change", () => undefined)
+  eventProxy.subscribe("error", () => undefined)
+
+  expect(eventProxy.removeAllSubscribers()).toBe(eventProxy)
+  expect(eventProxy.emit("change", 1)).toBe(false)
+  expect(eventProxy.emit("error", "boom")).toBe(false)
+  expect(unsubscribeSpy).toHaveBeenCalledTimes(2)
+})
+
+test("InstanceEventProxy.emit delegates to the target adapter and handles managed subscriber errors", () => {
+  const handledErrors: unknown[] = []
+  const { target, eventProxy } = createInstanceEventProxyHarness({
+    onSubscriberError: (error): void => {
+      handledErrors.push(error)
+    },
+  })
+  const emitSpy = vi.spyOn(target, "emit")
+
+  eventProxy.subscribe("change", () => {
+    throw new Error("proxy-failed")
+  })
+
+  expect(eventProxy.emit("change", 1)).toBe(true)
+  expect(emitSpy).toHaveBeenCalledTimes(1)
+  expect(handledErrors).toHaveLength(1)
+
+  const consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => undefined)
+
+  try {
+    const { eventProxy: unmanagedEventProxy } = createInstanceEventProxyHarness()
+    unmanagedEventProxy.subscribe("error", () => {
+      throw new Error("proxy-unhandled")
+    })
+
+    expect(unmanagedEventProxy.emit("error", "boom")).toBe(true)
+    expect(consoleErrorSpy).toHaveBeenCalledTimes(1)
+  }
+  finally {
+    consoleErrorSpy.mockRestore()
+  }
+})