docs: add LICENSE, README, CHANGELOG, and license headers for npm publish

- Add combined MIT + Apache-2.0 LICENSE file (Copyright 2026 alk.dev)
- Add README.md with quick start for each adapter, lifecycle/close docs,
  operators, EventEnvelope, TypeScript, exports table, upstream attribution
- Add CHANGELOG.md with 0.1.0 entry
- Add SPDX license headers to original source files (WS client, WS server,
  Worker, index barrel)
- Update package.json: add author, repository, homepage, bugs; include
  CHANGELOG.md in files; update description

CHANGELOG.md

@@ -0,0 +1,43 @@
+# Changelog
+
+## 0.1.0
+
+Initial release.
+
+### Core
+
+- `createPubSub` factory with type-safe `publish`/`subscribe` API (adapted from graphql-yoga, MIT)
+- `TypedEventTarget`, `TypedEvent`, `EventEnvelope` types
+- `Repeater` class for backpressure-aware async iteration (inlined from @repeaterjs/repeater, MIT)
+- Operators: `filter`, `map`, `pipe`, `take`, `reduce`, `toArray`, `batch`, `dedupe`, `window`, `flat`, `groupBy`, `chain`, `join`
+
+### Adapters
+
+- **Redis** — `createRedisEventTarget` (peer dep: `ioredis`). Pub/sub with optional prefix and custom serializer.
+- **WebSocket Client** — `createWebSocketClientEventTarget`. Subscribe/publish over a WebSocket connection.
+- **WebSocket Server** — `createWebSocketServerEventTarget`. Fan-out hub for WebSocket spokes with topic-based routing, backpressure handling, and subscription control protocol (`__subscribe`/`__unsubscribe`).
+- **Worker Host** — `createWorkerHostEventTarget`. Communicate with a Worker thread from the main thread.
+- **Worker Thread** — `createWorkerThreadEventTarget`. Communicate with the main thread from inside a Worker.
+
+### Lifecycle
+
+All transport adapters provide a `close()` method for graceful teardown:
+
+- Unsubscribes from all channels/topics
+- Restores any intercepted `onmessage`/`onclose` handlers
+- Removes message listeners
+- Clears internal state maps
+- Does **not** destroy the underlying transport (caller-owned)
+- Idempotent — safe to call multiple times
+
+### Build
+
+- Dual ESM + CJS output via tsup
+- Sub-path exports for each adapter (`@alkdev/pubsub/event-target-redis`, etc.)
+- Zero runtime dependencies (Repeater is inlined)
+- `sideEffects: false`
+- TypeScript declarations (`.d.ts` + `.d.cts`)
+
+### License
+
+Dual-licensed MIT OR Apache-2.0. Portions adapted from graphql-yoga (MIT) and @repeaterjs/repeater (MIT) retain their upstream attribution.

LICENSE

@@ -0,0 +1,214 @@
+MIT License
+
+Copyright (c) 2026 alk.dev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+---
+
+Apache License
+Version 2.0, January 2004
+http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+"License" shall mean the terms and conditions for use, reproduction,
+and distribution as defined by Sections 1 through 9 of this document.
+
+"Licensor" shall mean the copyright owner or entity authorized by
+the copyright owner that is granting the License.
+
+"Legal Entity" shall mean the union of the acting entity and all
+other entities that control, are controlled by, or are under common
+control with that entity. For the purposes of this definition,
+"control" means (i) the power, direct or indirect, to cause the
+direction or management of such entity, whether by contract or
+otherwise, or (ii) ownership of fifty percent (50%) or more of the
+outstanding shares, or (iii) beneficial ownership of such entity.
+
+"You" (or "Your") shall mean an individual or Legal Entity
+exercising permissions granted by this License.
+
+"Source" form shall mean the preferred form for making modifications,
+including but not limited to software source code, documentation
+source, and configuration files.
+
+"Object" form shall mean any form resulting from mechanical
+transformation or translation of a Source form, including but
+not limited to compiled object code, generated documentation,
+and conversions to other media types.
+
+"Work" shall mean the work of authorship, whether in Source or
+Object form, made available under the License, as indicated by a
+copyright notice that is included in or attached to the work
+(an example is provided in the Appendix below).
+
+"Derivative Works" shall mean any work, whether in Source or Object
+form, that is based on (or derived from) the Work and for which the
+editorial revisions, annotations, elaborations, or other modifications
+represent, as a whole, an original work of authorship. For the purposes
+of this License, Derivative Works shall not include works that remain
+separable from, or merely link (or bind by name) to the interfaces of,
+the Work and Derivative Works thereof.
+
+"Contribution" shall mean any work of authorship, including
+the original version of the Work and any modifications or additions
+to that Work or Derivative Works thereof, that is intentionally
+submitted to the Licensor for inclusion in the Work by the copyright owner
+or by an individual or Legal Entity authorized to submit on behalf of
+the copyright owner. For the purposes of this definition, "submitted"
+means any form of electronic, verbal, or written communication sent
+to the Licensor or its representatives, including but not limited to
+communication on electronic mailing lists, source code control systems,
+and issue tracking systems that are managed by, or on behalf of, the
+Licensor for the purpose of discussing and improving the Work, but
+excluding communication that is conspicuously marked or otherwise
+designated in writing by the copyright owner as "Not a Contribution."
+
+"Contributor" shall mean Licensor and any individual or Legal Entity
+on behalf of whom a Contribution has been received by the Licensor and
+subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+this License, each Contributor hereby grants to You a perpetual,
+worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+copyright license to reproduce, prepare Derivative Works of,
+publicly display, publicly perform, sublicense, and distribute the
+Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+this License, each Contributor hereby grants to You a perpetual,
+worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+(except as stated in this section) patent license to make, have made,
+use, offer to sell, sell, import, and otherwise transfer the Work,
+where such license applies only to those patent claims licensable
+by such Contributor that are necessarily infringed by their
+Contribution(s) alone or by combination of their Contribution(s)
+with the Work to which such Contribution(s) was submitted. If You
+institute patent litigation against any entity (including a
+cross-claim or counterclaim in a lawsuit) alleging that the Work
+or a Contribution incorporated within the Work constitutes direct
+or contributory patent infringement, then any patent licenses
+granted to You under this License for that Work shall terminate
+as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+Work or Derivative Works thereof in any medium, with or without
+modifications, and in Source or Object form, provided that You
+meet the following conditions:
+
+(a) You must give any other recipients of the Work or
+    Derivative Works a copy of this License; and
+
+(b) You must cause any modified files to carry prominent notices
+    stating that You changed the files; and
+
+(c) You must retain, in the Source form of any Derivative Works
+    that You distribute, all copyright, patent, trademark, and
+    attribution notices from the Source form of the Work,
+    excluding those notices that do not pertain to any part of
+    the Derivative Works; and
+
+(d) If the Work includes a "NOTICE" text file as part of its
+    distribution, then any Derivative Works that You distribute must
+    include a readable copy of the attribution notices contained
+    within such NOTICE file, excluding those notices that do not
+    pertain to any part of the Derivative Works, in at least one
+    of the following places: within a NOTICE text file distributed
+    as part of the Derivative Works; within the Source form or
+    documentation, if provided along with the Derivative Works; or,
+    within a display generated by the Derivative Works, if and
+    wherever such third-party notices normally appear. The contents
+    of the NOTICE file are for informational purposes only and
+    do not modify the License. You may add Your own attribution
+    notices within Derivative Works that You distribute, alongside
+    or as an addendum to the NOTICE text from the Work, provided
+    that such additional attribution notices cannot be construed
+    as modifying the License.
+
+You may add Your own copyright statement to Your modifications and
+may provide additional or different license terms and conditions
+for use, reproduction, or distribution of Your modifications, or
+for any such Derivative Works as a whole, provided Your use,
+reproduction, and distribution of the Work otherwise complies with
+the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+any Contribution intentionally submitted for inclusion in the Work by
+You to the Licensor shall be under the terms and conditions of
+this License, without any additional terms or conditions.
+Notwithstanding the above, nothing herein shall supersede or modify
+the terms of any separate license agreement you may have executed
+with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+names, trademarks, service marks, or product names of the Licensor,
+except as required for reasonable and customary use in describing the
+origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+agreed to in writing, Licensor provides the Work (and each
+Contributor provides its Contributions) on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+implied, including, without limitation, any warranties or conditions
+of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+PARTICULAR PURPOSE. You are solely responsible for determining the
+appropriateness of using or redistributing the Work and assume any
+risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+whether in tort (including negligence), contract, or otherwise,
+unless required by applicable law (such as deliberate and grossly
+negligent acts) or agreed to in writing, shall any Contributor be
+liable to You for damages, including any direct, indirect, special,
+incidental, or consequential damages of any character arising as a
+result of this License or out of the use or inability to use the
+Work (including but not limited to damages for loss of goodwill,
+work stoppage, computer failure or malfunction, or any and all
+other commercial damages or losses), even if such Contributor
+has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+the Work or Derivative Works thereof, You may choose to offer,
+and charge a fee for, acceptance of support, warranty, indemnity,
+or other liability obligations and/or rights consistent with this
+License. However, in accepting such obligations, You may act only
+on Your own behalf and on Your sole responsibility, not on behalf
+of any other Contributor, and only if You agree to indemnify,
+defend, and hold each Contributor harmless for any liability
+incurred by, or claims asserted against, such Contributor by reason
+of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+Copyright (c) 2026 alk.dev
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

README.md

@@ -0,0 +1,209 @@
+# @alkdev/pubsub
+
+Type-safe publish/subscribe with pluggable event target adapters. Transport layer only — no call protocol or coordination semantics.
+
+Every event is an `EventEnvelope<TType, TPayload>` with `{ type, id, payload }`. Adapters implement the `TypedEventTarget` interface so you can swap transports without changing your subscribe logic.
+
+## Install
+
+```bash
+npm install @alkdev/pubsub
+```
+
+For Redis transport:
+
+```bash
+npm install ioredis
+```
+
+WebSocket and Worker adapters use built-in APIs — no additional dependencies.
+
+## Quick Start
+
+### In-Process (default)
+
+```ts
+import { createPubSub } from "@alkdev/pubsub";
+
+type EventMap = {
+  "user.created": { name: string };
+  "order.placed": { orderId: string };
+};
+
+const pubsub = createPubSub<EventMap>();
+
+pubsub.subscribe("user.created", (_, payload) => {
+  console.log(`New user: ${payload.name}`);
+});
+
+pubsub.publish("user.created", "id-1", { name: "Alice" });
+```
+
+### Redis
+
+```ts
+import { createPubSub } from "@alkdev/pubsub";
+import { createRedisEventTarget } from "@alkdev/pubsub/event-target-redis";
+import Redis from "ioredis";
+
+const publishClient = new Redis();
+const subscribeClient = new Redis();
+
+const eventTarget = createRedisEventTarget({
+  publishClient,
+  subscribeClient,
+});
+
+const pubsub = createPubSub({ eventTarget });
+```
+
+### WebSocket Client (browser/Node)
+
+```ts
+import { createPubSub } from "@alkdev/pubsub";
+import { createWebSocketClientEventTarget } from "@alkdev/pubsub/event-target-websocket-client";
+
+const ws = new WebSocket("ws://localhost:8080");
+const eventTarget = createWebSocketClientEventTarget(ws);
+
+const pubsub = createPubSub({ eventTarget });
+```
+
+### WebSocket Server (Node)
+
+```ts
+import { createWebSocketServerEventTarget } from "@alkdev/pubsub/event-target-websocket-server";
+
+const server = createWebSocketServerEventTarget({
+  onConnection(spoke, ws) { /* new client connected */ },
+  onDisconnection(spoke, ws) { /* client disconnected */ },
+  maxBufferedAmount: 1_048_576,
+  onBackpressure(ws, bufferedAmount) { /* optional backpressure signal */ },
+});
+
+// When a new WebSocket connects:
+server.addConnection(ws);
+
+// When it disconnects:
+server.removeConnection(ws);
+
+// Subscribe local handlers:
+server.addEventListener("user.created:id-1", (event) => {
+  // event.detail is the EventEnvelope
+});
+
+// Publish to subscribed connections:
+server.dispatchEvent(new CustomEvent("user.created:id-1", { detail: envelope }));
+```
+
+### Worker (Host ↔ Thread)
+
+```ts
+// Host (main thread)
+import { createWorkerHostEventTarget } from "@alkdev/pubsub/event-target-worker";
+
+const worker = new Worker("./worker.js");
+const eventTarget = createWorkerHostEventTarget(worker);
+```
+
+```ts
+// Worker thread
+import { createWorkerThreadEventTarget } from "@alkdev/pubsub/event-target-worker";
+
+const eventTarget = createWorkerThreadEventTarget();
+// Must be called inside a Worker context — throws if globalThis.postMessage is unavailable
+```
+
+## Lifecycle
+
+All transport adapters provide a `close()` method for graceful teardown:
+
+```ts
+const eventTarget = createRedisEventTarget({ publishClient, subscribeClient });
+// ... subscribe and publish ...
+
+eventTarget.close(); // unsubscribes all channels, removes listener, clears state
+```
+
+After `close()`:
+- `addEventListener`, `removeEventListener`, and `dispatchEvent` are no-ops
+- Intercepted handlers (`onmessage`, `onclose`) are restored to their originals
+- Subscriptions are cleaned up (Redis channels unsubscribed, WebSocket `__unsubscribe` sent)
+- The underlying transport (Redis connection, WebSocket, Worker) is **not** destroyed — the caller owns it
+
+`close()` is idempotent. Calling it multiple times is safe.
+
+## Operators
+
+Operators transform `AsyncIterable` streams from `subscribe()`:
+
+```ts
+import { pipe, filter, map, take, batch } from "@alkdev/pubsub";
+
+const pubsub = createPubSub<EventMap>();
+
+const stream = pubsub.subscribe("user.created");
+
+for await (const event of pipe(
+  stream,
+  filter((e) => e.payload.name.startsWith("A")),
+  map((e) => e.payload.name),
+  take(5),
+)) {
+  console.log(event);
+}
+```
+
+Available operators: `filter`, `map`, `pipe`, `take`, `reduce`, `toArray`, `batch`, `dedupe`, `window`, `flat`, `groupBy`, `chain`, `join`.
+
+## EventEnvelope
+
+All events are serialized as `EventEnvelope`:
+
+```ts
+interface EventEnvelope<TType = string, TPayload = unknown> {
+  type: TType;
+  id: string;
+  payload: TPayload;
+}
+```
+
+This is the cross-platform wire format. Adapters serialize/deserialize this automatically (JSON for Redis and WebSocket, structured clone for Worker).
+
+## Subscription Control Protocol
+
+Event types starting with `__` are reserved for internal use. Adapters use `__subscribe` and `__unsubscribe` control events to manage topic subscriptions across connections. User code must not define event types with the `__` prefix.
+
+## TypeScript
+
+Full type inference through `EventMap`:
+
+```ts
+type EventMap = {
+  "user.created": { name: string; role: string };
+  "order.placed": { orderId: string; total: number };
+};
+
+const pubsub = createPubSub<EventMap>();
+
+pubsub.publish("user.created", "id-1", { name: "Alice", role: "admin" });
+//                                               ^ full type checking on payload
+```
+
+## Exports
+
+| Import | Description |
+|--------|-------------|
+| `@alkdev/pubsub` | Core: `createPubSub`, `EventEnvelope`, `Repeater`, operators |
+| `@alkdev/pubsub/event-target-redis` | Redis adapter (peer dep: `ioredis`) |
+| `@alkdev/pubsub/event-target-websocket-client` | WebSocket client adapter |
+| `@alkdev/pubsub/event-target-websocket-server` | WebSocket server adapter |
+| `@alkdev/pubsub/event-target-worker` | Worker host + thread adapters |
+
+## Upstream Attribution
+
+Core `createPubSub`, `TypedEventTarget`, and operators are adapted from [graphql-yoga](https://github.com/graphql-hive/graphql-yoga) (MIT). The `Repeater` class is inlined from [@repeaterjs/repeater](https://github.com/repeaterjs/repeater) (MIT).
+
+## License
+
+Dual-licensed under [MIT](LICENSE-MIT) or [Apache-2.0](LICENSE-APACHE). Portions adapted from upstream projects retain their MIT attribution.

docs/architecture/api-surface.md

@@ -90,7 +90,7 @@ The `Repeater` automatically cleans up its `addEventListener` when the consumer
 |--------|--------|-------------|
 | `EventEnvelope<TType, TPayload>` | `types.ts` | Cross-platform envelope: `{ type, id, payload }`. JSON-serializable. |
 | `TypedEvent<TType, TDetail>` | `types.ts` | Event with typed `type` and `detail`. Omits `CustomEvent`'s untyped fields. |
-| `TypedEventTarget<TEvent>` | `types.ts` | Extends `EventTarget` with typed `addEventListener`, `dispatchEvent`, `removeEventListener`. |
+| `TypedEventTarget<TEvent>` | `types.ts` | Extends `EventTarget` with typed `addEventListener`, `dispatchEvent`, `removeEventListener`. All adapters' `dispatchEvent` returns `true` (events are non-cancelable). |
 | `TypedEventListener<TEvent>` | `types.ts` | `(evt: TEvent) => void` |
 | `TypedEventListenerObject<TEvent>` | `types.ts` | `{ handleEvent(object: TEvent): void }` |
 | `TypedEventListenerOrEventListenerObject<TEvent>` | `types.ts` | Union of the above |
@@ -99,6 +99,27 @@ The `Repeater` automatically cleans up its `addEventListener` when the consumer
 | `PubSubEvent<TEventMap, TType>` | `create_pubsub.ts` | Derived `TypedEvent` for a specific event type, with `detail` as `EventEnvelope<TType, TPayload>` |
 | `PubSubEventTarget<TEventMap>` | `create_pubsub.ts` | `TypedEventTarget<PubSubEvent<...>>` |
 
+## Adapter Lifecycle
+
+All transport adapters provide a `close()` method for graceful teardown. After `close()`:
+
+- The adapter is unusable (no-op for `addEventListener`, `removeEventListener`, `dispatchEvent`)
+- All subscriptions are cleaned up (Redis channels unsubscribed, `__unsubscribe` sent for WebSocket topics, callbacks cleared)
+- Intercepted handlers are restored to their originals
+- The underlying transport (Redis connection, WebSocket, Worker) is **not** destroyed — the caller owns it
+
+`close()` is idempotent. Calling it multiple times is safe.
+
+Adapter return types reflect this:
+
+| Adapter | Return type |
+|---------|-------------|
+| Redis | `RedisEventTarget<TEvent>` (extends `TypedEventTarget<TEvent>`, adds `close()`) |
+| WebSocket Client | `WebSocketClientEventTarget<TEvent>` (extends `TypedEventTarget<TEvent>`, adds `close()`) |
+| WebSocket Server | `WebSocketServerEventTarget<TEvent>` (extends `TypedEventTarget<TEvent>`, adds `addConnection`, `removeConnection`, `close()`) |
+| Worker Host | `WorkerHostEventTarget<TEvent>` (extends `TypedEventTarget<TEvent>`, adds `close()`) |
+| Worker Thread | `WorkerThreadEventTarget<TEvent>` (extends `TypedEventTarget<TEvent>`, adds `close()`) |
+
 ## Operators
 
 All operators work with any `AsyncIterable`. Operators that return `Repeater` provide backpressure-aware push semantics.

docs/architecture/build-distribution.md

@@ -31,19 +31,22 @@ No logger dependency. No TypeBox dependency (call protocol and schemas moved to
                               #   batch, dedupe, window, flat, groupBy, chain, join
     repeater.ts              # Inlined from @repeaterjs/repeater (MIT)
     event-target-redis.ts    # createRedisEventTarget (peer dep: ioredis)
-    # Future adapters (each is its own entry point + peer dep island):
-    # event-target-websocket.ts  # (peer dep: none, web standard)
-    # event-target-worker.ts     # (peer dep: none, web standard)
+    event-target-websocket-client.ts  # createWebSocketClientEventTarget
+    event-target-websocket-server.ts  # createWebSocketServerEventTarget, WebSocketLike, SpokeEventTarget
+    event-target-worker.ts   # createWorkerHostEventTarget, createWorkerThreadEventTarget
+    # Future adapters:
     # event-target-iroh.ts       # (peer dep: @rayhanadev/iroh)
   test/
     create_pubsub.test.ts
     operators.test.ts
     event-target-redis.test.ts
-    # event-target-websocket.test.ts
-    # event-target-worker.test.ts
-    # event-target-iroh.test.ts
+    event-target-websocket-client.test.ts
+    event-target-websocket-server.test.ts
+    event-target-worker.test.ts
+    integration-pubsub-redis.test.ts
+    integration-websocket.test.ts
   docs/
-    architecture.md
+    architecture/
     architecture/
     research/
   package.json
@@ -61,7 +64,8 @@ We use explicit sub-path exports rather than barrel-only + tree-shaking. Each ad
   "exports": {
     ".": { ... },
     "./event-target-redis": { ... },
-    "./event-target-websocket": { ... },
+    "./event-target-websocket-client": { ... },
+    "./event-target-websocket-server": { ... },
     "./event-target-worker": { ... },
     "./event-target-iroh": { ... }
   }

docs/architecture/event-targets.md

@@ -16,6 +16,7 @@ Every adapter must implement:
 | `addEventListener(type, callback)` | Register listener for event type. Callback receives `CustomEvent` with typed `detail` (an `EventEnvelope`). |
 | `dispatchEvent(event)` | Send/dispatch event. Returns `boolean` (always `true` for non-cancelable events). |
 | `removeEventListener(type, callback)` | Unregister listener. Clean up underlying subscription when no listeners remain for a topic. |
+| `close()` | Teardown: clean up all subscriptions, restore any intercepted handlers, remove message listeners. Adapter is unusable after `close()`. Idempotent. Does **not** destroy the underlying transport (which the caller owns). |
 
 ## Topology Model
 
@@ -56,14 +57,35 @@ See [ADR-003](decisions/003-subscription-control-protocol.md).
 
 This is analogous to Redis's `SUBSCRIBE`/`UNSUBSCRIBE` commands — control messages share the same wire format and connection as data.
 
+## Lifecycle
+
+All adapters that acquire resources (handler interception, message listeners, subscriptions) provide a `close()` method for graceful teardown. `close()` is idempotent — calling it more than once is a no-op.
+
+`close()` does **not** destroy the underlying transport (Redis connection, WebSocket, Worker). The caller owns the transport and decides when to disconnect it. `close()` only cleans up the adapter's own state:
+
+- Removes message listeners from the transport
+- Restores any original `onmessage`/`onclose` handlers that were intercepted
+- Unsubscribes from all Redis channels / sends `__unsubscribe` for all active topics
+- Clears internal maps (subscription tracking, callbacks)
+
+After `close()`, the adapter is unusable: `addEventListener`, `removeEventListener`, and `dispatchEvent` become no-ops. This is intentional — the caller should create a new adapter if they need to reconnect.
+
+| Adapter | What `close()` does |
+|---------|---------------------|
+| Redis | Unsubscribes all channels, removes `message` listener, clears callback map |
+| WebSocket Client | Sends `__unsubscribe` for all active topics, restores original `onmessage`, clears callback map |
+| WebSocket Server | Removes all connections (restoring their original handlers, firing `onDisconnection`), clears local listener map |
+| Worker Host | Restores original `worker.onmessage`, clears callback map |
+| Worker Thread | Restores original `globalThis.onmessage`, clears callback map |
+
 ## Adapter Docs
 
 | Adapter | Import | Status |
 |---------|--------|--------|
-| [In-Process](in-process.md) | (default, no import) | Implemented (built-in `EventTarget`) |
-| [Redis](redis.md) | `@alkdev/pubsub/event-target-redis` | Implemented. Needs tests. |
-| [WebSocket Client](websocket-client.md) | `@alkdev/pubsub/event-target-websocket-client` | Not yet implemented |
-| [WebSocket Server](websocket-server.md) | `@alkdev/pubsub/event-target-websocket-server` | Not yet implemented |
-| [Worker](worker.md) | `@alkdev/pubsub/event-target-worker` | Not yet implemented (R&D on Node vs Web Worker) |
-| [Iroh Spoke](iroh-spoke.md) | `@alkdev/pubsub/event-target-iroh-spoke` | Deferred (pending fork of iroh-ts) |
-| [Iroh Hub](iroh-hub.md) | `@alkdev/pubsub/event-target-iroh-hub` | Deferred (pending fork of iroh-ts) |
+| [In-Process](event-targets/in-process.md) | (default, no import) | Implemented (built-in `EventTarget`) |
+| [Redis](event-targets/redis.md) | `@alkdev/pubsub/event-target-redis` | Implemented |
+| [WebSocket Client](event-targets/websocket-client.md) | `@alkdev/pubsub/event-target-websocket-client` | Implemented |
+| [WebSocket Server](event-targets/websocket-server.md) | `@alkdev/pubsub/event-target-websocket-server` | Implemented |
+| [Worker](event-targets/worker.md) | `@alkdev/pubsub/event-target-worker` | Implemented |
+| [Iroh Spoke](iroh-transport.md) | `@alkdev/pubsub/event-target-iroh-spoke` | Deferred (pending fork of iroh-ts) |
+| [Iroh Hub](iroh-transport.md) | `@alkdev/pubsub/event-target-iroh-hub` | Deferred (pending fork of iroh-ts) |

package.json

@@ -1,11 +1,20 @@
 {
   "name": "@alkdev/pubsub",
   "version": "0.1.0",
-  "description": "Type-safe publish/subscribe with pluggable event target adapters (in-process, Redis, WebSocket, Iroh)",
+  "description": "Type-safe publish/subscribe with pluggable event target adapters (in-process, Redis, WebSocket, Worker)",
   "type": "module",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
+  "author": "alk.dev",
+  "repository": {
+    "type": "git",
+    "url": "git+https://git.alk.dev/alkdev/pubsub.git"
+  },
+  "homepage": "https://git.alk.dev/alkdev/pubsub",
+  "bugs": {
+    "url": "https://git.alk.dev/alkdev/pubsub/issues"
+  },
   "exports": {
     ".": {
       "import": {
@@ -26,13 +35,45 @@
         "types": "./dist/event-target-redis.d.cts",
         "default": "./dist/event-target-redis.cjs"
       }
+    },
+    "./event-target-websocket-client": {
+      "import": {
+        "types": "./dist/event-target-websocket-client.d.ts",
+        "default": "./dist/event-target-websocket-client.js"
+      },
+      "require": {
+        "types": "./dist/event-target-websocket-client.d.cts",
+        "default": "./dist/event-target-websocket-client.cjs"
+      }
+    },
+    "./event-target-websocket-server": {
+      "import": {
+        "types": "./dist/event-target-websocket-server.d.ts",
+        "default": "./dist/event-target-websocket-server.js"
+      },
+      "require": {
+        "types": "./dist/event-target-websocket-server.d.cts",
+        "default": "./dist/event-target-websocket-server.cjs"
+      }
+    },
+    "./event-target-worker": {
+      "import": {
+        "types": "./dist/event-target-worker.d.ts",
+        "default": "./dist/event-target-worker.js"
+      },
+      "require": {
+        "types": "./dist/event-target-worker.d.cts",
+        "default": "./dist/event-target-worker.cjs"
+      }
     }
   },
   "publishConfig": {
     "access": "public"
   },
+  "sideEffects": false,
   "files": [
-    "dist"
+    "dist",
+    "CHANGELOG.md"
   ],
   "scripts": {
     "build": "tsup",

src/event-target-redis.ts

@@ -41,14 +41,20 @@ export type CreateRedisEventTargetArgs = {
     stringify: (message: unknown) => string;
     parse: (message: string) => unknown;
   };
+  prefix?: string;
 };
 
+export interface RedisEventTarget<TEvent extends TypedEvent> extends TypedEventTarget<TEvent> {
+  close(): void;
+}
+
 export function createRedisEventTarget<TEvent extends TypedEvent>(
   args: CreateRedisEventTargetArgs,
-): TypedEventTarget<TEvent> {
+): RedisEventTarget<TEvent> {
   const { publishClient, subscribeClient } = args;
 
   const serializer = args.serializer ?? JSON;
+  const prefix = args.prefix ?? "";
 
   const callbacksForTopic = new Map<string, Set<EventListener>>();
 
@@ -58,7 +64,15 @@ export function createRedisEventTarget<TEvent extends TypedEvent>(
       return;
     }
 
-    const envelope = serializer.parse(message) as EventEnvelope;
+    let envelope: EventEnvelope;
+    try {
+      envelope = serializer.parse(message) as EventEnvelope;
+    } catch {
+      console.warn(
+        `Failed to parse message on channel "${channel}": ${message}`,
+      );
+      return;
+    }
     const event = new CustomEvent(channel, {
       detail: envelope,
     }) as TEvent;
@@ -70,18 +84,20 @@ export function createRedisEventTarget<TEvent extends TypedEvent>(
   (subscribeClient as Redis).on("message", onMessage);
 
   function addCallback(topic: string, callback: EventListener) {
-    let callbacks = callbacksForTopic.get(topic);
+    const prefixedTopic = prefix + topic;
+    let callbacks = callbacksForTopic.get(prefixedTopic);
     if (callbacks === undefined) {
       callbacks = new Set();
-      callbacksForTopic.set(topic, callbacks);
+      callbacksForTopic.set(prefixedTopic, callbacks);
 
-      subscribeClient.subscribe(topic);
+      subscribeClient.subscribe(prefixedTopic);
     }
     callbacks.add(callback);
   }
 
   function removeCallback(topic: string, callback: EventListener) {
-    const callbacks = callbacksForTopic.get(topic);
+    const prefixedTopic = prefix + topic;
+    const callbacks = callbacksForTopic.get(prefixedTopic);
     if (callbacks === undefined) {
       return;
     }
@@ -89,8 +105,8 @@ export function createRedisEventTarget<TEvent extends TypedEvent>(
     if (callbacks.size > 0) {
       return;
     }
-    callbacksForTopic.delete(topic);
-    subscribeClient.unsubscribe(topic);
+    callbacksForTopic.delete(prefixedTopic);
+    subscribeClient.unsubscribe(prefixedTopic);
   }
 
   return {
@@ -103,7 +119,7 @@ export function createRedisEventTarget<TEvent extends TypedEvent>(
     },
     dispatchEvent(event: TEvent) {
       publishClient.publish(
-        event.type,
+        prefix + event.type,
         serializer.stringify(event.detail),
       );
       return true;
@@ -115,5 +131,13 @@ export function createRedisEventTarget<TEvent extends TypedEvent>(
         removeCallback(topic, callback);
       }
     },
+    close() {
+      const topics = [...callbacksForTopic.keys()];
+      callbacksForTopic.clear();
+      for (const topic of topics) {
+        subscribeClient.unsubscribe(topic);
+      }
+      (subscribeClient as Redis).off("message", onMessage);
+    },
   };
 }

src/event-target-websocket-client.ts

@@ -0,0 +1,133 @@
+/*
+ * @alkdev/pubsub — WebSocket Client Event Target
+ * Copyright (c) 2026 alk.dev
+ * SPDX-License-Identifier: MIT OR Apache-2.0
+ */
+
+import type { TypedEventTarget, TypedEvent, EventEnvelope } from "./types.js";
+
+export interface WebSocketClientEventTarget<TEvent extends TypedEvent> extends TypedEventTarget<TEvent> {
+  close(): void;
+}
+
+export function createWebSocketClientEventTarget<TEvent extends TypedEvent>(
+  ws: WebSocket,
+): WebSocketClientEventTarget<TEvent> {
+  const callbacksForTopic = new Map<string, Set<EventListener>>();
+
+  const originalOnmessage = ws.onmessage;
+  let closed = false;
+
+  ws.onmessage = (event: MessageEvent) => {
+    let envelope: EventEnvelope;
+    try {
+      envelope = JSON.parse(event.data as string) as EventEnvelope;
+    } catch {
+      console.warn(
+        `Failed to parse WebSocket message: ${event.data}`,
+      );
+      return;
+    }
+
+    if (typeof envelope.type !== "string" || envelope.type.startsWith("__")) {
+      return;
+    }
+
+    const topic = `${envelope.type}:${envelope.id}`;
+    const callbacks = callbacksForTopic.get(topic);
+    if (callbacks === undefined) {
+      return;
+    }
+
+    const customEvent = new CustomEvent(topic, {
+      detail: envelope,
+    }) as TEvent;
+
+    for (const callback of callbacks) {
+      callback(customEvent);
+    }
+  };
+
+  function addCallback(topic: string, callback: EventListener) {
+    if (closed) return;
+    let callbacks = callbacksForTopic.get(topic);
+    const isFirst = callbacks === undefined;
+    if (isFirst) {
+      callbacks = new Set();
+      callbacksForTopic.set(topic, callbacks);
+    }
+    callbacks!.add(callback);
+
+    if (isFirst) {
+      ws.send(
+        JSON.stringify({
+          type: "__subscribe",
+          id: "",
+          payload: { topic },
+        }),
+      );
+    }
+  }
+
+  function removeCallback(topic: string, callback: EventListener) {
+    if (closed) return;
+    const callbacks = callbacksForTopic.get(topic);
+    if (callbacks === undefined) {
+      return;
+    }
+    const existed = callbacks.delete(callback);
+    if (!existed) {
+      return;
+    }
+    if (callbacks.size > 0) {
+      return;
+    }
+    callbacksForTopic.delete(topic);
+    ws.send(
+      JSON.stringify({
+        type: "__unsubscribe",
+        id: "",
+        payload: { topic },
+      }),
+    );
+  }
+
+  return {
+    addEventListener(topic, callbackOrOptions: EventListenerOrEventListenerObject) {
+      if (callbackOrOptions != null) {
+        const callback =
+          "handleEvent" in callbackOrOptions ? callbackOrOptions.handleEvent : callbackOrOptions;
+        addCallback(topic, callback);
+      }
+    },
+    dispatchEvent(event: TEvent) {
+      if (closed) return true;
+      ws.send(JSON.stringify(event.detail));
+      return true;
+    },
+    removeEventListener(topic, callbackOrOptions: EventListenerOrEventListenerObject) {
+      if (callbackOrOptions != null) {
+        const callback =
+          "handleEvent" in callbackOrOptions ? callbackOrOptions.handleEvent : callbackOrOptions;
+        removeCallback(topic, callback);
+      }
+    },
+    close() {
+      if (closed) return;
+      closed = true;
+      for (const [topic, callbacks] of callbacksForTopic) {
+        if (callbacks.size > 0) {
+          ws.send(
+            JSON.stringify({
+              type: "__unsubscribe",
+              id: "",
+              payload: { topic },
+            }),
+          );
+        }
+      }
+      callbacksForTopic.clear();
+      ws.onmessage = originalOnmessage;
+    },
+  };
+}

src/event-target-websocket-server.ts

@@ -0,0 +1,296 @@
+/*
+ * @alkdev/pubsub — WebSocket Server Event Target
+ * Copyright (c) 2026 alk.dev
+ * SPDX-License-Identifier: MIT OR Apache-2.0
+ */
+
+import type { TypedEventTarget, TypedEvent, EventEnvelope } from "./types.js";
+
+export interface WebSocketLike {
+  send(data: string): void;
+  close(code?: number, reason?: string): void;
+  bufferedAmount: number;
+  onmessage: ((ev: { data: string }) => void) | null;
+  onclose: ((ev: { code: number; reason?: string }) => void) | null;
+}
+
+export interface SpokeEventTarget<TEvent extends TypedEvent> extends TypedEventTarget<TEvent> {
+  readonly ws: WebSocketLike;
+}
+
+export interface CreateWebSocketServerEventTargetArgs<TEvent extends TypedEvent> {
+  onConnection?: (spoke: SpokeEventTarget<TEvent>, ws: WebSocketLike) => void;
+  onDisconnection?: (spoke: SpokeEventTarget<TEvent>, ws: WebSocketLike) => void;
+  maxBufferedAmount?: number;
+  onBackpressure?: (ws: WebSocketLike, bufferedAmount: number) => void;
+}
+
+export interface WebSocketServerEventTarget<TEvent extends TypedEvent> extends TypedEventTarget<TEvent> {
+  addConnection(ws: WebSocketLike): void;
+  removeConnection(ws: WebSocketLike): void;
+  close(): void;
+}
+
+export function createWebSocketServerEventTarget<TEvent extends TypedEvent>(
+  args?: CreateWebSocketServerEventTargetArgs<TEvent>,
+): WebSocketServerEventTarget<TEvent> {
+  const maxBufferedAmount = args?.maxBufferedAmount ?? 1_048_576;
+  const onConnection = args?.onConnection;
+  const onDisconnection = args?.onDisconnection;
+  const onBackpressure = args?.onBackpressure;
+
+  const subscriptions = new Map<string, Set<WebSocketLike>>();
+  const connectionSubscriptions = new Map<WebSocketLike, Set<string>>();
+
+  const connectionListeners = new Map<WebSocketLike, Map<string, Set<EventListener>>>();
+
+  const localListeners = new Map<string, Set<EventListener>>();
+
+  const spokeTargets = new Map<WebSocketLike, SpokeEventTarget<TEvent>>();
+
+  const originalOnmessage = new Map<WebSocketLike, ((ev: { data: string }) => void) | null>();
+  const originalOnclose = new Map<WebSocketLike, ((ev: { code: number; reason?: string }) => void) | null>();
+
+  function createSpokeTarget(ws: WebSocketLike): SpokeEventTarget<TEvent> {
+    const listeners = new Map<string, Set<EventListener>>();
+    connectionListeners.set(ws, listeners);
+
+    const target: SpokeEventTarget<TEvent> = {
+      get ws() {
+        return ws;
+      },
+      addEventListener(type, callbackOrOptions: EventListenerOrEventListenerObject) {
+        if (callbackOrOptions == null) return;
+        const callback =
+          "handleEvent" in callbackOrOptions ? callbackOrOptions.handleEvent : callbackOrOptions;
+        let set = listeners.get(type);
+        if (set === undefined) {
+          set = new Set();
+          listeners.set(type, set);
+        }
+        set.add(callback as EventListener);
+      },
+      removeEventListener(type, callbackOrOptions: EventListenerOrEventListenerObject) {
+        if (callbackOrOptions == null) return;
+        const callback =
+          "handleEvent" in callbackOrOptions ? callbackOrOptions.handleEvent : callbackOrOptions;
+        const set = listeners.get(type);
+        if (set === undefined) return;
+        set.delete(callback as EventListener);
+        if (set.size === 0) {
+          listeners.delete(type);
+        }
+      },
+      dispatchEvent(event: TEvent): boolean {
+        const message = JSON.stringify(event.detail);
+        try {
+          if (ws.bufferedAmount > maxBufferedAmount) {
+            onBackpressure?.(ws, ws.bufferedAmount);
+            ws.close(1013, "Try Again Later");
+            removeConnection(ws);
+            return true;
+          }
+          ws.send(message);
+        } catch {
+          removeConnection(ws);
+        }
+        return true;
+      },
+    };
+
+    spokeTargets.set(ws, target);
+    return target;
+  }
+
+  function removeConnection(ws: WebSocketLike) {
+    if (!spokeTargets.has(ws)) return;
+    const topics = connectionSubscriptions.get(ws);
+    if (topics !== undefined) {
+      for (const topic of topics) {
+        const subscribers = subscriptions.get(topic);
+        if (subscribers !== undefined) {
+          subscribers.delete(ws);
+          if (subscribers.size === 0) {
+            subscriptions.delete(topic);
+          }
+        }
+      }
+      connectionSubscriptions.delete(ws);
+    }
+
+    connectionListeners.delete(ws);
+
+    const spoke = spokeTargets.get(ws);
+    spokeTargets.delete(ws);
+
+    const prevOnmessage = originalOnmessage.get(ws) ?? null;
+    const prevOnclose = originalOnclose.get(ws) ?? null;
+    ws.onmessage = prevOnmessage;
+    ws.onclose = prevOnclose;
+    originalOnmessage.delete(ws);
+    originalOnclose.delete(ws);
+
+    if (spoke !== undefined) {
+      onDisconnection?.(spoke, ws);
+    }
+  }
+
+  function addConnection(ws: WebSocketLike) {
+    if (spokeTargets.has(ws)) return;
+
+    originalOnmessage.set(ws, ws.onmessage);
+    originalOnclose.set(ws, ws.onclose);
+
+    const spoke = createSpokeTarget(ws);
+
+    connectionSubscriptions.set(ws, new Set());
+
+    const prevOnclose = originalOnclose.get(ws)!;
+
+    ws.onmessage = (ev: { data: string }) => {
+      let envelope: EventEnvelope;
+      try {
+        envelope = JSON.parse(ev.data) as EventEnvelope;
+      } catch {
+        console.warn(`Failed to parse WebSocket message: ${ev.data}`);
+        return;
+      }
+
+      if (typeof envelope.type !== "string") return;
+
+      if (envelope.type === "__subscribe") {
+        const topic = (envelope.payload as Record<string, unknown>)?.topic;
+        if (typeof topic === "string" && topic.length > 0) {
+          let subscribers = subscriptions.get(topic);
+          if (subscribers === undefined) {
+            subscribers = new Set();
+            subscriptions.set(topic, subscribers);
+          }
+          subscribers.add(ws);
+          const topics = connectionSubscriptions.get(ws);
+          if (topics !== undefined) {
+            topics.add(topic);
+          }
+        }
+        return;
+      }
+
+      if (envelope.type === "__unsubscribe") {
+        const topic = (envelope.payload as Record<string, unknown>)?.topic;
+        if (typeof topic === "string" && topic.length > 0) {
+          const subscribers = subscriptions.get(topic);
+          if (subscribers !== undefined) {
+            subscribers.delete(ws);
+            if (subscribers.size === 0) {
+              subscriptions.delete(topic);
+            }
+          }
+          const topics = connectionSubscriptions.get(ws);
+          if (topics !== undefined) {
+            topics.delete(topic);
+          }
+        }
+        return;
+      }
+
+      const topic = `${envelope.type}:${envelope.id}`;
+      const customEvent = new CustomEvent(topic, { detail: envelope }) as TEvent;
+
+      const spokeListeners = connectionListeners.get(ws);
+      if (spokeListeners !== undefined) {
+        const cbs = spokeListeners.get(topic);
+        if (cbs !== undefined) {
+          for (const cb of cbs) {
+            cb(customEvent);
+          }
+        }
+      }
+
+      const localCbs = localListeners.get(topic);
+      if (localCbs !== undefined) {
+        for (const cb of localCbs) {
+          cb(customEvent);
+        }
+      }
+    };
+
+    ws.onclose = (ev: { code: number; reason?: string }) => {
+      removeConnection(ws);
+      if (prevOnclose !== null) {
+        prevOnclose(ev);
+      }
+    };
+
+    onConnection?.(spoke, ws);
+  }
+
+  function sendToConnection(ws: WebSocketLike, message: string) {
+    try {
+      if (ws.bufferedAmount > maxBufferedAmount) {
+        onBackpressure?.(ws, ws.bufferedAmount);
+        ws.close(1013, "Try Again Later");
+        removeConnection(ws);
+        return;
+      }
+      ws.send(message);
+    } catch {
+      removeConnection(ws);
+    }
+  }
+
+  const serverTarget: WebSocketServerEventTarget<TEvent> = {
+    addConnection(ws: WebSocketLike) {
+      addConnection(ws);
+    },
+    removeConnection(ws: WebSocketLike) {
+      removeConnection(ws);
+    },
+    addEventListener(type, callbackOrOptions: EventListenerOrEventListenerObject) {
+      if (callbackOrOptions == null) return;
+      const callback =
+        "handleEvent" in callbackOrOptions ? callbackOrOptions.handleEvent : callbackOrOptions;
+      let set = localListeners.get(type);
+      if (set === undefined) {
+        set = new Set();
+        localListeners.set(type, set);
+      }
+      set.add(callback as EventListener);
+    },
+    removeEventListener(type, callbackOrOptions: EventListenerOrEventListenerObject) {
+      if (callbackOrOptions == null) return;
+      const callback =
+        "handleEvent" in callbackOrOptions ? callbackOrOptions.handleEvent : callbackOrOptions;
+      const set = localListeners.get(type);
+      if (set === undefined) return;
+      set.delete(callback as EventListener);
+      if (set.size === 0) {
+        localListeners.delete(type);
+      }
+    },
+    dispatchEvent(event: TEvent): boolean {
+      const message = JSON.stringify(event.detail);
+      const subscribers = subscriptions.get(event.type);
+      if (subscribers !== undefined) {
+        for (const ws of subscribers) {
+          sendToConnection(ws, message);
+        }
+      }
+
+      const localCbs = localListeners.get(event.type);
+      if (localCbs !== undefined) {
+        for (const cb of localCbs) {
+          cb(event);
+        }
+      }
+      return true;
+    },
+    close() {
+      for (const ws of [...spokeTargets.keys()]) {
+        removeConnection(ws);
+      }
+      localListeners.clear();
+    },
+  };
+
+  return serverTarget;
+}

src/event-target-worker.ts

@@ -0,0 +1,172 @@
+/*
+ * @alkdev/pubsub — Worker Event Target
+ * Copyright (c) 2026 alk.dev
+ * SPDX-License-Identifier: MIT OR Apache-2.0
+ */
+
+import type { TypedEventTarget, TypedEvent, EventEnvelope } from "./types.js";
+
+export interface WorkerHostEventTarget<TEvent extends TypedEvent> extends TypedEventTarget<TEvent> {
+  close(): void;
+}
+
+export interface WorkerThreadEventTarget<TEvent extends TypedEvent> extends TypedEventTarget<TEvent> {
+  close(): void;
+}
+
+export function createWorkerHostEventTarget<TEvent extends TypedEvent>(
+  worker: Worker,
+): WorkerHostEventTarget<TEvent> {
+  const callbacksForTopic = new Map<string, Set<EventListener>>();
+
+  const originalOnmessage = worker.onmessage;
+
+  worker.onmessage = (event: MessageEvent) => {
+    const envelope = event.data as EventEnvelope;
+    if (typeof envelope?.type !== "string" || envelope.type.startsWith("__")) {
+      return;
+    }
+
+    const topic = `${envelope.type}:${envelope.id}`;
+    const callbacks = callbacksForTopic.get(topic);
+    if (callbacks === undefined) {
+      return;
+    }
+
+    const customEvent = new CustomEvent(topic, {
+      detail: envelope,
+    }) as TEvent;
+
+    for (const callback of callbacks) {
+      callback(customEvent);
+    }
+  };
+
+  function addCallback(topic: string, callback: EventListener) {
+    let callbacks = callbacksForTopic.get(topic);
+    if (callbacks === undefined) {
+      callbacks = new Set();
+      callbacksForTopic.set(topic, callbacks);
+    }
+    callbacks.add(callback);
+  }
+
+  function removeCallback(topic: string, callback: EventListener) {
+    const callbacks = callbacksForTopic.get(topic);
+    if (callbacks === undefined) {
+      return;
+    }
+    callbacks.delete(callback);
+    if (callbacks.size === 0) {
+      callbacksForTopic.delete(topic);
+    }
+  }
+
+  return {
+    addEventListener(topic, callbackOrOptions: EventListenerOrEventListenerObject) {
+      if (callbackOrOptions != null) {
+        const callback =
+          "handleEvent" in callbackOrOptions ? callbackOrOptions.handleEvent : callbackOrOptions;
+        addCallback(topic, callback);
+      }
+    },
+    dispatchEvent(event: TEvent) {
+      worker.postMessage(event.detail);
+      return true;
+    },
+    removeEventListener(topic, callbackOrOptions: EventListenerOrEventListenerObject) {
+      if (callbackOrOptions != null) {
+        const callback =
+          "handleEvent" in callbackOrOptions ? callbackOrOptions.handleEvent : callbackOrOptions;
+        removeCallback(topic, callback);
+      }
+    },
+    close() {
+      callbacksForTopic.clear();
+      worker.onmessage = originalOnmessage;
+    },
+  };
+}
+
+export function createWorkerThreadEventTarget<TEvent extends TypedEvent>(): WorkerThreadEventTarget<TEvent> {
+  const callbacksForTopic = new Map<string, Set<EventListener>>();
+
+  const global = globalThis as unknown as {
+    onmessage: ((event: MessageEvent) => void) | null;
+    postMessage: (message: unknown) => void;
+  };
+
+  if (typeof global.postMessage !== "function") {
+    throw new Error(
+      "createWorkerThreadEventTarget must be called inside a Worker context where globalThis.postMessage is available",
+    );
+  }
+
+  const originalOnmessage = global.onmessage;
+
+  global.onmessage = (event: MessageEvent) => {
+    const envelope = event.data as EventEnvelope;
+    if (typeof envelope?.type !== "string" || envelope.type.startsWith("__")) {
+      return;
+    }
+
+    const topic = `${envelope.type}:${envelope.id}`;
+    const callbacks = callbacksForTopic.get(topic);
+    if (callbacks === undefined) {
+      return;
+    }
+
+    const customEvent = new CustomEvent(topic, {
+      detail: envelope,
+    }) as TEvent;
+
+    for (const callback of callbacks) {
+      callback(customEvent);
+    }
+  };
+
+  function addCallback(topic: string, callback: EventListener) {
+    let callbacks = callbacksForTopic.get(topic);
+    if (callbacks === undefined) {
+      callbacks = new Set();
+      callbacksForTopic.set(topic, callbacks);
+    }
+    callbacks.add(callback);
+  }
+
+  function removeCallback(topic: string, callback: EventListener) {
+    const callbacks = callbacksForTopic.get(topic);
+    if (callbacks === undefined) {
+      return;
+    }
+    callbacks.delete(callback);
+    if (callbacks.size === 0) {
+      callbacksForTopic.delete(topic);
+    }
+  }
+
+  return {
+    addEventListener(topic, callbackOrOptions: EventListenerOrEventListenerObject) {
+      if (callbackOrOptions != null) {
+        const callback =
+          "handleEvent" in callbackOrOptions ? callbackOrOptions.handleEvent : callbackOrOptions;
+        addCallback(topic, callback);
+      }
+    },
+    dispatchEvent(event: TEvent) {
+      global.postMessage(event.detail);
+      return true;
+    },
+    removeEventListener(topic, callbackOrOptions: EventListenerOrEventListenerObject) {
+      if (callbackOrOptions != null) {
+        const callback =
+          "handleEvent" in callbackOrOptions ? callbackOrOptions.handleEvent : callbackOrOptions;
+        removeCallback(topic, callback);
+      }
+    },
+    close() {
+      callbacksForTopic.clear();
+      global.onmessage = originalOnmessage;
+    },
+  };
+}

src/index.ts

@@ -1,5 +1,14 @@
+/*
+ * @alkdev/pubsub — Type-safe publish/subscribe with pluggable event target adapters
+ * Copyright (c) 2026 alk.dev
+ * SPDX-License-Identifier: MIT OR Apache-2.0
+ */
+
 export { createPubSub, type PubSub, type PubSubConfig, type PubSubEvent, type PubSubEventTarget, type PubSubEventMap } from "./create_pubsub.js";
 export { type EventEnvelope, type TypedEvent, type TypedEventTarget, type TypedEventListener, type TypedEventListenerObject, type TypedEventListenerOrEventListenerObject } from "./types.js";
 export { filter, map, pipe, take, reduce, toArray, batch, dedupe, window, flat, groupBy, chain, join } from "./operators.js";
 export { Repeater, RepeaterOverflowError, type Push, type Stop, type RepeaterExecutor, type RepeaterBuffer } from "./repeater.js";
-export { createRedisEventTarget, type CreateRedisEventTargetArgs } from "./event-target-redis.js";
+export { createRedisEventTarget, type CreateRedisEventTargetArgs, type RedisEventTarget } from "./event-target-redis.js";
+export { createWebSocketClientEventTarget, type WebSocketClientEventTarget } from "./event-target-websocket-client.js";
+export { createWebSocketServerEventTarget, type WebSocketLike, type SpokeEventTarget, type CreateWebSocketServerEventTargetArgs, type WebSocketServerEventTarget } from "./event-target-websocket-server.js";
+export { createWorkerHostEventTarget, createWorkerThreadEventTarget, type WorkerHostEventTarget, type WorkerThreadEventTarget } from "./event-target-worker.js";

tasks/001-core-pubsub-tests.md

@@ -1,7 +1,7 @@
 ---
 id: core-pubsub-tests
 name: Write tests for createPubSub, EventEnvelope, and in-process event target
-status: pending
+status: completed
 depends_on: []
 scope: moderate
 risk: low
@@ -43,8 +43,11 @@ The architecture specifies these behaviors:
 
 ## Notes
 
-> To be filled by implementation agent
+Used subscribe-based testing approach since `createPubSub` doesn't expose the internal `target`. Custom eventTarget tests use `vi.spyOn` on the provided target's `dispatchEvent` method.
 
 ## Summary
 
-> To be filled on completion
+Implemented comprehensive tests for createPubSub, EventEnvelope, and in-process event target.
+- Created: test/create_pubsub.test.ts
+- Tests: 11, all passing
+- Coverage: publish dispatches correct type:id topic, publish throws on __-prefixed types, subscribe yields EventEnvelope objects, envelope has correct type/id/payload, topic scoping (type:id matching), multiple subscribers receive events, subscriber cleanup on break, custom eventTarget dispatches to provided target, default in-process EventTarget works

tasks/002-core-operators-tests.md

@@ -1,7 +1,7 @@
 ---
 id: core-operators-tests
 name: Write tests for all stream operators
-status: pending
+status: completed
 depends_on: []
 scope: moderate
 risk: low
@@ -46,4 +46,7 @@ The operators are adapted from graphql-yoga (`filter`, `map`, `pipe`) and added
 
 ## Summary
 
-> To be filled on completion
+Implemented comprehensive tests for all 13 stream operators.
+- Created: `test/operators.test.ts` (53 tests)
+- Tests cover: filter (5 tests including type-narrowing & async), map (3 tests including async), pipe (6 tests including compose with subscribe), take (4), reduce (4), toArray (3), batch (5), dedupe (4), window (5), flat (3), groupBy (3), chain (4), join (4)
+- All 53 tests passing, build and lint pass

tasks/003-redis-adapter-tests.md

@@ -1,7 +1,7 @@
 ---
 id: redis-adapter-tests
 name: Write tests for Redis event target adapter
-status: pending
+status: completed
 depends_on: [core-pubsub-tests]
 scope: moderate
 risk: medium
@@ -26,15 +26,15 @@ Note: test 7 (error propagation) is partially blocked by the missing error handl
 
 ## Acceptance Criteria
 
-- [ ] `test/event-target-redis.test.ts` exists and passes
-- [ ] Test approach for Redis dependency is decided (mock, container, or ioredis-mock)
-- [ ] Test: dispatchEvent publishes correct channel and serialized envelope
-- [ ] Test: addEventListener subscribes to Redis and dispatches to local listeners
-- [ ] Test: removeEventListener unsubscribes from Redis when no listeners remain
-- [ ] Test: type:id topic scoping works correctly
-- [ ] Test: EventEnvelope round-trips through JSON serialization
-- [ ] Test: multiple listeners on same topic result in single Redis subscribe
-- [ ] Test: custom serializer option works
+- [x] `test/event-target-redis.test.ts` exists and passes
+- [x] Test approach for Redis dependency is decided (mock, container, or ioredis-mock)
+- [x] Test: dispatchEvent publishes correct channel and serialized envelope
+- [x] Test: addEventListener subscribes to Redis and dispatches to local listeners
+- [x] Test: removeEventListener unsubscribes from Redis when no listeners remain
+- [x] Test: type:id topic scoping works correctly
+- [x] Test: EventEnvelope round-trips through JSON serialization
+- [x] Test: multiple listeners on same topic result in single Redis subscribe
+- [x] Test: custom serializer option works
 
 ## References
 
@@ -43,8 +43,14 @@ Note: test 7 (error propagation) is partially blocked by the missing error handl
 
 ## Notes
 
-> To be filled by implementation agent
+Test approach: Manual Redis mock (no external dependencies). The `createMockRedis()` helper creates a lightweight mock that tracks `publish`/`subscribe`/`unsubscribe` calls and provides `simulateMessage()` to trigger the `message` event handler. This avoids needing `ioredis-mock` or a running Redis instance.
+
+Test 7 (error propagation) is not included because the current implementation lacks error handling — tracked in `redis-channel-prefix-and-error-handling` task.
 
 ## Summary
 
-> To be filled on completion
+Implemented comprehensive tests for the Redis event target adapter using a manual mock approach (no external dependencies needed).
+
+- Created: `test/event-target-redis.test.ts` (17 tests across 7 describe blocks)
+- Tests: 17, all passing
+- Coverage: dispatchEvent/publish path, addEventListener/subscribe path, removeEventListener/unsubscribe path, topic scoping, envelope round-trip serialization, multiple listeners (single Redis subscribe), custom serializer, EventListenerObject support

tasks/005-review-core-and-redis.md

@@ -1,7 +1,7 @@
 ---
 id: review-core-and-redis
 name: Review core module tests and Redis adapter
-status: pending
+status: completed
 depends_on: [core-pubsub-tests, core-operators-tests, redis-adapter-tests]
 scope: narrow
 risk: low
@@ -38,8 +38,123 @@ This is a quality gate before implementing new adapters. Mistakes in the core ty
 
 ## Notes
 
-> To be filled by implementation agent
+### Build / Lint / Test
+
+- **Build**: `npm run build` passes cleanly. ESM + CJS + declarations all produced.
+- **Lint**: `npm run lint` (tsc --noEmit) passes with no errors.
+- **Tests**: 99 tests pass across 4 files (core: 11, operators: 53, redis: 25, integration: 10).
+
+### Core Tests (`test/create_pubsub.test.ts` — 11 tests)
+
+Aligned with `api-surface.md`. Coverage:
+
+| Contract area | Covered? | Details |
+|---|---|---|
+| `publish(type, id, payload)` dispatches with `type:id` topic | Yes | "dispatches event with correct type:id topic" |
+| EventEnvelope `{ type, id, payload }` in CustomEvent detail | Yes | "dispatches EventEnvelope with type, id, and payload as CustomEvent detail" |
+| `__`-prefixed event types rejected | Yes | "throws on __-prefixed event types" with exact error message |
+| `subscribe(type, id)` returns async iterable | Yes | "returns async iterable that yields EventEnvelope objects" |
+| Topic scoping — only matching `type:id` received | Yes | "receives events only for the subscribed topic" |
+| Multiple subscribers on same topic | Yes | "multiple subscribers on the same topic all receive events" |
+| Cleanup — listener removed on break | Yes | "cleanup: breaking out of for await loop removes the listener" |
+| Custom eventTarget config | Yes | 3 tests: spy on dispatch, in-process default, subscribe via custom target |
+
+All acceptance criteria from `api-surface.md` are tested. No gaps found.
+
+### Operator Tests (`test/operators.test.ts` — 53 tests for 13 operators)
+
+| Operator | Tests | Edge cases |
+|---|---|---|
+| `filter` | 5 | Sync/async predicate, type-narrowing overload, all-filtered, all-pass |
+| `map` | 3 | Sync/async mapper, type transformation |
+| `pipe` | 6 | 0–4 functions, composition with subscribe+filter+map |
+| `take` | 4 | Normal, excess, 0, single |
+| `reduce` | 4 | Normal, empty source, async reducer, string concat |
+| `toArray` | 3 | Normal, empty, preserves order |
+| `batch` | 5 | Exact, remainder, single-item, size=1, empty |
+| `dedupe` | 4 | Mixed, no dups, empty, all same |
+| `window` | 5 | Default step, custom step, too short, exact size, empty |
+| `flat` | 3 | Normal, empty inner arrays, empty source |
+| `groupBy` | 3 | String key, empty, numeric key |
+| `chain` | 4 | Multiple, single, with empties, all empty |
+| `join` | 4 | Matching keys, no match, empty, duplicate keys (last wins) |
+
+All 13 operators tested with edge cases. Comprehensive coverage.
+
+### Redis Adapter Tests (`test/event-target-redis.test.ts` — 25 tests)
+
+Covers all acceptance criteria from `docs/architecture/event-targets/redis.md`:
+
+| Criterion | Covered? | Tests |
+|---|---|---|
+| Publish path — dispatchEvent sends to Redis | Yes | Correct channel, JSON serialization, returns true |
+| Subscribe path — addEventListener dispatches to local listeners | Yes | Subscribes to Redis, deserializes messages, ignores wrong channels |
+| Unsubscribe — removes callback; unsubscribes when empty | Yes | Last listener unsubscribes, partial remove keeps subscription |
+| Topic scoping — type:id strings as channels | Yes | "uses type:id strings as Redis channel names" |
+| Envelope serialization — full { type, id, payload } round-trip | Yes | JSON round-trip, null payload |
+| Multiple listeners on same topic | Yes | Single subscribe, delivers to all listeners |
+| Error propagation / handling | Yes | Parse error logs warning + continues, invalid JSON skipped |
+| Channel prefix | Yes | Prefix on publish, subscribe, unsubscribe, delivery, ignores non-prefixed |
+| Custom serializer | Yes | Custom stringify/parse called, non-JSON serializer round-trips |
+| EventListenerObject support | Yes | addEventListener + removeEventListener with handleEvent |
+
+The `redis.md` spec noted "No tests yet. Need: ..." — all 7 required test areas now covered, plus prefix, custom serializer, EventListenerObject, and error handling.
+
+### Integration Tests (`test/integration-pubsub-redis.test.ts` — 10 tests)
+
+End-to-end `createPubSub` + `createRedisEventTarget` with linked mock (publish triggers message on subscribe client):
+
+- Publish through Redis, subscriber receives
+- Correct channel name (type:id)
+- Subscribe triggers Redis SUBSCRIBE
+- Topic scoping (filtered events)
+- Multiple subscribers broadcast
+- Full envelope round-trip (complex + simple payloads)
+- Scoped topic isolation (no cross-topic leakage)
+- Channel prefix integration with pubsub
+
+### Code Conventions
+
+| File | License header | Unnecessary comments | Stray debug code |
+|---|---|---|---|
+| `types.ts` | MIT (graphql-yoga) ✅ | None ✅ | None ✅ |
+| `create_pubsub.ts` | MIT (graphql-yoga) ✅ | None ✅ | None ✅ |
+| `operators.ts` | MIT (graphql-yoga) short form ✅ | None ✅ | None ✅ |
+| `repeater.ts` | MIT (repeaterjs) ✅ | None ✅ | None ✅ |
+| `event-target-redis.ts` | MIT (graphql-yoga) + changelog ✅ | None ✅ | None ✅ |
+| `index.ts` | No header (barrel, original code) ✅ | None ✅ | None ✅ |
+
+All forked files have MIT attribution headers. No unnecessary comments in source. No stray debug code.
+
+### Architecture Alignment
+
+- Source layout matches `AGENTS.md` spec: `types.ts`, `create_pubsub.ts`, `operators.ts`, `repeater.ts`, `event-target-redis.ts`, `index.ts` barrel.
+- Sub-path exports: `@alkdev/pubsub/event-target-redis` configured in `package.json` exports map and `tsup.config.ts` entry array.
+- Peer dep isolation: `ioredis` is optional peer dep with `peerDependenciesMeta.optional: true`.
+- Barrel `index.ts` re-exports core API + operators + Redis adapter.
+- `EventEnvelope` format `{ type, id, payload }` matches spec (read-only fields).
+- `createPubSub` rejects `__`-prefixed types per ADR-003.
+- `TypedEventTarget` contract: `addEventListener`/`dispatchEvent`/`removeEventListener` implemented by Redis adapter.
+- `prefix` feature implemented per `redis.md` channel naming section.
+
+### Deficiencies / Observations
+
+1. **redis.md status**: The doc still says "Needs tests" and status "draft" — could be updated to reflect tests now exist.
+2. **redis.md limitations**: The listed limitations (no error handling, no channel prefix) are partially addressed — prefix is now implemented and error handling for parse errors exists, but connection failure/reconnection handling is still absent. The limitations section could be updated.
+3. **Test count**: Task description says 81 tests, actual count is now 99 (8 new Redis tests for prefix/error handling + 10 integration tests). No issue, just noting the delta.
 
 ## Summary
 
-> To be filled on completion
+**Review PASSED.** All acceptance criteria met:
+
+- ✅ `npm run build` passes cleanly
+- ✅ `npm run lint` passes (tsc --noEmit)
+- ✅ 99 tests pass (core: 11, operators: 53, redis: 25, integration: 10)
+- ✅ No regressions
+- ✅ Core tests align with api-surface.md (publish, subscribe, topic scoping, `__` rejection, cleanup, custom eventTarget)
+- ✅ All 13 operators tested with edge cases
+- ✅ Redis adapter tests cover all 7 spec requirements plus prefix, custom serializer, error handling, EventListenerObject
+- ✅ Code follows project conventions (no unnecessary comments, MIT headers on forked files, no debug code)
+- ✅ Architecture alignment verified (source layout, exports, peer dep isolation, EventEnvelope contract)
+
+Minor follow-up: consider updating `redis.md` status from "draft" to "stable" and updating its "No tests yet" and limitations sections to reflect current state.

tasks/009-websocket-server-tests.md

@@ -1,7 +1,7 @@
 ---
 id: websocket-server-tests
 name: Write tests for WebSocket server event target adapter
-status: pending
+status: completed
 depends_on: [websocket-server-adapter, websocket-client-tests]
 scope: moderate
 risk: medium
@@ -48,8 +48,15 @@ Test scenarios from the architecture doc:
 
 ## Notes
 
-> To be filled by implementation agent
+Completed as part of the websocket-server-adapter task. 46 test cases covering all acceptance criteria.
 
 ## Summary
 
-> To be filled on completion
+Tests were written alongside the adapter implementation. 46 tests pass, covering:
+- Connection lifecycle (addConnection, removeConnection, automatic cleanup on close)
+- Subscription protocol (__subscribe, __unsubscribe, idempotency, invalid topics)
+- Topic-based fan-out (subscribed connections receive events, unsubscribed don't)
+- Local listeners (addEventListener, removeEventListener, aggregation from spokes)
+- Per-connection spoke targets (spoke.addEventListener, spoke.dispatchEvent)
+- Error handling (malformed JSON, send failures, backpressure)
+- Callbacks (onConnection, onDisconnection, onBackpressure)

tasks/010-review-websocket-adapters.md

@@ -1,7 +1,7 @@
 ---
 id: review-websocket-adapters
 name: Review WebSocket client and server adapters
-status: pending
+status: completed
 depends_on: [websocket-client-tests, websocket-server-tests]
 scope: narrow
 risk: low
@@ -22,13 +22,13 @@ Verify:
 
 ## Acceptance Criteria
 
-- [ ] `npm run build` passes cleanly
-- [ ] `npm run lint` passes
-- [ ] `npm test` passes with all core + Redis + WebSocket tests
-- [ ] WebSocket client subscription forwarding matches ADR-003
-- [ ] WebSocket server fan-out and subscription tracking matches architecture spec
-- [ ] No unnecessary comments in source (project convention)
-- [ ] License headers present where needed
+- [x] `npm run build` passes cleanly
+- [x] `npm run lint` passes
+- [x] `npm test` passes with all core + Redis + WebSocket tests (181/181)
+- [x] WebSocket client subscription forwarding matches ADR-003
+- [x] WebSocket server fan-out and subscription tracking matches architecture spec
+- [x] No unnecessary comments in source (project convention)
+- [x] License headers present where needed
 
 ## References
 
@@ -36,10 +36,104 @@ Verify:
 - docs/architecture/event-targets/websocket-server.md
 - docs/architecture/decisions/003-subscription-control-protocol.md
 
-## Notes
+## Review Report
 
-> To be filled by implementation agent
+### 1. Build / Lint / Tests
+
+| Check | Result |
+|-------|--------|
+| `npm run build` | Pass — tsup produces ESM + CJS + declarations for all 4 entry points |
+| `npm run lint` (`tsc --noEmit`) | Pass — no type errors |
+| `npm test` | Pass — 181/181 tests (46 ws-server, 36 ws-client, 25 redis, 10 redis-integration, 11 create_pubsub, 53 operators) |
+
+### 2. Client Adapter (`event-target-websocket-client.ts`) — Spec Alignment
+
+| Spec Requirement | Implementation | Status |
+|-----------------|----------------|--------|
+| Takes a single connected `WebSocket` | `createWebSocketClientEventTarget<TEvent>(ws: WebSocket)` | Pass |
+| `dispatchEvent` sends `JSON.stringify(event.detail)` and returns `true` | Line 89: `ws.send(JSON.stringify(event.detail)); return true;` | Pass |
+| `addEventListener` registers local listener + sends `__subscribe` on first listener per topic | Lines 38-56: `addCallback` tracks per-topic `Set<EventListener>`, sends `__subscribe` when `isFirst` | Pass |
+| `removeEventListener` removes local listener + sends `__unsubscribe` when last listener removed | Lines 58-78: `removeCallback` deletes from Set, sends `__unsubscribe` only when `callbacks.size === 0` | Pass |
+| `null` callback is a no-op (no listener registered, no `__subscribe` sent) | Lines 82-83, 92-96: `if (callbackOrOptions != null)` guard | Pass |
+| `EventListenerObject.handleEvent` unwrapping | Lines 84, 95: `"handleEvent" in callbackOrOptions ? callbackOrOptions.handleEvent : callbackOrOptions` | Pass |
+| Malformed JSON → silently ignored, warning logged | Lines 10-17: `try/catch` around `JSON.parse` with `console.warn` | Pass |
+| Control events (`__subscribe`, `__unsubscribe`) from server → silently ignored | Line 19: `envelope.type.startsWith("__")` causes early return | Pass |
+| Subscription reference counting (dedup) | Multiple `addEventListener` for same topic only sends one `__subscribe` (tested) | Pass |
+| `ws.send()` failure → error propagates to caller | Line 89: `dispatchEvent` calls `ws.send()` directly, no try/catch — error propagates | Pass |
+| Reconnection is caller-managed (new instance per connection) | Confirmed — no reconnection logic in adapter; tests verify new ws → new target → fresh `__subscribe` | Pass |
+
+### 3. Server Adapter (`event-target-websocket-server.ts`) — Spec Alignment
+
+| Spec Requirement | Implementation | Status |
+|-----------------|----------------|--------|
+| `WebSocketLike` interface (not raw `WebSocket`) | Lines 3-9: `WebSocketLike` with `send`, `close`, `bufferedAmount`, `onmessage`, `onclose` | Pass |
+| `SpokeEventTarget<TEvent>` exposes `ws` property | Lines 11-13: `SpokeEventTarget` extends `TypedEventTarget<TEvent>` with `readonly ws` | Pass |
+| `addConnection(ws)` / `removeConnection(ws)` | Lines 130-217, 98-128: Full lifecycle management | Pass |
+| `addConnection` sets up `onmessage`/`onclose`, stores originals, calls `onConnection` | Lines 130-217 | Pass |
+| `removeConnection` cleans up subs/maps, restores original handlers, does NOT close ws | Lines 98-128: No `ws.close()` call | Pass |
+| `__subscribe` control event → adds ws to topic's `Set<WebSocketLike>` | Lines 153-167 | Pass |
+| `__unsubscribe` control event → removes ws from topic set | Lines 170-186 | Pass |
+| Control events not dispatched to local listeners | Code returns early for `__subscribe`/`__unsubscribe` before local listener dispatch | Pass |
+| Invalid topic in `__subscribe` (empty or non-string) → silently ignored | Lines 154-155: `typeof topic === "string" && topic.length > 0` | Pass |
+| Duplicate `__subscribe` is idempotent (Set handles dedup) | `Set<WebSocketLike>.add()` is idempotent | Pass |
+| Malformed JSON → caught, warned, message ignored | Lines 143-149 | Pass |
+| `dispatchEvent` → fan-out to subscribed connections + local listeners, always returns `true` | Lines 262-278 | Pass |
+| Per-connection spoke target: `addEventListener`/`removeEventListener` for events from that spoke only | Lines 47-96: `createSpokeTarget` with per-connection listener map | Pass |
+| Per-connection spoke `dispatchEvent` sends to that specific ws | Lines 77-91: `spoke.dispatchEvent` checks backpressure then sends | Pass |
+| Backpressure: check `bufferedAmount > maxBufferedAmount` before send, close with 1013 | Lines 219-226 (`sendToConnection`) and 79-83 (spoke target) | Pass |
+| Default `maxBufferedAmount` = 1,048,576 (1 MB) | Line 30 | Pass |
+| `onBackpressure` called before disconnect, cannot prevent it | Lines 221-222, 81-82 | Pass |
+| `ws.send()` failure → catches error, removes connection, fires `onDisconnection` | Lines 87-88 (`spoke.dispatchEvent`), 227-228 (`sendToConnection`) | Pass |
+| Duplicate `addConnection` for same ws is a no-op | Line 131: `if (spokeTargets.has(ws)) return;` | Pass |
+| `onclose` handler calls `removeConnection` and chains to original handler | Lines 209-214 | Pass |
+
+### 4. ADR-003 Subscription Control Protocol Compliance
+
+| ADR-003 Requirement | Implementation | Status |
+|---------------------|----------------|--------|
+| Control events use `EventEnvelope` format | Both adapters send/receive `{ type: "__subscribe"|"__unsubscribe", id: "", payload: { topic: "..." } }` | Pass |
+| `id` field is `""` for control events | Lines 51, 72 (client) | Pass |
+| Control events use `payload.topic` for routing, not `type:id` scoping | Client sends `payload: { topic }`, server reads `envelope.payload.topic` | Pass |
+| `__`-prefixed types are reserved, not dispatched to user-facing listeners | Client: line 19 `startsWith("__")` → return; Server: lines 153-186 handle `__subscribe`/`__unsubscribe` with early return | Pass |
+| Fire-and-forget semantics (no ack) | No acknowledgment mechanism in either adapter | Pass |
+| Cleanup on disconnection | Server removes all subscriptions on `onclose` → `removeConnection`; Client per-connection so new instance needed | Pass |
+| Reconnection requires new instance + re-subscribe | Client: each connection gets new instance, `addEventListener` triggers fresh `__subscribe` | Pass |
+
+### 5. Test Coverage
+
+**Client adapter (36 tests):** Covers send path, receive path, topic scoping, subscription forwarding (including dedup), unsubscribe forwarding, malformed JSON, control event ignoring, envelope round-trip, `null` callback, `EventListenerObject`, reconnection, connection close, and subscription reference counting.
+
+**Server adapter (46 tests):** Covers `addConnection`/`removeConnection`, automatic cleanup on close, subscription tracking (subscribe/unsubscribe/idempotent/invalid topic), topic-based fan-out, dispatched events to local listeners, per-connection spoke targets, incoming message aggregation, backpressure (threshold, callback, disconnect, below threshold, default 1MB), send failure handling, local `addEventListener`/`removeEventListener`, `EventListenerObject`, and `onDisconnection` callback.
+
+All test items from the architecture spec test plans are covered.
+
+### 6. Code Conventions
+
+- No unnecessary comments in either adapter source file — Pass
+- No stray debug code — Pass
+- `types.ts` retains the graphql-yoga MIT license header — Pass
+
+### 7. Exports
+
+| File | Status |
+|------|--------|
+| `src/index.ts` — barrel re-exports `createWebSocketClientEventTarget` and `createWebSocketServerEventTarget` + types | Pass |
+| `tsup.config.ts` — includes both `event-target-websocket-client.ts` and `event-target-websocket-server.ts` entries | Pass |
+| `package.json` exports — includes both `./event-target-websocket-client` and `./event-target-websocket-server` sub-path exports with ESM/CJS/d.ts | Pass |
+| No peer deps for WebSocket adapters (correct — WebSocket is web standard) | Pass |
+
+### 8. Minor Observations (non-blocking)
+
+1. The client adapter uses the raw `WebSocket` type (browser global) rather than a `WebSocketLike` interface like the server. This is consistent with the spec ("No native deps — works in browsers and Node") but makes the client adapter harder to unit-test with alternative WebSocket implementations. The current tests use `as any` casts for mock WebSockets, which works but is less type-safe than the server's `WebSocketLike` pattern. This is a design choice, not a bug — the client is simpler (single connection) and the spec explicitly says "takes an already-connected WebSocket."
+
+2. The server adapter has a subtle difference between `sendToConnection` (used for server `dispatchEvent` fan-out) and `spoke.dispatchEvent` (used for per-connection spoke sending). Both check backpressure and handle send failures, but the spoke target's `dispatchEvent` has its own inline backpressure check rather than calling `sendToConnection`. Duplicated logic, but functionally equivalent — no bug.
+
+3. The server's `onmessage` handler checks `typeof envelope.type !== "string"` (line 151) but does NOT check for `__`-prefixed types beyond `__subscribe` and `__unsubscribe`. If a future control type like `__ping` were added, it would fall through to the regular event dispatch and be delivered to local listeners. This is fine as long as ADR-003's convention is followed — only `__subscribe` and `__unsubscribe` are defined currently. Future control types should be added to the handler.
+
+### Verdict
+
+**PASS** — All acceptance criteria met. Both adapters correctly implement the architecture spec and ADR-003. Tests cover all specified behaviors. Build, lint, and 181 tests pass cleanly.
 
 ## Summary
 
-> To be filled on completion
+Review completed successfully. Both WebSocket client and server adapters fully align with their architecture specs and ADR-003. Subscription control protocol (`__subscribe`/`__unsubscribe`) is correctly implemented in both directions. Topic-based fan-out, backpressure protection, error handling, and connection lifecycle management all match spec. All 181 tests pass. Two minor non-blocking observations noted (client uses raw `WebSocket` type, duplicated backpressure logic in spoke target). No blockers found.

tasks/011-worker-adapter-rd.md

@@ -1,7 +1,7 @@
 ---
 id: worker-adapter-rd
 name: "R&D on Worker adapter: Node vs Web Worker API differences"
-status: pending
+status: completed
 depends_on: [review-core-and-redis]
 scope: narrow
 risk: medium
@@ -23,10 +23,10 @@ This R&D task should:
 
 ## Acceptance Criteria
 
-- [ ] R&D notes documented on the API differences between Web Worker and Node worker_threads
-- [ ] Decision made on scope: single Web Worker adapter, or dual adapter from the start
-- [ ] If dual adapter, create separate task for the Node worker_threads variant
-- [ ] If single adapter, identify what runtime detection or abstraction is needed
+- [x] R&D notes documented on the API differences between Web Worker and Node worker_threads
+- [x] Decision made on scope: single Web Worker adapter, or dual adapter from the start
+- [x] If dual adapter, create separate task for the Node worker_threads variant
+- [x] If single adapter, identify what runtime detection or abstraction is needed
 
 ## References
 
@@ -34,8 +34,103 @@ This R&D task should:
 
 ## Notes
 
-> To be filled by implementation agent
+### API Comparison: Web Worker vs Node `worker_threads`
+
+| Concern | Web Worker (browser/Deno/Bun) | Node `worker_threads` |
+|---------|-------------------------------|----------------------|
+| **Host send** | `worker.postMessage(msg)` | `worker.postMessage(msg)` |
+| **Host receive** | `worker.onmessage = handler` or `worker.addEventListener('message', handler)` | `worker.on('message', handler)` |
+| **Thread send** | `self.postMessage(msg)` | `parentPort.postMessage(msg)` |
+| **Thread receive** | `self.onmessage = handler` or `self.addEventListener('message', handler)` | `parentPort.on('message', handler)` |
+| **Message data** | `event.data` (MessageEvent) | Direct value — no `.data` wrapper |
+| **Event model** | Event-based (DOM-style) | EventEmitter-based (Node-style) |
+| **Transferables** | `postMessage(msg, [transfer])` | `postMessage(msg, [transferList])` — same concept, different arg name |
+| **Dedicated channels** | `MessageChannel` (web standard) | `MessageChannel` from `worker_threads` |
+| **Thread self-reference** | `self` / `globalThis` | `parentPort` (must be imported) |
+| **Lifecycle** | `self.close()` | `process.exit()` or `parentPort.close()` |
+
+### Key Differences That Matter for the Adapter
+
+1. **Message format**: Web Workers wrap data in `MessageEvent.data`, so `msg.data` extracts the envelope. Node `worker_threads` delivers the payload directly with no `.data` wrapper. This is a fundamental structural difference — any abstraction must handle this at the message-reception layer.
+
+2. **Event subscription model**: Web Workers use `onmessage`/`addEventListener('message', ...)` (DOM EventTarget pattern). Node uses `parentPort.on('message', ...)` (Node EventEmitter pattern). These are fundamentally different subscription APIs that cannot be unified without a shim/wrapper.
+
+3. **Thread-side messaging primitive**: Web Workers use `self.postMessage(msg)` where `self` is the global scope. Node uses `parentPort.postMessage(msg)` where `parentPort` must be explicitly imported from `node:worker_threads`. These are different objects with different origins.
+
+4. **Host-side subscription setup**: `worker.onmessage = handler` (property assignment) vs `worker.on('message', handler)` (EventEmitter). The object shape is completely different.
+
+5. **TypeScript types**: Web Worker types come from `lib.webworker.d.ts`. Node worker types come from `@types/node`. They are mutually exclusive type definitions — a single file cannot import both without conditional types or `// @ts-ignore`.
+
+### Feasibility Assessment: Single Adapter with Runtime Detection
+
+**Verdict: Not recommended.**
+
+A single adapter abstracting both APIs would require:
+- A runtime detection layer (`typeof process !== 'undefined' && process.versions?.node`)
+- A port abstraction wrapping `worker.onmessage`/`worker.addEventListener` vs `worker.on('message', ...)`
+- A thread-side abstraction wrapping `self.postMessage` vs `parentPort.postMessage`
+- A message-unwrapping layer (`msg.data` vs `msg`)
+- Conditional TypeScript imports and types
+- Test infrastructure that runs in both browser and Node contexts
+
+This adds significant complexity (wrappers, detection, conditional code paths) for marginal benefit. The adapter's core job — wrapping a postMessage channel — is simple. The abstraction layer would be more code than the adapter itself.
+
+### Feasibility Assessment: Single Adapter Abstracting Both (Common Interface)
+
+**Verdict: Possible but not worth it.**
+
+You could define a `MessagePort`-like abstraction:
+```ts
+interface WorkerChannel {
+  send(msg: EventEnvelope): void;
+  onMessage(handler: (msg: EventEnvelope) => void): void;
+  close(): void;
+}
+```
+
+Then provide two implementations (`WebWorkerHostChannel`, `NodeWorkerHostChannel`, etc.). However:
+- This pushes the API surface from 2 factory functions to 4 (2 per runtime)
+- The user must import the correct factory based on runtime, defeating the "single adapter" goal
+- Testing requires both runtime environments
+- The adapter code itself is ~50 lines per side; the abstraction adds more code than it saves
+
+### Decision: Single Adapter — Web Worker Only (Initial Scope)
+
+**Scope: `event-target-worker` targets Web Workers only (browser, Deno, Bun).**
+
+Rationale:
+1. **Three runtimes, one API**: Browser, Deno, and Bun all implement the Web Worker API. This covers the vast majority of use cases for a pub/sub transport.
+2. **Node has a natural alternative**: Node users already have `event-target-redis` for cross-process pub/sub. Worker threads in Node are primarily for CPU-bound tasks (not distributed messaging), and Redis is the better transport for inter-process coordination.
+3. **Simplicity wins**: The adapter should be thin. Two factory functions, ~50 lines each. No abstraction layers.
+4. **No runtime detection needed**: Since we target only Web Workers, there's no need to detect the environment. The consumer simply uses the correct import for their platform.
+5. **Path for Node later**: If Node `worker_threads` support is needed in the future, a separate `event-target-node-worker` adapter can use the same `EventEnvelope` protocol but with `parentPort` semantics. This keeps each adapter simple and focused.
+
+### What the Web Worker Adapter Needs
+
+No polyfills or shims are required. The Web Worker API is natively supported in all target runtimes:
+- **Browser**: `Worker`, `self.postMessage`, `self.onmessage` — standard since ES2015
+- **Deno**: Full Web Worker API support
+- **Bun**: Full Web Worker API support (with additional `MessagePort` compat)
+
+The adapter will be two factory functions:
+- `createWorkerHostEventTarget(worker: Worker)` — wraps a `Worker` instance on the host side
+- `createWorkerThreadEventTarget()` — wraps `self` on the worker thread side
+
+Both send `EventEnvelope` over `postMessage`, both extract from `event.data` on receive. No serialization config needed since `EventEnvelope` is JSON-serializable and structured-clone compatible.
+
+### Node `worker_threads` — Future Task
+
+If Node worker_threads support is needed, a separate adapter `event-target-node-worker` should be created. Key differences that adapter would handle:
+- Use `parentPort` instead of `self`
+- Use `worker.on('message', ...)` instead of `worker.onmessage`
+- No `MessageEvent.data` wrapper — receive payload directly
+- Import from `node:worker_threads`
+- Add `@types/node` as a dev dependency for type resolution
+
+This is tracked separately (no new task needed at this time — can be created when demand exists).
 
 ## Summary
 
-> To be filled on completion
+**Decision: Single adapter targeting Web Workers only — no runtime detection, no abstraction layer.**
+
+The API differences between Web Workers and Node `worker_threads` are structural (EventTarget vs EventEmitter, `MessageEvent.data` vs direct payload, `self.postMessage` vs `parentPort.postMessage`), not superficial. Attempting to unify them would add more complexity than the adapter code itself. The Web Worker API is consistently supported across browser, Deno, and Bun, giving the adapter broad reach without Node-specific code. Node users have Redis as a transport alternative. A separate `event-target-node-worker` adapter can be created in the future if demand exists.

tasks/013-worker-adapter-tests.md

@@ -1,7 +1,7 @@
 ---
 id: worker-adapter-tests
 name: Write tests for Worker event target adapter
-status: pending
+status: completed
 depends_on: [worker-adapter-implementation]
 scope: moderate
 risk: medium

tasks/014-review-worker-adapter.md

@@ -1,7 +1,7 @@
 ---
 id: review-worker-adapter
 name: Review Worker adapter implementation
-status: pending
+status: completed
 depends_on: [worker-adapter-tests]
 scope: narrow
 risk: low
@@ -31,8 +31,27 @@ Review checkpoint after Worker adapter implementation. Verify:
 
 ## Notes
 
-> To be filled by implementation agent
+### Review Report
+
+**Build / Lint / Tests**: All pass. 242 tests across 8 files. Build produces correct d.ts for all 5 entry points (index, redis, ws-client, ws-server, worker).
+
+**Worker Adapter API**: Matches architecture spec.
+- `createWorkerHostEventTarget(worker: Worker)` — host side, uses `worker.postMessage`/`worker.onmessage`
+- `createWorkerThreadEventTarget()` — thread side, uses `globalThis.postMessage`/`globalThis.onmessage`
+- Both follow the same `Map<string, Set<EventListener>>` pattern as other adapters
+- `__`-prefixed event types are silently ignored (consistent with WS adapters)
+
+**Exports**: Correct.
+- `tsup.config.ts` has `event-target-worker.ts` entry
+- `package.json` has `./event-target-worker` sub-path export
+- `src/index.ts` re-exports both factory functions
+
+**Test Strategy**: Mock-based (not actual Worker threads). Uses mock `Worker` and `globalThis` objects. 42 tests covering host send/receive, thread send/receive, topic scoping, envelope round-trip, bidirectional communication, error handling.
+
+**Observation**: The thread side sets `globalThis.onmessage` directly, which overwrites any existing handler. This is noted in the architecture doc and acceptable — the adapter takes ownership of the message channel.
+
+**Verdict**: PASS
 
 ## Summary
 
-> To be filled on completion
+Worker adapter review passed. 242 tests, build, lint all clean. API matches architecture spec. Web Worker only per R&D decision. Mock-based test strategy is sound (42 tests).

tasks/015-deferred-iroh-adapters.md

@@ -1,7 +1,7 @@
 ---
 id: deferred-iroh-adapters
 name: Iroh spoke and hub adapters (deferred)
-status: pending
+status: blocked
 depends_on: [review-worker-adapter]
 scope: system
 risk: critical

tasks/016-build-and-exports-validation.md

@@ -1,7 +1,7 @@
 ---
 id: build-and-exports-validation
 name: Validate build, package.json exports, and tsup config for all adapters
-status: pending
+status: completed
 depends_on: []
 scope: narrow
 risk: low
@@ -38,8 +38,51 @@ This task validates the current setup and serves as a checklist item for each ad
 
 ## Notes
 
-> To be filled by implementation agent
+Validated all acceptance criteria. No changes were needed — the existing configuration is correct.
+
+### Validation Results
+
+1. **`npm run build` produces correct output** ✅
+   - `src/index.ts` → `dist/index.js` (ESM), `dist/index.cjs` (CJS), `dist/index.d.ts` + `dist/index.d.cts` (declarations)
+   - `src/event-target-redis.ts` → `dist/event-target-redis.js` (ESM), `dist/event-target-redis.cjs` (CJS), `dist/event-target-redis.d.ts` + `dist/event-target-redis.d.cts` (declarations)
+   - Code splitting enabled: shared chunk between entries (`chunk-JGLUDY7D.js` / `chunk-TBKAZXTS.cjs`)
+   - Verified both ESM dynamic import and CJS require work for both entry points
+
+2. **`npm run lint` (tsc --noEmit) passes** ✅ — No errors
+
+3. **`package.json` exports map has correct ESM/CJS/dts paths** ✅
+   - `"."` → import (d.ts + js) / require (d.cts + cjs)
+   - `"./event-target-redis"` → import (d.ts + js) / require (d.cts + cjs)
+   - All paths resolve to actual built files
+
+4. **`tsup.config.ts` lists all current entry points** ✅
+   - `src/index.ts` and `src/event-target-redis.ts` both present
+   - `format: ['esm', 'cjs']`, `dts: true`, `splitting: true`, `target: 'es2022'`
+
+5. **`src/index.ts` re-exports everything from all modules** ✅
+   - Exports from: `create_pubsub.js`, `types.js`, `operators.js`, `repeater.js`, `event-target-redis.js`
+   - All public API surface is accessible from barrel
+
+6. **Peer dependencies and peerDependenciesMeta are correct** ✅
+   - `ioredis@^5.0.0` as optional peer dep
+   - Future: `@rayhanadev/iroh` will follow same pattern when added
+
+7. **No runtime dependencies** ✅
+   - `dependencies: {}` is empty
+   - `@repeaterjs/repeater` is inlined in `src/repeater.ts`
+
+### Verified type resolution
+- `import { createRedisEventTarget } from '@alkdev/pubsub/event-target-redis'` — types resolve correctly
+- `import { createPubSub, type EventEnvelope } from '@alkdev/pubsub'` — types resolve correctly
+- Works with both `skipLibCheck: true` and `skipLibCheck: false`
+
+### Verified package contents
+- `npm pack --dry-run` shows 19 files (all dist files + package.json)
+- `files: ["dist"]` correctly includes all build output
 
 ## Summary
 
-> To be filled on completion
+Validated build pipeline, package.json exports map, and tsup config for all adapters. All acceptance criteria pass with no changes required — the existing configuration is correct and consistent.
+- Created: none
+- Modified: none (validation-only task)
+- Tests: 0 (no test files exist yet; `npm test` exits with "No test files found")

tasks/019-final-review-and-ci-validation.md

@@ -1,7 +1,7 @@
 ---
 id: final-review-and-ci-validation
 name: "Final review: full test suite, build, and CI readiness"
-status: pending
+status: completed
 depends_on: [review-worker-adapter, integration-test-ws-client-server]
 scope: moderate
 risk: low
@@ -44,8 +44,36 @@ Final review before considering the package ready for use (excluding Iroh, which
 
 ## Notes
 
-> To be filled by implementation agent
+### Final Review Report
+
+**Build**: All 5 entry points produce correct ESM + CJS + declarations. tsup with splitting produces shared chunks correctly.
+
+**Lint**: `tsc --noEmit` passes cleanly.
+
+**Tests**: 242 tests across 8 files, all passing.
+
+**Coverage**:
+- `create_pubsub.ts`: 100% (all)
+- `operators.ts`: 100% (all)
+- `event-target-redis.ts`: 97.36%
+- `event-target-websocket-client.ts`: 97.75%
+- `event-target-websocket-server.ts`: 92.44%
+- `event-target-worker.ts`: 51.26% (thread side untested — requires Worker env)
+- `index.ts` / `types.ts`: 0% (barrel/type-only, expected)
+- `repeater.ts`: 67.35% (inlined, complex async iterator)
+- Overall: 81.99% statements, core modules > 90%
+
+**Sub-path exports**: All 4 adapters have correct exports in package.json (ESM + CJS + d.ts + d.cts), tsup config entries, and barrel re-exports in index.ts.
+
+**No runtime dependencies**: Confirmed. `dependencies` is `{}`. Repeater is inlined. `ioredis` is optional peer dep.
+
+**Package consumption**: All sub-path imports resolve correctly:
+- `@alkdev/pubsub` → core + operators + all adapters
+- `@alkdev/pubsub/event-target-redis` → Redis adapter
+- `@alkdev/pubsub/event-target-websocket-client` → WS client
+- `@alkdev/pubsub/event-target-websocket-server` → WS server
+- `@alkdev/pubsub/event-target-worker` → Worker adapter
 
 ## Summary
 
-> To be filled on completion
+**Final review PASSED.** 242 tests, build produces correct dual ESM/CJS output with all 5 entry points, type-check clean, coverage >80% (core modules >90%), no runtime dependencies, peer dep isolation correct, all sub-path exports configured. Package is ready for use (Iroh adapters deferred).

test/create_pubsub.test.ts

@@ -0,0 +1,272 @@
+import { describe, it, expect, vi } from "vitest";
+import { createPubSub } from "../src/create_pubsub.js";
+import type { EventEnvelope, TypedEventTarget } from "../src/types.js";
+
+type TestEventMap = {
+  "message.sent": string;
+  "user.joined": { name: string };
+  "session.status": { status: string; code: number };
+};
+
+describe("createPubSub", () => {
+  describe("publish", () => {
+    it("dispatches event with correct type:id topic", async () => {
+      const pubsub = createPubSub<TestEventMap>();
+      const received: EventEnvelope<"message.sent", string>[] = [];
+
+      const iterator = pubsub.subscribe("message.sent", "abc123");
+      const consume = (async () => {
+        for await (const envelope of iterator) {
+          received.push(envelope);
+          if (received.length >= 1) break;
+        }
+      })();
+
+      pubsub.publish("message.sent", "abc123", "hello");
+      await consume;
+
+      expect(received).toHaveLength(1);
+      expect(received[0].type).toBe("message.sent");
+      expect(received[0].id).toBe("abc123");
+    });
+
+    it("throws on __-prefixed event types", () => {
+      const pubsub = createPubSub<TestEventMap>();
+
+      expect(() => pubsub.publish("__subscribe" as any, "", {})).toThrow(
+        'Event types starting with "__" are reserved for adapter control messages. Received: "__subscribe"',
+      );
+    });
+
+    it("dispatches EventEnvelope with type, id, and payload as CustomEvent detail", async () => {
+      const pubsub = createPubSub<TestEventMap>();
+      const received: EventEnvelope<"user.joined", { name: string }>[] = [];
+
+      const iterator = pubsub.subscribe("user.joined", "user1");
+      const consume = (async () => {
+        for await (const envelope of iterator) {
+          received.push(envelope);
+          if (received.length >= 1) break;
+        }
+      })();
+
+      pubsub.publish("user.joined", "user1", { name: "Alice" });
+      await consume;
+
+      expect(received).toHaveLength(1);
+      expect(received[0]).toEqual({
+        type: "user.joined",
+        id: "user1",
+        payload: { name: "Alice" },
+      });
+    });
+  });
+
+  describe("subscribe", () => {
+    it("returns async iterable that yields EventEnvelope objects", async () => {
+      const pubsub = createPubSub<TestEventMap>();
+      const received: EventEnvelope<string>[] = [];
+
+      const iterator = pubsub.subscribe("message.sent", "msg1");
+
+      const consume = (async () => {
+        for await (const envelope of iterator) {
+          received.push(envelope);
+          if (received.length === 1) break;
+        }
+      })();
+
+      pubsub.publish("message.sent", "msg1", "hello");
+
+      await consume;
+      expect(received).toHaveLength(1);
+      expect(received[0]).toEqual({
+        type: "message.sent",
+        id: "msg1",
+        payload: "hello",
+      });
+    });
+
+    it("yields envelope with correct type, id, and payload fields", async () => {
+      const pubsub = createPubSub<TestEventMap>();
+      let result: EventEnvelope<"session.status", { status: string; code: number }> | undefined;
+
+      const iterator = pubsub.subscribe("session.status", "sess1");
+
+      const consume = (async () => {
+        for await (const envelope of iterator) {
+          result = envelope;
+          break;
+        }
+      })();
+
+      pubsub.publish("session.status", "sess1", { status: "active", code: 200 });
+
+      await consume;
+
+      expect(result).toBeDefined();
+      expect(result!.type).toBe("session.status");
+      expect(result!.id).toBe("sess1");
+      expect(result!.payload).toEqual({ status: "active", code: 200 });
+    });
+
+    it("receives events only for the subscribed topic", async () => {
+      const pubsub = createPubSub<TestEventMap>();
+      const received: EventEnvelope<string>[] = [];
+
+      const iterator = pubsub.subscribe("message.sent", "msg1");
+
+      const consume = (async () => {
+        for await (const envelope of iterator) {
+          received.push(envelope);
+          if (received.length >= 2) break;
+        }
+      })();
+
+      pubsub.publish("message.sent", "msg1", "first");
+      pubsub.publish("message.sent", "msg_different", "wrong topic");
+      pubsub.publish("message.sent", "msg1", "second");
+
+      await consume;
+
+      expect(received).toHaveLength(2);
+      expect(received[0].payload).toBe("first");
+      expect(received[1].payload).toBe("second");
+    });
+
+    it("multiple subscribers on the same topic all receive events", async () => {
+      const pubsub = createPubSub<TestEventMap>();
+      const received1: EventEnvelope<string>[] = [];
+      const received2: EventEnvelope<string>[] = [];
+
+      const iterator1 = pubsub.subscribe("message.sent", "msg1");
+      const iterator2 = pubsub.subscribe("message.sent", "msg1");
+
+      const consume1 = (async () => {
+        for await (const envelope of iterator1) {
+          received1.push(envelope);
+          if (received1.length >= 1) break;
+        }
+      })();
+
+      const consume2 = (async () => {
+        for await (const envelope of iterator2) {
+          received2.push(envelope);
+          if (received2.length >= 1) break;
+        }
+      })();
+
+      pubsub.publish("message.sent", "msg1", "broadcast");
+
+      await Promise.all([consume1, consume2]);
+
+      expect(received1).toHaveLength(1);
+      expect(received2).toHaveLength(1);
+      expect(received1[0].payload).toBe("broadcast");
+      expect(received2[0].payload).toBe("broadcast");
+    });
+
+    it("cleanup: breaking out of for await loop removes the listener", async () => {
+      const pubsub = createPubSub<TestEventMap>();
+      const received: EventEnvelope<string>[] = [];
+
+      const iterator = pubsub.subscribe("message.sent", "cleanup-test");
+
+      const consume = (async () => {
+        for await (const envelope of iterator) {
+          received.push(envelope);
+          break;
+        }
+      })();
+
+      pubsub.publish("message.sent", "cleanup-test", "first");
+      await consume;
+
+      expect(received).toHaveLength(1);
+      expect(received[0].payload).toBe("first");
+
+      pubsub.publish("message.sent", "cleanup-test", "after-break");
+      await new Promise((resolve) => setTimeout(resolve, 20));
+
+      expect(received).toHaveLength(1);
+
+      const secondIterator = pubsub.subscribe("message.sent", "cleanup-test");
+      const secondReceived: EventEnvelope<string>[] = [];
+      const consume2 = (async () => {
+        for await (const envelope of secondIterator) {
+          secondReceived.push(envelope);
+          if (secondReceived.length >= 1) break;
+        }
+      })();
+
+      pubsub.publish("message.sent", "cleanup-test", "second-listener");
+      await consume2;
+
+      expect(secondReceived).toHaveLength(1);
+      expect(secondReceived[0].payload).toBe("second-listener");
+      expect(received).toHaveLength(1);
+    });
+  });
+
+  describe("createPubSub config", () => {
+    it("with custom eventTarget dispatches to that target", () => {
+      const customTarget = new EventTarget() as TypedEventTarget<any>;
+      const dispatchSpy = vi.spyOn(customTarget, "dispatchEvent");
+
+      const pubsub = createPubSub<TestEventMap>({ eventTarget: customTarget });
+
+      pubsub.publish("message.sent", "custom1", "hello custom");
+
+      expect(dispatchSpy).toHaveBeenCalledTimes(1);
+      expect(dispatchSpy.mock.calls[0][0].type).toBe("message.sent:custom1");
+      expect((dispatchSpy.mock.calls[0][0] as CustomEvent).detail).toEqual({
+        type: "message.sent",
+        id: "custom1",
+        payload: "hello custom",
+      });
+
+      dispatchSpy.mockRestore();
+    });
+
+    it("without eventTarget uses new EventTarget() (in-process)", async () => {
+      const pubsub = createPubSub<TestEventMap>();
+      const received: EventEnvelope<string>[] = [];
+
+      const iterator = pubsub.subscribe("message.sent", "inproc1");
+      const consume = (async () => {
+        for await (const envelope of iterator) {
+          received.push(envelope);
+          if (received.length >= 1) break;
+        }
+      })();
+
+      pubsub.publish("message.sent", "inproc1", "in-process works");
+      await consume;
+
+      expect(received).toHaveLength(1);
+      expect(received[0].payload).toBe("in-process works");
+    });
+
+    it("custom eventTarget receives events via subscribe", async () => {
+      const customTarget = new EventTarget() as TypedEventTarget<any>;
+      const pubsub = createPubSub<TestEventMap>({ eventTarget: customTarget });
+      const received: EventEnvelope<string>[] = [];
+
+      const iterator = pubsub.subscribe("message.sent", "custom-sub");
+
+      const consume = (async () => {
+        for await (const envelope of iterator) {
+          received.push(envelope);
+          if (received.length >= 1) break;
+        }
+      })();
+
+      pubsub.publish("message.sent", "custom-sub", "via custom");
+
+      await consume;
+
+      expect(received).toHaveLength(1);
+      expect(received[0].payload).toBe("via custom");
+    });
+  });
+});

test/event-target-redis.test.ts

@@ -0,0 +1,701 @@
+import { describe, it, expect, vi } from "vitest";
+import { createRedisEventTarget } from "../src/event-target-redis.js";
+import type { EventEnvelope, TypedEvent } from "../src/types.js";
+
+type TestEvent = TypedEvent<string, EventEnvelope>;
+
+function createMockRedis() {
+  const publications: { channel: string; message: string }[] = [];
+  const subscriptions: { channel: string }[] = [];
+  const unsubscriptions: { channel: string }[] = [];
+  let messageListener: ((channel: string, message: string) => void) | null = null;
+
+  return {
+    publish: vi.fn((channel: string, message: string) => {
+      publications.push({ channel, message });
+    }),
+    subscribe: vi.fn((channel: string) => {
+      subscriptions.push({ channel });
+    }),
+    unsubscribe: vi.fn((channel: string) => {
+      unsubscriptions.push({ channel });
+    }),
+    on: vi.fn((event: string, callback: (channel: string, message: string) => void) => {
+      if (event === "message") {
+        messageListener = callback;
+      }
+      return {} as any;
+    }),
+    off: vi.fn((event: string, callback: (channel: string, message: string) => void) => {
+      if (event === "message" && messageListener === callback) {
+        messageListener = null;
+      }
+    }),
+    publications,
+    subscriptions,
+    unsubscriptions,
+    simulateMessage(channel: string, message: string) {
+      if (messageListener) {
+        messageListener(channel, message);
+      }
+    },
+  };
+}
+
+describe("createRedisEventTarget", () => {
+  describe("dispatchEvent (publish path)", () => {
+    it("publishes to Redis with correct channel name matching event type", () => {
+      const publishClient = createMockRedis();
+      const subscribeClient = createMockRedis();
+      const eventTarget = createRedisEventTarget<TestEvent>({
+        publishClient: publishClient as any,
+        subscribeClient: subscribeClient as any,
+      });
+
+      const event = new CustomEvent("call.responded:uuid-123", {
+        detail: { type: "call.responded", id: "uuid-123", payload: { status: "ok" } },
+      }) as TestEvent;
+
+      eventTarget.dispatchEvent(event);
+
+      expect(publishClient.publish).toHaveBeenCalledTimes(1);
+      expect(publishClient.publish).toHaveBeenCalledWith(
+        "call.responded:uuid-123",
+        JSON.stringify({ type: "call.responded", id: "uuid-123", payload: { status: "ok" } }),
+      );
+    });
+
+    it("serializes the envelope detail using the default JSON serializer", () => {
+      const publishClient = createMockRedis();
+      const subscribeClient = createMockRedis();
+      const eventTarget = createRedisEventTarget<TestEvent>({
+        publishClient: publishClient as any,
+        subscribeClient: subscribeClient as any,
+      });
+
+      const envelope: EventEnvelope<"user.joined", { name: string }> = {
+        type: "user.joined",
+        id: "user-42",
+        payload: { name: "Alice" },
+      };
+
+      const event = new CustomEvent("user.joined:user-42", {
+        detail: envelope,
+      }) as TestEvent;
+
+      eventTarget.dispatchEvent(event);
+
+      expect(publishClient.publish).toHaveBeenCalledTimes(1);
+      const publishedMessage = publishClient.publications[0].message;
+      expect(JSON.parse(publishedMessage)).toEqual(envelope);
+    });
+
+    it("returns true from dispatchEvent", () => {
+      const publishClient = createMockRedis();
+      const subscribeClient = createMockRedis();
+      const eventTarget = createRedisEventTarget<TestEvent>({
+        publishClient: publishClient as any,
+        subscribeClient: subscribeClient as any,
+      });
+
+      const event = new CustomEvent("test.event:id1", {
+        detail: { type: "test.event", id: "id1", payload: null },
+      }) as TestEvent;
+
+      const result = eventTarget.dispatchEvent(event);
+      expect(result).toBe(true);
+    });
+  });
+
+  describe("addEventListener (subscribe path)", () => {
+    it("subscribes to Redis on the topic when first listener is added", () => {
+      const publishClient = createMockRedis();
+      const subscribeClient = createMockRedis();
+      const eventTarget = createRedisEventTarget<TestEvent>({
+        publishClient: publishClient as any,
+        subscribeClient: subscribeClient as any,
+      });
+
+      const listener = vi.fn();
+      eventTarget.addEventListener("message.sent:msg1", listener);
+
+      expect(subscribeClient.subscribe).toHaveBeenCalledTimes(1);
+      expect(subscribeClient.subscribe).toHaveBeenCalledWith("message.sent:msg1");
+    });
+
+    it("dispatches deserialized messages to local listeners", () => {
+      const publishClient = createMockRedis();
+      const subscribeClient = createMockRedis();
+      const eventTarget = createRedisEventTarget<TestEvent>({
+        publishClient: publishClient as any,
+        subscribeClient: subscribeClient as any,
+      });
+
+      const listener = vi.fn();
+      eventTarget.addEventListener("message.sent:msg1", listener);
+
+      const envelope: EventEnvelope = {
+        type: "message.sent",
+        id: "msg1",
+        payload: "hello world",
+      };
+      subscribeClient.simulateMessage("message.sent:msg1", JSON.stringify(envelope));
+
+      expect(listener).toHaveBeenCalledTimes(1);
+      const receivedEvent = listener.mock.calls[0][0] as TestEvent;
+      expect(receivedEvent.type).toBe("message.sent:msg1");
+      expect(receivedEvent.detail).toEqual(envelope);
+    });
+
+    it("ignores messages on channels with no registered listeners", () => {
+      const publishClient = createMockRedis();
+      const subscribeClient = createMockRedis();
+      const eventTarget = createRedisEventTarget<TestEvent>({
+        publishClient: publishClient as any,
+        subscribeClient: subscribeClient as any,
+      });
+
+      const listener = vi.fn();
+      eventTarget.addEventListener("topic:a", listener);
+
+      subscribeClient.simulateMessage("topic:b", JSON.stringify({ type: "topic", id: "b", payload: null }));
+
+      expect(listener).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("removeEventListener (unsubscribe path)", () => {
+    it("unsubscribes from Redis when the last listener for a topic is removed", () => {
+      const publishClient = createMockRedis();
+      const subscribeClient = createMockRedis();
+      const eventTarget = createRedisEventTarget<TestEvent>({
+        publishClient: publishClient as any,
+        subscribeClient: subscribeClient as any,
+      });
+
+      const listener = vi.fn();
+      eventTarget.addEventListener("topic:a", listener);
+
+      expect(subscribeClient.subscribe).toHaveBeenCalledTimes(1);
+
+      eventTarget.removeEventListener("topic:a", listener);
+
+      expect(subscribeClient.unsubscribe).toHaveBeenCalledTimes(1);
+      expect(subscribeClient.unsubscribe).toHaveBeenCalledWith("topic:a");
+    });
+
+    it("does not unsubscribe from Redis while other listeners remain on the same topic", () => {
+      const publishClient = createMockRedis();
+      const subscribeClient = createMockRedis();
+      const eventTarget = createRedisEventTarget<TestEvent>({
+        publishClient: publishClient as any,
+        subscribeClient: subscribeClient as any,
+      });
+
+      const listener1 = vi.fn();
+      const listener2 = vi.fn();
+      eventTarget.addEventListener("event:type1", listener1);
+      eventTarget.addEventListener("event:type1", listener2);
+
+      expect(subscribeClient.subscribe).toHaveBeenCalledTimes(1);
+
+      eventTarget.removeEventListener("event:type1", listener1);
+
+      expect(subscribeClient.unsubscribe).not.toHaveBeenCalled();
+
+      eventTarget.removeEventListener("event:type1", listener2);
+
+      expect(subscribeClient.unsubscribe).toHaveBeenCalledTimes(1);
+      expect(subscribeClient.unsubscribe).toHaveBeenCalledWith("event:type1");
+    });
+  });
+
+  describe("topic scoping", () => {
+    it("uses type:id strings as Redis channel names", () => {
+      const publishClient = createMockRedis();
+      const subscribeClient = createMockRedis();
+      const eventTarget = createRedisEventTarget<TestEvent>({
+        publishClient: publishClient as any,
+        subscribeClient: subscribeClient as any,
+      });
+
+      const listener = vi.fn();
+      eventTarget.addEventListener("call.responded:uuid-456", listener);
+
+      expect(subscribeClient.subscribe).toHaveBeenCalledWith("call.responded:uuid-456");
+
+      const event = new CustomEvent("call.responded:uuid-456", {
+        detail: { type: "call.responded", id: "uuid-456", payload: { ok: true } },
+      }) as TestEvent;
+
+      eventTarget.dispatchEvent(event);
+
+      expect(publishClient.publications[0].channel).toBe("call.responded:uuid-456");
+    });
+  });
+
+  describe("EventEnvelope serialization round-trip", () => {
+    it("round-trips full { type, id, payload } envelope through JSON", () => {
+      const publishClient = createMockRedis();
+      const subscribeClient = createMockRedis();
+      const eventTarget = createRedisEventTarget<TestEvent>({
+        publishClient: publishClient as any,
+        subscribeClient: subscribeClient as any,
+      });
+
+      const listener = vi.fn();
+      eventTarget.addEventListener("user.joined:user-99", listener);
+
+      const originalEnvelope: EventEnvelope<"user.joined", { name: string; role: string }> = {
+        type: "user.joined",
+        id: "user-99",
+        payload: { name: "Bob", role: "admin" },
+      };
+
+      const event = new CustomEvent("user.joined:user-99", {
+        detail: originalEnvelope,
+      }) as TestEvent;
+
+      eventTarget.dispatchEvent(event);
+
+      const publishedMessage = publishClient.publications[0].message;
+      subscribeClient.simulateMessage("user.joined:user-99", publishedMessage);
+
+      expect(listener).toHaveBeenCalledTimes(1);
+      const receivedDetail = (listener.mock.calls[0][0] as TestEvent).detail as EventEnvelope;
+      expect(receivedDetail).toEqual(originalEnvelope);
+      expect(receivedDetail.type).toBe("user.joined");
+      expect(receivedDetail.id).toBe("user-99");
+      expect(receivedDetail.payload).toEqual({ name: "Bob", role: "admin" });
+    });
+
+    it("round-trips envelope with null payload", () => {
+      const publishClient = createMockRedis();
+      const subscribeClient = createMockRedis();
+      const eventTarget = createRedisEventTarget<TestEvent>({
+        publishClient: publishClient as any,
+        subscribeClient: subscribeClient as any,
+      });
+
+      const listener = vi.fn();
+      eventTarget.addEventListener("ping:1", listener);
+
+      const envelope: EventEnvelope = { type: "ping", id: "1", payload: null };
+      subscribeClient.simulateMessage("ping:1", JSON.stringify(envelope));
+
+      expect(listener).toHaveBeenCalledTimes(1);
+      const receivedDetail = (listener.mock.calls[0][0] as TestEvent).detail as EventEnvelope;
+      expect(receivedDetail).toEqual(envelope);
+    });
+  });
+
+  describe("multiple listeners on the same topic", () => {
+    it("subscribes to Redis only once when multiple listeners are added to the same topic", () => {
+      const publishClient = createMockRedis();
+      const subscribeClient = createMockRedis();
+      const eventTarget = createRedisEventTarget<TestEvent>({
+        publishClient: publishClient as any,
+        subscribeClient: subscribeClient as any,
+      });
+
+      const listener1 = vi.fn();
+      const listener2 = vi.fn();
+      const listener3 = vi.fn();
+
+      eventTarget.addEventListener("topic:x", listener1);
+      eventTarget.addEventListener("topic:x", listener2);
+      eventTarget.addEventListener("topic:x", listener3);
+
+      expect(subscribeClient.subscribe).toHaveBeenCalledTimes(1);
+      expect(subscribeClient.subscribe).toHaveBeenCalledWith("topic:x");
+    });
+
+    it("delivers messages to all listeners on the same topic", () => {
+      const publishClient = createMockRedis();
+      const subscribeClient = createMockRedis();
+      const eventTarget = createRedisEventTarget<TestEvent>({
+        publishClient: publishClient as any,
+        subscribeClient: subscribeClient as any,
+      });
+
+      const listener1 = vi.fn();
+      const listener2 = vi.fn();
+      eventTarget.addEventListener("topic:x", listener1);
+      eventTarget.addEventListener("topic:x", listener2);
+
+      const envelope: EventEnvelope = { type: "topic", id: "x", payload: "data" };
+      subscribeClient.simulateMessage("topic:x", JSON.stringify(envelope));
+
+      expect(listener1).toHaveBeenCalledTimes(1);
+      expect(listener2).toHaveBeenCalledTimes(1);
+      expect((listener1.mock.calls[0][0] as TestEvent).detail).toEqual(envelope);
+      expect((listener2.mock.calls[0][0] as TestEvent).detail).toEqual(envelope);
+    });
+  });
+
+  describe("custom serializer", () => {
+    it("uses custom serializer for stringify and parse", () => {
+      const publishClient = createMockRedis();
+      const subscribeClient = createMockRedis();
+      const customSerializer = {
+        stringify: vi.fn((value: unknown) => JSON.stringify(value)),
+        parse: vi.fn((text: string) => JSON.parse(text)),
+      };
+
+      const eventTarget = createRedisEventTarget<TestEvent>({
+        publishClient: publishClient as any,
+        subscribeClient: subscribeClient as any,
+        serializer: customSerializer,
+      });
+
+      const listener = vi.fn();
+      eventTarget.addEventListener("custom:event1", listener);
+
+      const envelope: EventEnvelope = { type: "custom", id: "event1", payload: { key: "value" } };
+      const event = new CustomEvent("custom:event1", { detail: envelope }) as TestEvent;
+      eventTarget.dispatchEvent(event);
+
+      expect(customSerializer.stringify).toHaveBeenCalledTimes(1);
+      expect(customSerializer.stringify).toHaveBeenCalledWith(envelope);
+
+      const publishedMessage = publishClient.publications[0].message;
+      subscribeClient.simulateMessage("custom:event1", publishedMessage);
+
+      expect(customSerializer.parse).toHaveBeenCalledTimes(1);
+      expect(customSerializer.parse).toHaveBeenCalledWith(publishedMessage);
+      expect(listener).toHaveBeenCalledTimes(1);
+    });
+
+    it("allows non-JSON serializers to round-trip envelopes", () => {
+      const publishClient = createMockRedis();
+      const subscribeClient = createMockRedis();
+
+      const prefixSerializer = {
+        stringify: (value: unknown) => `PREFIX:${JSON.stringify(value)}`,
+        parse: (text: string) => JSON.parse(text.slice(7)),
+      };
+
+      const eventTarget = createRedisEventTarget<TestEvent>({
+        publishClient: publishClient as any,
+        subscribeClient: subscribeClient as any,
+        serializer: prefixSerializer,
+      });
+
+      const listener = vi.fn();
+      eventTarget.addEventListener("test:str", listener);
+
+      const envelope: EventEnvelope = { type: "test", id: "str", payload: 42 };
+      const event = new CustomEvent("test:str", { detail: envelope }) as TestEvent;
+      eventTarget.dispatchEvent(event);
+
+      const publishedMessage = publishClient.publications[0].message;
+      expect(publishedMessage).toBe(`PREFIX:${JSON.stringify(envelope)}`);
+
+      subscribeClient.simulateMessage("test:str", publishedMessage);
+
+      expect(listener).toHaveBeenCalledTimes(1);
+      const receivedDetail = (listener.mock.calls[0][0] as TestEvent).detail as EventEnvelope;
+      expect(receivedDetail).toEqual(envelope);
+    });
+  });
+
+  describe("channel prefix", () => {
+    it("publishes to prefixed channel when prefix is set", () => {
+      const publishClient = createMockRedis();
+      const subscribeClient = createMockRedis();
+      const eventTarget = createRedisEventTarget<TestEvent>({
+        publishClient: publishClient as any,
+        subscribeClient: subscribeClient as any,
+        prefix: "alk:events:",
+      });
+
+      const event = new CustomEvent("call.responded:uuid-123", {
+        detail: { type: "call.responded", id: "uuid-123", payload: { status: "ok" } },
+      }) as TestEvent;
+
+      eventTarget.dispatchEvent(event);
+
+      expect(publishClient.publish).toHaveBeenCalledWith(
+        "alk:events:call.responded:uuid-123",
+        expect.any(String),
+      );
+    });
+
+    it("subscribes to prefixed channel when prefix is set", () => {
+      const publishClient = createMockRedis();
+      const subscribeClient = createMockRedis();
+      const eventTarget = createRedisEventTarget<TestEvent>({
+        publishClient: publishClient as any,
+        subscribeClient: subscribeClient as any,
+        prefix: "alk:events:",
+      });
+
+      const listener = vi.fn();
+      eventTarget.addEventListener("call.responded:uuid-123", listener);
+
+      expect(subscribeClient.subscribe).toHaveBeenCalledWith("alk:events:call.responded:uuid-123");
+    });
+
+    it("unsubscribes from prefixed channel when prefix is set", () => {
+      const publishClient = createMockRedis();
+      const subscribeClient = createMockRedis();
+      const eventTarget = createRedisEventTarget<TestEvent>({
+        publishClient: publishClient as any,
+        subscribeClient: subscribeClient as any,
+        prefix: "alk:events:",
+      });
+
+      const listener = vi.fn();
+      eventTarget.addEventListener("call.responded:uuid-123", listener);
+      eventTarget.removeEventListener("call.responded:uuid-123", listener);
+
+      expect(subscribeClient.unsubscribe).toHaveBeenCalledWith("alk:events:call.responded:uuid-123");
+    });
+
+    it("delivers messages on prefixed channels to listeners", () => {
+      const publishClient = createMockRedis();
+      const subscribeClient = createMockRedis();
+      const eventTarget = createRedisEventTarget<TestEvent>({
+        publishClient: publishClient as any,
+        subscribeClient: subscribeClient as any,
+        prefix: "alk:events:",
+      });
+
+      const listener = vi.fn();
+      eventTarget.addEventListener("call.responded:uuid-123", listener);
+
+      const envelope: EventEnvelope = {
+        type: "call.responded",
+        id: "uuid-123",
+        payload: { status: "ok" },
+      };
+      subscribeClient.simulateMessage("alk:events:call.responded:uuid-123", JSON.stringify(envelope));
+
+      expect(listener).toHaveBeenCalledTimes(1);
+      expect((listener.mock.calls[0][0] as TestEvent).detail).toEqual(envelope);
+    });
+
+    it("ignores messages on non-prefixed channels when prefix is set", () => {
+      const publishClient = createMockRedis();
+      const subscribeClient = createMockRedis();
+      const eventTarget = createRedisEventTarget<TestEvent>({
+        publishClient: publishClient as any,
+        subscribeClient: subscribeClient as any,
+        prefix: "alk:events:",
+      });
+
+      const listener = vi.fn();
+      eventTarget.addEventListener("call.responded:uuid-123", listener);
+
+      subscribeClient.simulateMessage("call.responded:uuid-123", JSON.stringify({ type: "call.responded", id: "uuid-123", payload: null }));
+
+      expect(listener).not.toHaveBeenCalled();
+    });
+
+    it("defaults prefix to empty string", () => {
+      const publishClient = createMockRedis();
+      const subscribeClient = createMockRedis();
+      const eventTarget = createRedisEventTarget<TestEvent>({
+        publishClient: publishClient as any,
+        subscribeClient: subscribeClient as any,
+      });
+
+      const event = new CustomEvent("test:1", {
+        detail: { type: "test", id: "1", payload: null },
+      }) as TestEvent;
+
+      eventTarget.dispatchEvent(event);
+
+      expect(publishClient.publish).toHaveBeenCalledWith("test:1", expect.any(String));
+    });
+  });
+
+  describe("error handling", () => {
+    it("skips messages that fail to parse and logs a warning", () => {
+      const publishClient = createMockRedis();
+      const subscribeClient = createMockRedis();
+      const eventTarget = createRedisEventTarget<TestEvent>({
+        publishClient: publishClient as any,
+        subscribeClient: subscribeClient as any,
+      });
+
+      const listener = vi.fn();
+      eventTarget.addEventListener("topic:a", listener);
+
+      const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+
+      subscribeClient.simulateMessage("topic:a", "not valid json{{");
+
+      expect(listener).not.toHaveBeenCalled();
+      expect(warnSpy).toHaveBeenCalledTimes(1);
+      expect(warnSpy).toHaveBeenCalledWith(
+        'Failed to parse message on channel "topic:a": not valid json{{',
+      );
+
+      warnSpy.mockRestore();
+    });
+
+    it("continues delivering valid messages after a parse error", () => {
+      const publishClient = createMockRedis();
+      const subscribeClient = createMockRedis();
+      const eventTarget = createRedisEventTarget<TestEvent>({
+        publishClient: publishClient as any,
+        subscribeClient: subscribeClient as any,
+      });
+
+      const listener = vi.fn();
+      eventTarget.addEventListener("topic:a", listener);
+
+      const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+
+      subscribeClient.simulateMessage("topic:a", "broken{{{");
+
+      expect(listener).not.toHaveBeenCalled();
+
+      const envelope: EventEnvelope = { type: "topic", id: "a", payload: "good" };
+      subscribeClient.simulateMessage("topic:a", JSON.stringify(envelope));
+
+      expect(listener).toHaveBeenCalledTimes(1);
+      expect((listener.mock.calls[0][0] as TestEvent).detail).toEqual(envelope);
+
+      warnSpy.mockRestore();
+    });
+  });
+
+  describe("EventListenerObject support", () => {
+    it("addEventListener accepts EventListenerObject with handleEvent", () => {
+      const publishClient = createMockRedis();
+      const subscribeClient = createMockRedis();
+      const eventTarget = createRedisEventTarget<TestEvent>({
+        publishClient: publishClient as any,
+        subscribeClient: subscribeClient as any,
+      });
+
+      const handleEvent = vi.fn();
+      const listenerObject = { handleEvent };
+
+      eventTarget.addEventListener("obj:test", listenerObject);
+
+      const envelope: EventEnvelope = { type: "obj", id: "test", payload: true };
+      subscribeClient.simulateMessage("obj:test", JSON.stringify(envelope));
+
+      expect(handleEvent).toHaveBeenCalledTimes(1);
+    });
+
+    it("removeEventListener accepts EventListenerObject with handleEvent", () => {
+      const publishClient = createMockRedis();
+      const subscribeClient = createMockRedis();
+      const eventTarget = createRedisEventTarget<TestEvent>({
+        publishClient: publishClient as any,
+        subscribeClient: subscribeClient as any,
+      });
+
+      const handleEvent = vi.fn();
+      const listenerObject = { handleEvent };
+
+      eventTarget.addEventListener("obj:test2", listenerObject);
+      expect(subscribeClient.subscribe).toHaveBeenCalledWith("obj:test2");
+
+      eventTarget.removeEventListener("obj:test2", listenerObject);
+      expect(subscribeClient.unsubscribe).toHaveBeenCalledWith("obj:test2");
+    });
+  });
+
+  describe("close()", () => {
+    it("unsubscribes from all active channels", () => {
+      const publishClient = createMockRedis();
+      const subscribeClient = createMockRedis();
+      const eventTarget = createRedisEventTarget<TestEvent>({
+        publishClient: publishClient as any,
+        subscribeClient: subscribeClient as any,
+      });
+
+      const listener1 = vi.fn();
+      const listener2 = vi.fn();
+      eventTarget.addEventListener("topic:a", listener1);
+      eventTarget.addEventListener("topic:b", listener2);
+
+      eventTarget.close();
+
+      expect(subscribeClient.unsubscribe).toHaveBeenCalledWith("topic:a");
+      expect(subscribeClient.unsubscribe).toHaveBeenCalledWith("topic:b");
+    });
+
+    it("removes the message listener from subscribeClient", () => {
+      const publishClient = createMockRedis();
+      const subscribeClient = createMockRedis();
+      const eventTarget = createRedisEventTarget<TestEvent>({
+        publishClient: publishClient as any,
+        subscribeClient: subscribeClient as any,
+      });
+
+      eventTarget.close();
+
+      expect(subscribeClient.off).toHaveBeenCalledWith("message", expect.any(Function));
+    });
+
+    it("does not receive messages after close", () => {
+      const publishClient = createMockRedis();
+      const subscribeClient = createMockRedis();
+      const eventTarget = createRedisEventTarget<TestEvent>({
+        publishClient: publishClient as any,
+        subscribeClient: subscribeClient as any,
+      });
+
+      const listener = vi.fn();
+      eventTarget.addEventListener("topic:a", listener);
+
+      eventTarget.close();
+
+      const envelope: EventEnvelope = { type: "topic", id: "a", payload: "hello" };
+      subscribeClient.simulateMessage("topic:a", JSON.stringify(envelope));
+
+      expect(listener).not.toHaveBeenCalled();
+    });
+
+    it("is idempotent", () => {
+      const publishClient = createMockRedis();
+      const subscribeClient = createMockRedis();
+      const eventTarget = createRedisEventTarget<TestEvent>({
+        publishClient: publishClient as any,
+        subscribeClient: subscribeClient as any,
+      });
+
+      const listener = vi.fn();
+      eventTarget.addEventListener("topic:a", listener);
+
+      eventTarget.close();
+      eventTarget.close();
+
+      expect(subscribeClient.unsubscribe).toHaveBeenCalledTimes(1);
+    });
+
+    it("handles close with no subscriptions", () => {
+      const publishClient = createMockRedis();
+      const subscribeClient = createMockRedis();
+      const eventTarget = createRedisEventTarget<TestEvent>({
+        publishClient: publishClient as any,
+        subscribeClient: subscribeClient as any,
+      });
+
+      expect(() => eventTarget.close()).not.toThrow();
+    });
+
+    it("unsubscribes from prefixed channels correctly", () => {
+      const publishClient = createMockRedis();
+      const subscribeClient = createMockRedis();
+      const eventTarget = createRedisEventTarget<TestEvent>({
+        publishClient: publishClient as any,
+        subscribeClient: subscribeClient as any,
+        prefix: "alk:events:",
+      });
+
+      const listener = vi.fn();
+      eventTarget.addEventListener("topic:a", listener);
+
+      eventTarget.close();
+
+      expect(subscribeClient.unsubscribe).toHaveBeenCalledWith("alk:events:topic:a");
+    });
+  });
+});

test/event-target-websocket-client.test.ts

@@ -0,0 +1,811 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { createWebSocketClientEventTarget } from "../src/event-target-websocket-client.js";
+import type { EventEnvelope, TypedEvent } from "../src/types.js";
+
+type TestEvent = TypedEvent<string, EventEnvelope>;
+
+function createMockWebSocket() {
+  const sent: string[] = [];
+  let onmessageHandler: ((event: { data: string }) => void) | null = null;
+  let oncloseHandler: ((event: { code: number; reason: string }) => void) | null = null;
+
+  const ws = {
+    send: vi.fn((data: string) => {
+      sent.push(data);
+    }),
+    get onmessage() {
+      return onmessageHandler;
+    },
+    set onmessage(handler: ((event: { data: string }) => void) | null) {
+      onmessageHandler = handler;
+    },
+    get onclose() {
+      return oncloseHandler;
+    },
+    set onclose(handler: ((event: { code: number; reason: string }) => void) | null) {
+      oncloseHandler = handler;
+    },
+    sent,
+    simulateMessage(data: string) {
+      if (onmessageHandler) {
+        onmessageHandler({ data });
+      }
+    },
+    simulateClose(code = 1000, reason = "") {
+      if (oncloseHandler) {
+        oncloseHandler({ code, reason });
+      }
+      onmessageHandler = null;
+    },
+  };
+
+  Object.defineProperty(ws, "onmessage", {
+    get() {
+      return onmessageHandler;
+    },
+    set(handler: ((event: { data: string }) => void) | null) {
+      onmessageHandler = handler;
+    },
+  });
+
+  Object.defineProperty(ws, "onclose", {
+    get() {
+      return oncloseHandler;
+    },
+    set(handler: ((event: { code: number; reason: string }) => void) | null) {
+      oncloseHandler = handler;
+    },
+  });
+
+  return ws;
+}
+
+describe("createWebSocketClientEventTarget", () => {
+  describe("dispatchEvent (send path)", () => {
+    it("serializes envelope detail and calls ws.send", () => {
+      const ws = createMockWebSocket();
+      const eventTarget = createWebSocketClientEventTarget<TestEvent>(ws as any);
+
+      const envelope: EventEnvelope<"call.responded", { status: string }> = {
+        type: "call.responded",
+        id: "uuid-123",
+        payload: { status: "ok" },
+      };
+
+      const event = new CustomEvent("call.responded:uuid-123", {
+        detail: envelope,
+      }) as TestEvent;
+
+      eventTarget.dispatchEvent(event);
+
+      expect(ws.send).toHaveBeenCalledTimes(1);
+      expect(ws.send).toHaveBeenCalledWith(JSON.stringify(envelope));
+    });
+
+    it("returns true from dispatchEvent", () => {
+      const ws = createMockWebSocket();
+      const eventTarget = createWebSocketClientEventTarget<TestEvent>(ws as any);
+
+      const event = new CustomEvent("test:event", {
+        detail: { type: "test", id: "event", payload: null },
+      }) as TestEvent;
+
+      const result = eventTarget.dispatchEvent(event);
+      expect(result).toBe(true);
+    });
+
+    it("propagates ws.send() errors to caller", () => {
+      const ws = createMockWebSocket();
+      ws.send.mockImplementation(() => {
+        throw new Error("WebSocket is not open");
+      });
+      const eventTarget = createWebSocketClientEventTarget<TestEvent>(ws as any);
+
+      const event = new CustomEvent("test:event", {
+        detail: { type: "test", id: "event", payload: null },
+      }) as TestEvent;
+
+      expect(() => eventTarget.dispatchEvent(event)).toThrow("WebSocket is not open");
+    });
+  });
+
+  describe("addEventListener (subscribe path)", () => {
+    it("sends __subscribe control event on first listener for a topic", () => {
+      const ws = createMockWebSocket();
+      const eventTarget = createWebSocketClientEventTarget<TestEvent>(ws as any);
+
+      const listener = vi.fn();
+      eventTarget.addEventListener("call.responded:uuid-123", listener);
+
+      expect(ws.send).toHaveBeenCalledTimes(1);
+      expect(ws.send).toHaveBeenCalledWith(
+        JSON.stringify({
+          type: "__subscribe",
+          id: "",
+          payload: { topic: "call.responded:uuid-123" },
+        }),
+      );
+    });
+
+    it("sends __subscribe only once when multiple listeners are added for the same topic", () => {
+      const ws = createMockWebSocket();
+      const eventTarget = createWebSocketClientEventTarget<TestEvent>(ws as any);
+
+      const listener1 = vi.fn();
+      const listener2 = vi.fn();
+      eventTarget.addEventListener("message.sent:msg1", listener1);
+      eventTarget.addEventListener("message.sent:msg1", listener2);
+
+      expect(ws.send).toHaveBeenCalledTimes(1);
+    });
+
+    it("does not send __subscribe when callback is null", () => {
+      const ws = createMockWebSocket();
+      const eventTarget = createWebSocketClientEventTarget<TestEvent>(ws as any);
+
+      eventTarget.addEventListener("topic:a", null as any);
+
+      expect(ws.send).not.toHaveBeenCalled();
+    });
+
+    it("supports EventListenerObject with handleEvent", () => {
+      const ws = createMockWebSocket();
+      const eventTarget = createWebSocketClientEventTarget<TestEvent>(ws as any);
+
+      const handleEvent = vi.fn();
+      const listenerObject = { handleEvent };
+
+      eventTarget.addEventListener("obj:test", listenerObject);
+
+      expect(ws.send).toHaveBeenCalledTimes(1);
+      expect(ws.send).toHaveBeenCalledWith(
+        JSON.stringify({
+          type: "__subscribe",
+          id: "",
+          payload: { topic: "obj:test" },
+        }),
+      );
+    });
+  });
+
+  describe("removeEventListener (unsubscribe path)", () => {
+    it("sends __unsubscribe when the last listener for a topic is removed", () => {
+      const ws = createMockWebSocket();
+      const eventTarget = createWebSocketClientEventTarget<TestEvent>(ws as any);
+
+      const listener = vi.fn();
+      eventTarget.addEventListener("topic:a", listener);
+
+      expect(ws.send).toHaveBeenCalledTimes(1);
+
+      eventTarget.removeEventListener("topic:a", listener);
+
+      expect(ws.send).toHaveBeenCalledTimes(2);
+      expect(ws.send).toHaveBeenCalledWith(
+        JSON.stringify({
+          type: "__unsubscribe",
+          id: "",
+          payload: { topic: "topic:a" },
+        }),
+      );
+    });
+
+    it("does not send __unsubscribe while other listeners remain for the same topic", () => {
+      const ws = createMockWebSocket();
+      const eventTarget = createWebSocketClientEventTarget<TestEvent>(ws as any);
+
+      const listener1 = vi.fn();
+      const listener2 = vi.fn();
+      eventTarget.addEventListener("event:type1", listener1);
+      eventTarget.addEventListener("event:type1", listener2);
+
+      expect(ws.send).toHaveBeenCalledTimes(1);
+
+      eventTarget.removeEventListener("event:type1", listener1);
+
+      expect(ws.send).toHaveBeenCalledTimes(1);
+
+      eventTarget.removeEventListener("event:type1", listener2);
+
+      expect(ws.send).toHaveBeenCalledTimes(2);
+      expect(ws.send).toHaveBeenCalledWith(
+        JSON.stringify({
+          type: "__unsubscribe",
+          id: "",
+          payload: { topic: "event:type1" },
+        }),
+      );
+    });
+
+    it("does not send __unsubscribe when removing a callback that was never registered", () => {
+      const ws = createMockWebSocket();
+      const eventTarget = createWebSocketClientEventTarget<TestEvent>(ws as any);
+
+      const listener1 = vi.fn();
+      eventTarget.addEventListener("topic:a", listener1);
+
+      const unregisteredListener = vi.fn();
+      eventTarget.removeEventListener("topic:a", unregisteredListener);
+
+      expect(ws.send).toHaveBeenCalledTimes(1);
+    });
+
+    it("does not send __unsubscribe when callback is null", () => {
+      const ws = createMockWebSocket();
+      const eventTarget = createWebSocketClientEventTarget<TestEvent>(ws as any);
+
+      eventTarget.addEventListener("topic:a", null as any);
+
+      eventTarget.removeEventListener("topic:a", null as any);
+
+      expect(ws.send).not.toHaveBeenCalled();
+    });
+
+    it("supports EventListenerObject with handleEvent for removal", () => {
+      const ws = createMockWebSocket();
+      const eventTarget = createWebSocketClientEventTarget<TestEvent>(ws as any);
+
+      const handleEvent = vi.fn();
+      const listenerObject = { handleEvent };
+
+      eventTarget.addEventListener("obj:test", listenerObject);
+      expect(ws.send).toHaveBeenCalledWith(
+        JSON.stringify({
+          type: "__subscribe",
+          id: "",
+          payload: { topic: "obj:test" },
+        }),
+      );
+
+      eventTarget.removeEventListener("obj:test", listenerObject);
+      expect(ws.send).toHaveBeenCalledWith(
+        JSON.stringify({
+          type: "__unsubscribe",
+          id: "",
+          payload: { topic: "obj:test" },
+        }),
+      );
+    });
+  });
+
+  describe("receive path (ws.onmessage)", () => {
+    it("parses envelope, creates CustomEvent with type:id topic, and dispatches to listeners", () => {
+      const ws = createMockWebSocket();
+      const eventTarget = createWebSocketClientEventTarget<TestEvent>(ws as any);
+
+      const listener = vi.fn();
+      eventTarget.addEventListener("message.sent:msg1", listener);
+
+      const envelope: EventEnvelope = {
+        type: "message.sent",
+        id: "msg1",
+        payload: "hello world",
+      };
+      ws.simulateMessage(JSON.stringify(envelope));
+
+      expect(listener).toHaveBeenCalledTimes(1);
+      const receivedEvent = listener.mock.calls[0][0] as TestEvent;
+      expect(receivedEvent.type).toBe("message.sent:msg1");
+      expect(receivedEvent.detail).toEqual(envelope);
+    });
+
+    it("delivers messages to all listeners on the same topic", () => {
+      const ws = createMockWebSocket();
+      const eventTarget = createWebSocketClientEventTarget<TestEvent>(ws as any);
+
+      const listener1 = vi.fn();
+      const listener2 = vi.fn();
+      eventTarget.addEventListener("topic:x", listener1);
+      eventTarget.addEventListener("topic:x", listener2);
+
+      const envelope: EventEnvelope = { type: "topic", id: "x", payload: "data" };
+      ws.simulateMessage(JSON.stringify(envelope));
+
+      expect(listener1).toHaveBeenCalledTimes(1);
+      expect(listener2).toHaveBeenCalledTimes(1);
+      expect((listener1.mock.calls[0][0] as TestEvent).detail).toEqual(envelope);
+      expect((listener2.mock.calls[0][0] as TestEvent).detail).toEqual(envelope);
+    });
+
+    it("ignores messages for topics with no registered listeners", () => {
+      const ws = createMockWebSocket();
+      const eventTarget = createWebSocketClientEventTarget<TestEvent>(ws as any);
+
+      const listener = vi.fn();
+      eventTarget.addEventListener("topic:a", listener);
+
+      const envelope: EventEnvelope = { type: "other", id: "b", payload: null };
+      ws.simulateMessage(JSON.stringify(envelope));
+
+      expect(listener).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("malformed JSON handling", () => {
+    it("silently ignores malformed JSON and logs a warning", () => {
+      const ws = createMockWebSocket();
+      const eventTarget = createWebSocketClientEventTarget<TestEvent>(ws as any);
+
+      const listener = vi.fn();
+      eventTarget.addEventListener("topic:a", listener);
+
+      const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+
+      ws.simulateMessage("not valid json{{");
+
+      expect(listener).not.toHaveBeenCalled();
+      expect(warnSpy).toHaveBeenCalledTimes(1);
+      expect(warnSpy).toHaveBeenCalledWith(
+        expect.stringContaining("Failed to parse WebSocket message"),
+      );
+
+      warnSpy.mockRestore();
+    });
+
+    it("continues delivering valid messages after a parse error", () => {
+      const ws = createMockWebSocket();
+      const eventTarget = createWebSocketClientEventTarget<TestEvent>(ws as any);
+
+      const listener = vi.fn();
+      eventTarget.addEventListener("topic:a", listener);
+
+      const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+
+      ws.simulateMessage("broken{{{");
+
+      expect(listener).not.toHaveBeenCalled();
+
+      const envelope: EventEnvelope = { type: "topic", id: "a", payload: "good" };
+      ws.simulateMessage(JSON.stringify(envelope));
+
+      expect(listener).toHaveBeenCalledTimes(1);
+      expect((listener.mock.calls[0][0] as TestEvent).detail).toEqual(envelope);
+
+      warnSpy.mockRestore();
+    });
+  });
+
+  describe("control events from server", () => {
+    it("silently ignores __subscribe control events received from server", () => {
+      const ws = createMockWebSocket();
+      const eventTarget = createWebSocketClientEventTarget<TestEvent>(ws as any);
+
+      const listener = vi.fn();
+      eventTarget.addEventListener("topic:a", listener);
+
+      ws.simulateMessage(JSON.stringify({
+        type: "__subscribe",
+        id: "",
+        payload: { topic: "topic:a" },
+      }));
+
+      expect(listener).not.toHaveBeenCalled();
+    });
+
+    it("silently ignores __unsubscribe control events received from server", () => {
+      const ws = createMockWebSocket();
+      const eventTarget = createWebSocketClientEventTarget<TestEvent>(ws as any);
+
+      const listener = vi.fn();
+      eventTarget.addEventListener("topic:a", listener);
+
+      ws.simulateMessage(JSON.stringify({
+        type: "__unsubscribe",
+        id: "",
+        payload: { topic: "topic:a" },
+      }));
+
+      expect(listener).not.toHaveBeenCalled();
+    });
+
+    it("ignores any event type starting with __", () => {
+      const ws = createMockWebSocket();
+      const eventTarget = createWebSocketClientEventTarget<TestEvent>(ws as any);
+
+      const listener = vi.fn();
+      eventTarget.addEventListener("__custom:thing", listener);
+
+      ws.simulateMessage(JSON.stringify({
+        type: "__custom",
+        id: "thing",
+        payload: null,
+      }));
+
+      expect(listener).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("EventEnvelope round-trip", () => {
+    it("round-trips full { type, id, payload } envelope through send and receive", () => {
+      const ws = createMockWebSocket();
+      const eventTarget = createWebSocketClientEventTarget<TestEvent>(ws as any);
+
+      const listener = vi.fn();
+      eventTarget.addEventListener("user.joined:user-99", listener);
+
+      const originalEnvelope: EventEnvelope<"user.joined", { name: string; role: string }> = {
+        type: "user.joined",
+        id: "user-99",
+        payload: { name: "Bob", role: "admin" },
+      };
+
+      const event = new CustomEvent("user.joined:user-99", {
+        detail: originalEnvelope,
+      }) as TestEvent;
+
+      eventTarget.dispatchEvent(event);
+
+      const dispatchedData = ws.sent[1];
+      expect(dispatchedData).toBe(JSON.stringify(originalEnvelope));
+
+      const sentData = dispatchedData;
+
+      ws.simulateMessage(sentData);
+
+      expect(listener).toHaveBeenCalledTimes(1);
+      const receivedDetail = (listener.mock.calls[0][0] as TestEvent).detail as EventEnvelope;
+      expect(receivedDetail).toEqual(originalEnvelope);
+      expect(receivedDetail.type).toBe("user.joined");
+      expect(receivedDetail.id).toBe("user-99");
+      expect(receivedDetail.payload).toEqual({ name: "Bob", role: "admin" });
+    });
+
+    it("round-trips envelope with null payload", () => {
+      const ws = createMockWebSocket();
+      const eventTarget = createWebSocketClientEventTarget<TestEvent>(ws as any);
+
+      const listener = vi.fn();
+      eventTarget.addEventListener("ping:1", listener);
+
+      const envelope: EventEnvelope = { type: "ping", id: "1", payload: null };
+      ws.simulateMessage(JSON.stringify(envelope));
+
+      expect(listener).toHaveBeenCalledTimes(1);
+      const receivedDetail = (listener.mock.calls[0][0] as TestEvent).detail as EventEnvelope;
+      expect(receivedDetail).toEqual(envelope);
+    });
+  });
+
+  describe("topic scoping", () => {
+    it("forms topic from envelope type and id fields", () => {
+      const ws = createMockWebSocket();
+      const eventTarget = createWebSocketClientEventTarget<TestEvent>(ws as any);
+
+      const listener = vi.fn();
+      eventTarget.addEventListener("user.action:abc-123", listener);
+
+      const envelope: EventEnvelope = {
+        type: "user.action",
+        id: "abc-123",
+        payload: { done: true },
+      };
+      ws.simulateMessage(JSON.stringify(envelope));
+
+      expect(listener).toHaveBeenCalledTimes(1);
+      expect((listener.mock.calls[0][0] as TestEvent).type).toBe("user.action:abc-123");
+    });
+
+    it("does not match when type differs even if id is the same", () => {
+      const ws = createMockWebSocket();
+      const eventTarget = createWebSocketClientEventTarget<TestEvent>(ws as any);
+
+      const listener = vi.fn();
+      eventTarget.addEventListener("user.created:id1", listener);
+
+      ws.simulateMessage(JSON.stringify({ type: "user.deleted", id: "id1", payload: null }));
+
+      expect(listener).not.toHaveBeenCalled();
+    });
+
+    it("does not match when id differs even if type is the same", () => {
+      const ws = createMockWebSocket();
+      const eventTarget = createWebSocketClientEventTarget<TestEvent>(ws as any);
+
+      const listener = vi.fn();
+      eventTarget.addEventListener("event:alpha", listener);
+
+      ws.simulateMessage(JSON.stringify({ type: "event", id: "beta", payload: null }));
+
+      expect(listener).not.toHaveBeenCalled();
+    });
+
+    it("forms topic with undefined id as 'type:undefined' which does not match 'type:'", () => {
+      const ws = createMockWebSocket();
+      const eventTarget = createWebSocketClientEventTarget<TestEvent>(ws as any);
+
+      const listener = vi.fn();
+      eventTarget.addEventListener("ping:", listener);
+
+      ws.simulateMessage(JSON.stringify({ type: "ping", payload: "hello" }));
+
+      expect(listener).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("envelope validation on receive", () => {
+    it("ignores messages where type is not a string", () => {
+      const ws = createMockWebSocket();
+      const eventTarget = createWebSocketClientEventTarget<TestEvent>(ws as any);
+
+      const listener = vi.fn();
+      eventTarget.addEventListener("topic:a", listener);
+
+      ws.simulateMessage(JSON.stringify({ type: 123, id: "a", payload: null }));
+
+      expect(listener).not.toHaveBeenCalled();
+    });
+
+    it("ignores messages where type is undefined", () => {
+      const ws = createMockWebSocket();
+      const eventTarget = createWebSocketClientEventTarget<TestEvent>(ws as any);
+
+      const listener = vi.fn();
+      eventTarget.addEventListener("topic:a", listener);
+
+      ws.simulateMessage(JSON.stringify({ id: "a", payload: null }));
+
+      expect(listener).not.toHaveBeenCalled();
+    });
+
+    it("ignores messages where type is null", () => {
+      const ws = createMockWebSocket();
+      const eventTarget = createWebSocketClientEventTarget<TestEvent>(ws as any);
+
+      const listener = vi.fn();
+      eventTarget.addEventListener("topic:a", listener);
+
+      ws.simulateMessage(JSON.stringify({ type: null, id: "a", payload: null }));
+
+      expect(listener).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("reconnection", () => {
+    it("restores subscriptions on a new event target with a new WebSocket", () => {
+      const ws1 = createMockWebSocket();
+      const eventTarget1 = createWebSocketClientEventTarget<TestEvent>(ws1 as any);
+
+      const listener1 = vi.fn();
+      eventTarget1.addEventListener("order.created:ord-1", listener1);
+      expect(ws1.send).toHaveBeenCalledTimes(1);
+
+      ws1.simulateClose();
+
+      const ws2 = createMockWebSocket();
+      const eventTarget2 = createWebSocketClientEventTarget<TestEvent>(ws2 as any);
+
+      const listener2 = vi.fn();
+      eventTarget2.addEventListener("order.created:ord-1", listener2);
+      expect(ws2.send).toHaveBeenCalledTimes(1);
+      expect(ws2.send).toHaveBeenCalledWith(
+        JSON.stringify({ type: "__subscribe", id: "", payload: { topic: "order.created:ord-1" } }),
+      );
+
+      const envelope: EventEnvelope = { type: "order.created", id: "ord-1", payload: { item: "book" } };
+      ws2.simulateMessage(JSON.stringify(envelope));
+
+      expect(listener2).toHaveBeenCalledTimes(1);
+      expect((listener2.mock.calls[0][0] as TestEvent).detail).toEqual(envelope);
+    });
+
+    it("does not receive messages on old connection after reconnect", () => {
+      const ws1 = createMockWebSocket();
+      const eventTarget1 = createWebSocketClientEventTarget<TestEvent>(ws1 as any);
+
+      const listener1 = vi.fn();
+      eventTarget1.addEventListener("chat.msg:1", listener1);
+
+      ws1.simulateClose();
+
+      const ws2 = createMockWebSocket();
+      const eventTarget2 = createWebSocketClientEventTarget<TestEvent>(ws2 as any);
+
+      const listener2 = vi.fn();
+      eventTarget2.addEventListener("chat.msg:1", listener2);
+
+      ws1.simulateMessage(JSON.stringify({ type: "chat.msg", id: "1", payload: "stale" }));
+
+      expect(listener1).not.toHaveBeenCalled();
+      expect(listener2).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("connection close", () => {
+    it("does not send __unsubscribe on close since lifecycle is caller-managed", () => {
+      const ws = createMockWebSocket();
+      const eventTarget = createWebSocketClientEventTarget<TestEvent>(ws as any);
+
+      const listener = vi.fn();
+      eventTarget.addEventListener("topic:a", listener);
+
+      expect(ws.send).toHaveBeenCalledTimes(1);
+
+      ws.simulateClose();
+
+      expect(ws.send).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe("close()", () => {
+    it("sends __unsubscribe for all active subscriptions", () => {
+      const ws = createMockWebSocket();
+      const eventTarget = createWebSocketClientEventTarget<TestEvent>(ws as any);
+
+      const listener1 = vi.fn();
+      const listener2 = vi.fn();
+      eventTarget.addEventListener("topic:a", listener1);
+      eventTarget.addEventListener("topic:b", listener2);
+
+      (ws.send as ReturnType<typeof vi.fn>).mockClear();
+
+      eventTarget.close();
+
+      const sent = ws.sent.map((s: string) => JSON.parse(s));
+      const unsubscribes = sent.filter((e: any) => e.type === "__unsubscribe");
+      expect(unsubscribes).toHaveLength(2);
+      const topics = unsubscribes.map((e: any) => e.payload.topic);
+      expect(topics).toContain("topic:a");
+      expect(topics).toContain("topic:b");
+    });
+
+    it("restores original onmessage handler", () => {
+      const ws = createMockWebSocket();
+      const originalOnmessage = vi.fn();
+      ws.onmessage = originalOnmessage;
+
+      const eventTarget = createWebSocketClientEventTarget<TestEvent>(ws as any);
+      expect(ws.onmessage).not.toBe(originalOnmessage);
+
+      eventTarget.close();
+
+      expect(ws.onmessage).toBe(originalOnmessage);
+    });
+
+    it("does not deliver messages after close", () => {
+      const ws = createMockWebSocket();
+      const eventTarget = createWebSocketClientEventTarget<TestEvent>(ws as any);
+
+      const listener = vi.fn();
+      eventTarget.addEventListener("topic:a", listener);
+
+      eventTarget.close();
+
+      const envelope: EventEnvelope = { type: "topic", id: "a", payload: "hello" };
+      ws.simulateMessage(JSON.stringify(envelope));
+
+      expect(listener).not.toHaveBeenCalled();
+    });
+
+    it("does not send __subscribe after close", () => {
+      const ws = createMockWebSocket();
+      const eventTarget = createWebSocketClientEventTarget<TestEvent>(ws as any);
+      eventTarget.close();
+
+      const listener = vi.fn();
+      eventTarget.addEventListener("topic:a", listener);
+
+      expect(ws.send).not.toHaveBeenCalledWith(
+        expect.stringContaining("__subscribe"),
+      );
+    });
+
+    it("dispatchEvent returns true but does not send after close", () => {
+      const ws = createMockWebSocket();
+      const eventTarget = createWebSocketClientEventTarget<TestEvent>(ws as any);
+      eventTarget.close();
+
+      (ws.send as ReturnType<typeof vi.fn>).mockClear();
+
+      const event = new CustomEvent("test:event", {
+        detail: { type: "test", id: "event", payload: null },
+      }) as TestEvent;
+
+      const result = eventTarget.dispatchEvent(event);
+      expect(result).toBe(true);
+      expect(ws.send).not.toHaveBeenCalled();
+    });
+
+    it("is idempotent", () => {
+      const ws = createMockWebSocket();
+      const eventTarget = createWebSocketClientEventTarget<TestEvent>(ws as any);
+
+      const listener = vi.fn();
+      eventTarget.addEventListener("topic:a", listener);
+
+      eventTarget.close();
+      eventTarget.close();
+
+      const sentCalls = ws.sent.filter((s: string) => JSON.parse(s).type === "__unsubscribe");
+      expect(sentCalls).toHaveLength(1);
+    });
+  });
+
+  describe("dispatchEvent (send path) edge cases", () => {
+    it("sends envelope with null payload", () => {
+      const ws = createMockWebSocket();
+      const eventTarget = createWebSocketClientEventTarget<TestEvent>(ws as any);
+
+      const event = new CustomEvent("notify:1", {
+        detail: { type: "notify", id: "1", payload: null },
+      }) as TestEvent;
+
+      eventTarget.dispatchEvent(event);
+
+      expect(ws.send).toHaveBeenCalledTimes(1);
+      const sent = JSON.parse(ws.sent[0]);
+      expect(sent.type).toBe("notify");
+      expect(sent.id).toBe("1");
+      expect(sent.payload).toBeNull();
+    });
+
+    it("sends multiple events in order", () => {
+      const ws = createMockWebSocket();
+      const eventTarget = createWebSocketClientEventTarget<TestEvent>(ws as any);
+
+      const event1 = new CustomEvent("a:1", {
+        detail: { type: "a", id: "1", payload: "first" },
+      }) as TestEvent;
+      const event2 = new CustomEvent("b:2", {
+        detail: { type: "b", id: "2", payload: "second" },
+      }) as TestEvent;
+
+      eventTarget.dispatchEvent(event1);
+      eventTarget.dispatchEvent(event2);
+
+      expect(ws.sent).toHaveLength(2);
+      expect(JSON.parse(ws.sent[0])).toEqual({ type: "a", id: "1", payload: "first" });
+      expect(JSON.parse(ws.sent[1])).toEqual({ type: "b", id: "2", payload: "second" });
+    });
+  });
+
+  describe("subscription reference counting", () => {
+    it("re-sends __subscribe after all listeners removed and a new one added", () => {
+      const ws = createMockWebSocket();
+      const eventTarget = createWebSocketClientEventTarget<TestEvent>(ws as any);
+
+      const listener1 = vi.fn();
+      eventTarget.addEventListener("topic:a", listener1);
+      expect(ws.send).toHaveBeenCalledTimes(1);
+
+      eventTarget.removeEventListener("topic:a", listener1);
+      expect(ws.send).toHaveBeenCalledTimes(2);
+
+      const listener2 = vi.fn();
+      eventTarget.addEventListener("topic:a", listener2);
+      expect(ws.send).toHaveBeenCalledTimes(3);
+
+      expect(ws.send).toHaveBeenNthCalledWith(1,
+        JSON.stringify({ type: "__subscribe", id: "", payload: { topic: "topic:a" } }),
+      );
+      expect(ws.send).toHaveBeenNthCalledWith(2,
+        JSON.stringify({ type: "__unsubscribe", id: "", payload: { topic: "topic:a" } }),
+      );
+      expect(ws.send).toHaveBeenNthCalledWith(3,
+        JSON.stringify({ type: "__subscribe", id: "", payload: { topic: "topic:a" } }),
+      );
+    });
+
+    it("tracks separate topics independently", () => {
+      const ws = createMockWebSocket();
+      const eventTarget = createWebSocketClientEventTarget<TestEvent>(ws as any);
+
+      const listenerA = vi.fn();
+      const listenerB = vi.fn();
+      eventTarget.addEventListener("topic:a", listenerA);
+      eventTarget.addEventListener("topic:b", listenerB);
+
+      expect(ws.send).toHaveBeenCalledTimes(2);
+
+      eventTarget.removeEventListener("topic:a", listenerA);
+      expect(ws.send).toHaveBeenCalledTimes(3);
+
+      expect(ws.send).toHaveBeenNthCalledWith(3,
+        JSON.stringify({ type: "__unsubscribe", id: "", payload: { topic: "topic:a" } }),
+      );
+
+      const listenerB2 = vi.fn();
+      eventTarget.addEventListener("topic:b", listenerB2);
+      expect(ws.send).toHaveBeenCalledTimes(3);
+    });
+  });
+});

test/event-target-websocket-server.test.ts

@@ -0,0 +1,908 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { createWebSocketServerEventTarget } from "../src/event-target-websocket-server.js";
+import type { WebSocketLike, SpokeEventTarget } from "../src/event-target-websocket-server.js";
+import type { EventEnvelope, TypedEvent } from "../src/types.js";
+
+type TestEvent = TypedEvent<string, EventEnvelope>;
+
+function createMockWebSocket(): WebSocketLike & {
+  sent: string[];
+  simulateMessage: (data: string) => void;
+  simulateClose: (code?: number, reason?: string) => void;
+} {
+  let onmessageHandler: ((ev: { data: string }) => void) | null = null;
+  let oncloseHandler: ((ev: { code: number; reason?: string }) => void) | null = null;
+
+  const ws = {
+    bufferedAmount: 0,
+    sent: [] as string[],
+    send: vi.fn((data: string) => {
+      ws.sent.push(data);
+    }) as any,
+    close: vi.fn() as any,
+    get onmessage() {
+      return onmessageHandler;
+    },
+    set onmessage(handler: ((ev: { data: string }) => void) | null) {
+      onmessageHandler = handler;
+    },
+    get onclose() {
+      return oncloseHandler;
+    },
+    set onclose(handler: ((ev: { code: number; reason?: string }) => void) | null) {
+      oncloseHandler = handler;
+    },
+    simulateMessage(data: string) {
+      if (onmessageHandler) {
+        onmessageHandler({ data });
+      }
+    },
+    simulateClose(code: number = 1000, reason?: string) {
+      if (oncloseHandler) {
+        oncloseHandler({ code, reason });
+      }
+    },
+  };
+
+  Object.defineProperty(ws, "onmessage", {
+    get() {
+      return onmessageHandler;
+    },
+    set(handler: ((ev: { data: string }) => void) | null) {
+      onmessageHandler = handler;
+    },
+  });
+
+  Object.defineProperty(ws, "onclose", {
+    get() {
+      return oncloseHandler;
+    },
+    set(handler: ((ev: { code: number; reason?: string }) => void) | null) {
+      oncloseHandler = handler;
+    },
+  });
+
+  return ws;
+}
+
+describe("createWebSocketServerEventTarget", () => {
+  describe("addConnection", () => {
+    it("sets up onmessage and onclose handlers on the WebSocket", () => {
+      const server = createWebSocketServerEventTarget<TestEvent>();
+      const ws = createMockWebSocket();
+
+      expect(ws.onmessage).toBeNull();
+      expect(ws.onclose).toBeNull();
+
+      server.addConnection(ws as any);
+
+      expect(ws.onmessage).not.toBeNull();
+      expect(ws.onclose).not.toBeNull();
+    });
+
+    it("calls onConnection callback when a new connection is added", () => {
+      const onConnection = vi.fn();
+      const server = createWebSocketServerEventTarget<TestEvent>({ onConnection });
+      const ws = createMockWebSocket();
+
+      server.addConnection(ws as any);
+
+      expect(onConnection).toHaveBeenCalledTimes(1);
+      expect(onConnection).toHaveBeenCalledWith(expect.any(Object), ws);
+      const [spoke] = onConnection.mock.calls[0];
+      expect(spoke).toHaveProperty("addEventListener");
+      expect(spoke).toHaveProperty("removeEventListener");
+      expect(spoke).toHaveProperty("dispatchEvent");
+      expect(spoke).toHaveProperty("ws");
+    });
+
+    it("does not add the same connection twice", () => {
+      const onConnection = vi.fn();
+      const server = createWebSocketServerEventTarget<TestEvent>({ onConnection });
+      const ws = createMockWebSocket();
+
+      server.addConnection(ws as any);
+      server.addConnection(ws as any);
+
+      expect(onConnection).toHaveBeenCalledTimes(1);
+    });
+
+    it("preserves original onclose handler", () => {
+      const originalOnclose = vi.fn();
+      const server = createWebSocketServerEventTarget<TestEvent>();
+      const ws = createMockWebSocket();
+      ws.onclose = originalOnclose;
+
+      server.addConnection(ws as any);
+      ws.simulateClose(1000);
+
+      expect(originalOnclose).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe("removeConnection", () => {
+    it("cleans up subscription maps when a connection is removed", () => {
+      const server = createWebSocketServerEventTarget<TestEvent>();
+      const ws = createMockWebSocket();
+
+      server.addConnection(ws as any);
+      ws.simulateMessage(JSON.stringify({ type: "__subscribe", id: "", payload: { topic: "chat:room1" } }));
+
+      server.removeConnection(ws as any);
+
+      const envelope: EventEnvelope = { type: "chat", id: "room1", payload: "hello" };
+      const event = new CustomEvent("chat:room1", { detail: envelope }) as TestEvent;
+      server.dispatchEvent(event);
+
+      expect(ws.send).not.toHaveBeenCalledWith(JSON.stringify(envelope));
+    });
+
+    it("calls onDisconnection callback when a connection is removed", () => {
+      const onDisconnection = vi.fn();
+      const server = createWebSocketServerEventTarget<TestEvent>({ onDisconnection });
+      const ws = createMockWebSocket();
+
+      server.addConnection(ws as any);
+      server.removeConnection(ws as any);
+
+      expect(onDisconnection).toHaveBeenCalledTimes(1);
+      expect(onDisconnection).toHaveBeenCalledWith(expect.any(Object), ws);
+    });
+
+    it("does not close the WebSocket", () => {
+      const server = createWebSocketServerEventTarget<TestEvent>();
+      const ws = createMockWebSocket();
+
+      server.addConnection(ws as any);
+      server.removeConnection(ws as any);
+
+      expect(ws.close).not.toHaveBeenCalled();
+    });
+
+    it("restores original onmessage and onclose handlers", () => {
+      const originalOnmessage = vi.fn();
+      const server = createWebSocketServerEventTarget<TestEvent>();
+      const ws = createMockWebSocket();
+      ws.onmessage = originalOnmessage;
+
+      server.addConnection(ws as any);
+      expect(ws.onmessage).not.toBe(originalOnmessage);
+
+      server.removeConnection(ws as any);
+      expect(ws.onmessage).toBe(originalOnmessage);
+    });
+  });
+
+  describe("automatic cleanup on close", () => {
+    it("calls removeConnection automatically when WebSocket closes", () => {
+      const onDisconnection = vi.fn();
+      const server = createWebSocketServerEventTarget<TestEvent>({ onDisconnection });
+      const ws = createMockWebSocket();
+
+      server.addConnection(ws as any);
+      ws.simulateClose(1000);
+
+      expect(onDisconnection).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe("subscription tracking (__subscribe / __unsubscribe)", () => {
+    it("adds connection to topic subscriber set on __subscribe", () => {
+      const server = createWebSocketServerEventTarget<TestEvent>();
+      const ws = createMockWebSocket();
+
+      server.addConnection(ws as any);
+      ws.simulateMessage(JSON.stringify({ type: "__subscribe", id: "", payload: { topic: "chat:room1" } }));
+
+      const envelope: EventEnvelope = { type: "chat", id: "room1", payload: "hello" };
+      const event = new CustomEvent("chat:room1", { detail: envelope }) as TestEvent;
+      server.dispatchEvent(event);
+
+      expect(ws.send).toHaveBeenCalledWith(JSON.stringify(envelope));
+    });
+
+    it("is idempotent for duplicate __subscribe", () => {
+      const server = createWebSocketServerEventTarget<TestEvent>();
+      const ws = createMockWebSocket();
+
+      server.addConnection(ws as any);
+      ws.simulateMessage(JSON.stringify({ type: "__subscribe", id: "", payload: { topic: "chat:room1" } }));
+      ws.simulateMessage(JSON.stringify({ type: "__subscribe", id: "", payload: { topic: "chat:room1" } }));
+
+      const envelope: EventEnvelope = { type: "chat", id: "room1", payload: "hello" };
+      const event = new CustomEvent("chat:room1", { detail: envelope }) as TestEvent;
+      server.dispatchEvent(event);
+
+      expect(ws.send).toHaveBeenCalledTimes(1);
+    });
+
+    it("removes connection from topic subscriber set on __unsubscribe", () => {
+      const server = createWebSocketServerEventTarget<TestEvent>();
+      const ws = createMockWebSocket();
+
+      server.addConnection(ws as any);
+      ws.simulateMessage(JSON.stringify({ type: "__subscribe", id: "", payload: { topic: "chat:room1" } }));
+
+      ws.simulateMessage(JSON.stringify({ type: "__unsubscribe", id: "", payload: { topic: "chat:room1" } }));
+
+      const envelope: EventEnvelope = { type: "chat", id: "room1", payload: "hello" };
+      const event = new CustomEvent("chat:room1", { detail: envelope }) as TestEvent;
+      server.dispatchEvent(event);
+
+      expect(ws.send).not.toHaveBeenCalled();
+    });
+
+    it("silently ignores invalid topic in __subscribe", () => {
+      const server = createWebSocketServerEventTarget<TestEvent>();
+      const ws = createMockWebSocket();
+      const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+
+      server.addConnection(ws as any);
+
+      ws.simulateMessage(JSON.stringify({ type: "__subscribe", id: "", payload: { topic: "" } }));
+      ws.simulateMessage(JSON.stringify({ type: "__subscribe", id: "", payload: {} }));
+      ws.simulateMessage(JSON.stringify({ type: "__subscribe", id: "", payload: { topic: 123 } }));
+
+      const envelope: EventEnvelope = { type: "chat", id: "room1", payload: "hello" };
+      const event = new CustomEvent("chat:room1", { detail: envelope }) as TestEvent;
+      server.dispatchEvent(event);
+
+      expect(ws.send).not.toHaveBeenCalled();
+      warnSpy.mockRestore();
+    });
+
+    it("does not dispatch __subscribe to local listeners", () => {
+      const server = createWebSocketServerEventTarget<TestEvent>();
+      const ws = createMockWebSocket();
+      const listener = vi.fn();
+
+      server.addConnection(ws as any);
+      server.addEventListener("__subscribe" as any, listener);
+
+      ws.simulateMessage(JSON.stringify({ type: "__subscribe", id: "", payload: { topic: "chat:room1" } }));
+
+      expect(listener).not.toHaveBeenCalled();
+    });
+
+    it("does not dispatch __unsubscribe to local listeners", () => {
+      const server = createWebSocketServerEventTarget<TestEvent>();
+      const ws = createMockWebSocket();
+      const listener = vi.fn();
+
+      server.addConnection(ws as any);
+      server.addEventListener("__unsubscribe" as any, listener);
+
+      ws.simulateMessage(JSON.stringify({ type: "__unsubscribe", id: "", payload: { topic: "chat:room1" } }));
+
+      expect(listener).not.toHaveBeenCalled();
+    });
+
+    it("cleans up all subscriptions when a connection is removed", () => {
+      const server = createWebSocketServerEventTarget<TestEvent>();
+      const ws1 = createMockWebSocket();
+      const ws2 = createMockWebSocket();
+
+      server.addConnection(ws1 as any);
+      server.addConnection(ws2 as any);
+
+      ws1.simulateMessage(JSON.stringify({ type: "__subscribe", id: "", payload: { topic: "chat:room1" } }));
+      ws2.simulateMessage(JSON.stringify({ type: "__subscribe", id: "", payload: { topic: "chat:room1" } }));
+
+      server.removeConnection(ws1 as any);
+
+      const envelope: EventEnvelope = { type: "chat", id: "room1", payload: "hello" };
+      const event = new CustomEvent("chat:room1", { detail: envelope }) as TestEvent;
+      server.dispatchEvent(event);
+
+      expect(ws1.send).not.toHaveBeenCalledWith(JSON.stringify(envelope));
+      expect(ws2.send).toHaveBeenCalledWith(JSON.stringify(envelope));
+    });
+  });
+
+  describe("topic-based fan-out", () => {
+    it("sends events only to connections subscribed to that topic", () => {
+      const server = createWebSocketServerEventTarget<TestEvent>();
+      const ws1 = createMockWebSocket();
+      const ws2 = createMockWebSocket();
+
+      server.addConnection(ws1 as any);
+      server.addConnection(ws2 as any);
+
+      ws1.simulateMessage(JSON.stringify({ type: "__subscribe", id: "", payload: { topic: "chat:room1" } }));
+
+      const envelope: EventEnvelope = { type: "chat", id: "room1", payload: "hello" };
+      const event = new CustomEvent("chat:room1", { detail: envelope }) as TestEvent;
+      server.dispatchEvent(event);
+
+      expect(ws1.send).toHaveBeenCalledWith(JSON.stringify(envelope));
+      expect(ws2.send).not.toHaveBeenCalledWith(JSON.stringify(envelope));
+    });
+
+    it("sends to multiple subscribed connections", () => {
+      const server = createWebSocketServerEventTarget<TestEvent>();
+      const ws1 = createMockWebSocket();
+      const ws2 = createMockWebSocket();
+
+      server.addConnection(ws1 as any);
+      server.addConnection(ws2 as any);
+
+      ws1.simulateMessage(JSON.stringify({ type: "__subscribe", id: "", payload: { topic: "chat:room1" } }));
+      ws2.simulateMessage(JSON.stringify({ type: "__subscribe", id: "", payload: { topic: "chat:room1" } }));
+
+      const envelope: EventEnvelope = { type: "chat", id: "room1", payload: "hello" };
+      const event = new CustomEvent("chat:room1", { detail: envelope }) as TestEvent;
+      server.dispatchEvent(event);
+
+      expect(ws1.send).toHaveBeenCalledWith(JSON.stringify(envelope));
+      expect(ws2.send).toHaveBeenCalledWith(JSON.stringify(envelope));
+    });
+
+    it("routes events to different topics independently", () => {
+      const server = createWebSocketServerEventTarget<TestEvent>();
+      const ws1 = createMockWebSocket();
+      const ws2 = createMockWebSocket();
+
+      server.addConnection(ws1 as any);
+      server.addConnection(ws2 as any);
+
+      ws1.simulateMessage(JSON.stringify({ type: "__subscribe", id: "", payload: { topic: "chat:room1" } }));
+      ws2.simulateMessage(JSON.stringify({ type: "__subscribe", id: "", payload: { topic: "chat:room2" } }));
+
+      const envelope1: EventEnvelope = { type: "chat", id: "room1", payload: "hello1" };
+      const envelope2: EventEnvelope = { type: "chat", id: "room2", payload: "hello2" };
+
+      const event1 = new CustomEvent("chat:room1", { detail: envelope1 }) as TestEvent;
+      const event2 = new CustomEvent("chat:room2", { detail: envelope2 }) as TestEvent;
+
+      server.dispatchEvent(event1);
+
+      expect(ws1.send).toHaveBeenCalledWith(JSON.stringify(envelope1));
+      expect(ws2.send).not.toHaveBeenCalledWith(JSON.stringify(envelope1));
+
+      server.dispatchEvent(event2);
+
+      expect(ws2.send).toHaveBeenCalledWith(JSON.stringify(envelope2));
+      expect(ws1.send).not.toHaveBeenCalledWith(JSON.stringify(envelope2));
+    });
+
+    it("does not send to unsubscribed connections", () => {
+      const server = createWebSocketServerEventTarget<TestEvent>();
+      const ws = createMockWebSocket();
+
+      server.addConnection(ws as any);
+
+      const envelope: EventEnvelope = { type: "chat", id: "room1", payload: "hello" };
+      const event = new CustomEvent("chat:room1", { detail: envelope }) as TestEvent;
+      server.dispatchEvent(event);
+
+      expect(ws.send).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("dispatchEvent on server target", () => {
+    it("always returns true", () => {
+      const server = createWebSocketServerEventTarget<TestEvent>();
+      const envelope: EventEnvelope = { type: "chat", id: "room1", payload: "hello" };
+      const event = new CustomEvent("chat:room1", { detail: envelope }) as TestEvent;
+
+      expect(server.dispatchEvent(event)).toBe(true);
+    });
+
+    it("returns true even when there are no subscribers", () => {
+      const server = createWebSocketServerEventTarget<TestEvent>();
+      const envelope: EventEnvelope = { type: "chat", id: "room1", payload: "hello" };
+      const event = new CustomEvent("chat:room1", { detail: envelope }) as TestEvent;
+
+      expect(server.dispatchEvent(event)).toBe(true);
+    });
+
+    it("delivers to local listeners", () => {
+      const server = createWebSocketServerEventTarget<TestEvent>();
+      const listener = vi.fn();
+      server.addEventListener("chat:room1", listener);
+
+      const envelope: EventEnvelope = { type: "chat", id: "room1", payload: "hello" };
+      const event = new CustomEvent("chat:room1", { detail: envelope }) as TestEvent;
+      server.dispatchEvent(event);
+
+      expect(listener).toHaveBeenCalledTimes(1);
+      expect((listener.mock.calls[0][0] as TestEvent).detail).toEqual(envelope);
+    });
+
+    it("delivers to local listeners even without WebSocket subscribers", () => {
+      const server = createWebSocketServerEventTarget<TestEvent>();
+      const listener = vi.fn();
+      server.addEventListener("chat:room1", listener);
+
+      const envelope: EventEnvelope = { type: "chat", id: "room1", payload: "hello" };
+      const event = new CustomEvent("chat:room1", { detail: envelope }) as TestEvent;
+      server.dispatchEvent(event);
+
+      expect(listener).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe("incoming messages from spokes", () => {
+    it("dispatches regular events to local listeners", () => {
+      const server = createWebSocketServerEventTarget<TestEvent>();
+      const ws = createMockWebSocket();
+      const listener = vi.fn();
+
+      server.addConnection(ws as any);
+      server.addEventListener("chat:room1", listener);
+
+      const envelope: EventEnvelope = { type: "chat", id: "room1", payload: "hello" };
+      ws.simulateMessage(JSON.stringify(envelope));
+
+      expect(listener).toHaveBeenCalledTimes(1);
+      expect((listener.mock.calls[0][0] as TestEvent).detail).toEqual(envelope);
+    });
+
+    it("delivers events from a spoke to its per-connection spoke target", () => {
+      const onConnection = vi.fn();
+      const server = createWebSocketServerEventTarget<TestEvent>({ onConnection });
+      const ws = createMockWebSocket();
+
+      server.addConnection(ws as any);
+
+      const spoke = onConnection.mock.calls[0][0] as SpokeEventTarget<TestEvent>;
+      const spokeListener = vi.fn();
+      spoke.addEventListener("chat:room1", spokeListener);
+
+      const envelope: EventEnvelope = { type: "chat", id: "room1", payload: "hello" };
+      ws.simulateMessage(JSON.stringify(envelope));
+
+      expect(spokeListener).toHaveBeenCalledTimes(1);
+      expect((spokeListener.mock.calls[0][0] as TestEvent).detail).toEqual(envelope);
+    });
+
+    it("does not deliver spoke events to other spokes' listeners", () => {
+      const onConnection = vi.fn();
+      const server = createWebSocketServerEventTarget<TestEvent>({ onConnection });
+      const ws1 = createMockWebSocket();
+      const ws2 = createMockWebSocket();
+
+      server.addConnection(ws1 as any);
+      server.addConnection(ws2 as any);
+
+      const spoke1 = onConnection.mock.calls[0][0] as SpokeEventTarget<TestEvent>;
+      const spoke2 = onConnection.mock.calls[1][0] as SpokeEventTarget<TestEvent>;
+
+      const spoke1Listener = vi.fn();
+      const spoke2Listener = vi.fn();
+      spoke1.addEventListener("chat:room1", spoke1Listener);
+      spoke2.addEventListener("chat:room1", spoke2Listener);
+
+      const envelope: EventEnvelope = { type: "chat", id: "room1", payload: "from-ws1" };
+      ws1.simulateMessage(JSON.stringify(envelope));
+
+      expect(spoke1Listener).toHaveBeenCalledTimes(1);
+      expect(spoke2Listener).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("spoke target dispatchEvent", () => {
+    it("sends events to the specific spoke connection", () => {
+      const onConnection = vi.fn();
+      const server = createWebSocketServerEventTarget<TestEvent>({ onConnection });
+      const ws = createMockWebSocket();
+
+      server.addConnection(ws as any);
+
+      const spoke = onConnection.mock.calls[0][0] as SpokeEventTarget<TestEvent>;
+      const envelope: EventEnvelope = { type: "direct", id: "spoke1", payload: "hello" };
+      const event = new CustomEvent("direct:spoke1", { detail: envelope }) as TestEvent;
+
+      spoke.dispatchEvent(event);
+
+      expect(ws.send).toHaveBeenCalledWith(JSON.stringify(envelope));
+      expect(spoke.dispatchEvent(event)).toBe(true);
+    });
+  });
+
+  describe("malformed JSON handling", () => {
+    it("silently ignores malformed JSON and logs a warning", () => {
+      const server = createWebSocketServerEventTarget<TestEvent>();
+      const ws = createMockWebSocket();
+      const listener = vi.fn();
+
+      server.addConnection(ws as any);
+      server.addEventListener("topic:a", listener);
+
+      const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+      ws.simulateMessage("not valid json{{");
+
+      expect(listener).not.toHaveBeenCalled();
+      expect(warnSpy).toHaveBeenCalledTimes(1);
+      expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining("Failed to parse WebSocket message"));
+
+      warnSpy.mockRestore();
+    });
+
+    it("continues delivering valid messages after a parse error", () => {
+      const server = createWebSocketServerEventTarget<TestEvent>();
+      const ws = createMockWebSocket();
+      const listener = vi.fn();
+
+      server.addConnection(ws as any);
+      server.addEventListener("topic:a", listener);
+
+      const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+      ws.simulateMessage("broken{{{");
+
+      const envelope: EventEnvelope = { type: "topic", id: "a", payload: "good" };
+      ws.simulateMessage(JSON.stringify(envelope));
+
+      expect(listener).toHaveBeenCalledTimes(1);
+      warnSpy.mockRestore();
+    });
+  });
+
+  describe("backpressure handling", () => {
+    it("closes connection when bufferedAmount exceeds threshold", () => {
+      const server = createWebSocketServerEventTarget<TestEvent>({ maxBufferedAmount: 1024 });
+      const ws = createMockWebSocket();
+
+      server.addConnection(ws as any);
+      ws.simulateMessage(JSON.stringify({ type: "__subscribe", id: "", payload: { topic: "chat:room1" } }));
+
+      ws.bufferedAmount = 2048;
+
+      const envelope: EventEnvelope = { type: "chat", id: "room1", payload: "hello" };
+      const event = new CustomEvent("chat:room1", { detail: envelope }) as TestEvent;
+      server.dispatchEvent(event);
+
+      expect(ws.close).toHaveBeenCalledWith(1013, "Try Again Later");
+    });
+
+    it("calls onBackpressure callback before disconnecting", () => {
+      const onBackpressure = vi.fn();
+      const server = createWebSocketServerEventTarget<TestEvent>({
+        maxBufferedAmount: 1024,
+        onBackpressure,
+      });
+      const ws = createMockWebSocket();
+
+      server.addConnection(ws as any);
+      ws.simulateMessage(JSON.stringify({ type: "__subscribe", id: "", payload: { topic: "chat:room1" } }));
+
+      ws.bufferedAmount = 2048;
+
+      const envelope: EventEnvelope = { type: "chat", id: "room1", payload: "hello" };
+      const event = new CustomEvent("chat:room1", { detail: envelope }) as TestEvent;
+      server.dispatchEvent(event);
+
+      expect(onBackpressure).toHaveBeenCalledTimes(1);
+      expect(onBackpressure).toHaveBeenCalledWith(ws, 2048);
+    });
+
+    it("removes connection after backpressure disconnect", () => {
+      const onDisconnection = vi.fn();
+      const server = createWebSocketServerEventTarget<TestEvent>({
+        maxBufferedAmount: 1024,
+        onDisconnection,
+      });
+      const ws = createMockWebSocket();
+
+      server.addConnection(ws as any);
+      ws.simulateMessage(JSON.stringify({ type: "__subscribe", id: "", payload: { topic: "chat:room1" } }));
+
+      ws.bufferedAmount = 2048;
+
+      const envelope: EventEnvelope = { type: "chat", id: "room1", payload: "hello" };
+      const event = new CustomEvent("chat:room1", { detail: envelope }) as TestEvent;
+      server.dispatchEvent(event);
+
+      expect(onDisconnection).toHaveBeenCalledTimes(1);
+    });
+
+    it("does not send the current event when backpressure threshold is exceeded", () => {
+      const server = createWebSocketServerEventTarget<TestEvent>({ maxBufferedAmount: 1024 });
+      const ws = createMockWebSocket();
+
+      server.addConnection(ws as any);
+      ws.simulateMessage(JSON.stringify({ type: "__subscribe", id: "", payload: { topic: "chat:room1" } }));
+
+      ws.bufferedAmount = 2048;
+
+      const envelope: EventEnvelope = { type: "chat", id: "room1", payload: "hello" };
+      const event = new CustomEvent("chat:room1", { detail: envelope }) as TestEvent;
+
+      (ws.send as ReturnType<typeof vi.fn>).mockClear();
+      server.dispatchEvent(event);
+
+      expect(ws.send).not.toHaveBeenCalled();
+    });
+
+    it("default maxBufferedAmount is 1MB (1_048_576)", () => {
+      const server = createWebSocketServerEventTarget<TestEvent>();
+      const ws = createMockWebSocket();
+
+      server.addConnection(ws as any);
+      ws.simulateMessage(JSON.stringify({ type: "__subscribe", id: "", payload: { topic: "chat:room1" } }));
+
+      ws.bufferedAmount = 1_048_577;
+
+      const envelope: EventEnvelope = { type: "chat", id: "room1", payload: "hello" };
+      const event = new CustomEvent("chat:room1", { detail: envelope }) as TestEvent;
+
+      (ws.send as ReturnType<typeof vi.fn>).mockClear();
+      server.dispatchEvent(event);
+
+      expect(ws.send).not.toHaveBeenCalled();
+      expect(ws.close).toHaveBeenCalledWith(1013, "Try Again Later");
+    });
+
+    it("allows sending when bufferedAmount is below threshold", () => {
+      const server = createWebSocketServerEventTarget<TestEvent>({ maxBufferedAmount: 1024 });
+      const ws = createMockWebSocket();
+
+      server.addConnection(ws as any);
+      ws.simulateMessage(JSON.stringify({ type: "__subscribe", id: "", payload: { topic: "chat:room1" } }));
+
+      ws.bufferedAmount = 512;
+
+      const envelope: EventEnvelope = { type: "chat", id: "room1", payload: "hello" };
+      const event = new CustomEvent("chat:room1", { detail: envelope }) as TestEvent;
+      server.dispatchEvent(event);
+
+      expect(ws.send).toHaveBeenCalledWith(JSON.stringify(envelope));
+    });
+  });
+
+  describe("send failure handling", () => {
+    it("removes connection and fires onDisconnection when ws.send throws", () => {
+      const onDisconnection = vi.fn();
+      const server = createWebSocketServerEventTarget<TestEvent>({ onDisconnection });
+      const ws = createMockWebSocket();
+
+      server.addConnection(ws as any);
+      ws.simulateMessage(JSON.stringify({ type: "__subscribe", id: "", payload: { topic: "chat:room1" } }));
+
+      (ws.send as ReturnType<typeof vi.fn>).mockImplementation(() => {
+        throw new Error("Connection closed");
+      });
+
+      const envelope: EventEnvelope = { type: "chat", id: "room1", payload: "hello" };
+      const event = new CustomEvent("chat:room1", { detail: envelope }) as TestEvent;
+      server.dispatchEvent(event);
+
+      expect(onDisconnection).toHaveBeenCalledTimes(1);
+    });
+
+    it("dispatchEvent still returns true when ws.send throws", () => {
+      const server = createWebSocketServerEventTarget<TestEvent>();
+      const ws = createMockWebSocket();
+
+      server.addConnection(ws as any);
+      ws.simulateMessage(JSON.stringify({ type: "__subscribe", id: "", payload: { topic: "chat:room1" } }));
+
+      (ws.send as ReturnType<typeof vi.fn>).mockImplementation(() => {
+        throw new Error("Connection closed");
+      });
+
+      const envelope: EventEnvelope = { type: "chat", id: "room1", payload: "hello" };
+      const event = new CustomEvent("chat:room1", { detail: envelope }) as TestEvent;
+
+      expect(server.dispatchEvent(event)).toBe(true);
+    });
+  });
+
+  describe("addEventListener / removeEventListener on server target", () => {
+    it("adds and removes local listeners", () => {
+      const server = createWebSocketServerEventTarget<TestEvent>();
+      const listener = vi.fn();
+
+      server.addEventListener("chat:room1", listener);
+
+      const envelope: EventEnvelope = { type: "chat", id: "room1", payload: "hello" };
+      const event = new CustomEvent("chat:room1", { detail: envelope }) as TestEvent;
+      server.dispatchEvent(event);
+
+      expect(listener).toHaveBeenCalledTimes(1);
+
+      server.removeEventListener("chat:room1", listener);
+      server.dispatchEvent(event);
+
+      expect(listener).toHaveBeenCalledTimes(1);
+    });
+
+    it("supports EventListenerObject with handleEvent", () => {
+      const server = createWebSocketServerEventTarget<TestEvent>();
+      const handleEvent = vi.fn();
+      const listenerObject = { handleEvent };
+
+      server.addEventListener("chat:room1", listenerObject);
+
+      const envelope: EventEnvelope = { type: "chat", id: "room1", payload: "hello" };
+      const event = new CustomEvent("chat:room1", { detail: envelope }) as TestEvent;
+      server.dispatchEvent(event);
+
+      expect(handleEvent).toHaveBeenCalledTimes(1);
+
+      server.removeEventListener("chat:room1", listenerObject);
+      server.dispatchEvent(event);
+
+      expect(handleEvent).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe("per-connection spoke target", () => {
+    it("exposes ws property on spoke target", () => {
+      const onConnection = vi.fn();
+      const server = createWebSocketServerEventTarget<TestEvent>({ onConnection });
+      const ws = createMockWebSocket();
+
+      server.addConnection(ws as any);
+
+      const spoke = onConnection.mock.calls[0][0] as SpokeEventTarget<TestEvent>;
+      expect(spoke.ws).toBe(ws);
+    });
+
+    it("spoke target dispatchEvent sends to specific connection", () => {
+      const onConnection = vi.fn();
+      const server = createWebSocketServerEventTarget<TestEvent>({ onConnection });
+      const ws1 = createMockWebSocket();
+      const ws2 = createMockWebSocket();
+
+      server.addConnection(ws1 as any);
+      server.addConnection(ws2 as any);
+
+      const spoke1 = onConnection.mock.calls[0][0] as SpokeEventTarget<TestEvent>;
+      const envelope: EventEnvelope = { type: "direct", id: "spoke1", payload: "secret" };
+      const event = new CustomEvent("direct:spoke1", { detail: envelope }) as TestEvent;
+
+      spoke1.dispatchEvent(event);
+
+      expect(ws1.send).toHaveBeenCalledWith(JSON.stringify(envelope));
+      expect(ws2.send).not.toHaveBeenCalled();
+    });
+
+    it("spoke target dispatchEvent returns true", () => {
+      const onConnection = vi.fn();
+      const server = createWebSocketServerEventTarget<TestEvent>({ onConnection });
+      const ws = createMockWebSocket();
+
+      server.addConnection(ws as any);
+
+      const spoke = onConnection.mock.calls[0][0] as SpokeEventTarget<TestEvent>;
+      const envelope: EventEnvelope = { type: "direct", id: "spoke1", payload: "hello" };
+      const event = new CustomEvent("direct:spoke1", { detail: envelope }) as TestEvent;
+
+      expect(spoke.dispatchEvent(event)).toBe(true);
+    });
+  });
+
+  describe("invalid message handling", () => {
+    it("ignores messages without a string type", () => {
+      const server = createWebSocketServerEventTarget<TestEvent>();
+      const ws = createMockWebSocket();
+      const listener = vi.fn();
+
+      server.addConnection(ws as any);
+      server.addEventListener("topic:a", listener);
+
+      ws.simulateMessage(JSON.stringify({ id: "1", payload: null }));
+
+      expect(listener).not.toHaveBeenCalled();
+    });
+
+    it("handles non-string type gracefully", () => {
+      const server = createWebSocketServerEventTarget<TestEvent>();
+      const ws = createMockWebSocket();
+      const listener = vi.fn();
+
+      server.addConnection(ws as any);
+      server.addEventListener("topic:a", listener);
+
+      ws.simulateMessage(JSON.stringify({ type: 123, id: "1", payload: null }));
+
+      expect(listener).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("onDisconnection callback", () => {
+    it("receives the spoke event target and raw WebSocket", () => {
+      const onDisconnection = vi.fn();
+      const server = createWebSocketServerEventTarget<TestEvent>({ onDisconnection });
+      const ws = createMockWebSocket();
+
+      server.addConnection(ws as any);
+      server.removeConnection(ws as any);
+
+      expect(onDisconnection).toHaveBeenCalledTimes(1);
+      const [spoke, rawWs] = onDisconnection.mock.calls[0];
+      expect(spoke).toHaveProperty("addEventListener");
+      expect(spoke).toHaveProperty("removeEventListener");
+      expect(spoke).toHaveProperty("dispatchEvent");
+      expect(spoke).toHaveProperty("ws");
+      expect(rawWs).toBe(ws);
+    });
+  });
+
+  describe("close()", () => {
+    it("removes all connections and clears local listeners", () => {
+      const onDisconnection = vi.fn();
+      const server = createWebSocketServerEventTarget<TestEvent>({ onDisconnection });
+      const ws1 = createMockWebSocket();
+      const ws2 = createMockWebSocket();
+
+      server.addConnection(ws1 as any);
+      server.addConnection(ws2 as any);
+
+      server.close();
+
+      expect(onDisconnection).toHaveBeenCalledTimes(2);
+    });
+
+    it("no longer delivers events to removed connections after close", () => {
+      const server = createWebSocketServerEventTarget<TestEvent>();
+      const ws = createMockWebSocket();
+
+      server.addConnection(ws as any);
+      ws.simulateMessage(JSON.stringify({ type: "__subscribe", id: "", payload: { topic: "chat:room1" } }));
+
+      server.close();
+
+      const envelope: EventEnvelope = { type: "chat", id: "room1", payload: "hello" };
+      const event = new CustomEvent("chat:room1", { detail: envelope }) as TestEvent;
+      server.dispatchEvent(event);
+
+      expect(ws.send).not.toHaveBeenCalledWith(JSON.stringify(envelope));
+    });
+
+    it("no longer delivers events to local listeners after close", () => {
+      const server = createWebSocketServerEventTarget<TestEvent>();
+      const listener = vi.fn();
+      server.addEventListener("chat:room1", listener);
+
+      server.close();
+
+      const envelope: EventEnvelope = { type: "chat", id: "room1", payload: "hello" };
+      const event = new CustomEvent("chat:room1", { detail: envelope }) as TestEvent;
+      server.dispatchEvent(event);
+
+      expect(listener).not.toHaveBeenCalled();
+    });
+
+    it("restores original onmessage and onclose for all connections", () => {
+      const server = createWebSocketServerEventTarget<TestEvent>();
+      const ws = createMockWebSocket();
+      const originalOnmessage = vi.fn();
+      const originalOnclose = vi.fn();
+      ws.onmessage = originalOnmessage;
+      ws.onclose = originalOnclose;
+
+      server.addConnection(ws as any);
+      expect(ws.onmessage).not.toBe(originalOnmessage);
+
+      server.close();
+
+      expect(ws.onmessage).toBe(originalOnmessage);
+      expect(ws.onclose).toBe(originalOnclose);
+    });
+
+    it("does not close the WebSocket connections", () => {
+      const server = createWebSocketServerEventTarget<TestEvent>();
+      const ws = createMockWebSocket();
+
+      server.addConnection(ws as any);
+      server.close();
+
+      expect(ws.close).not.toHaveBeenCalled();
+    });
+
+    it("is idempotent", () => {
+      const onDisconnection = vi.fn();
+      const server = createWebSocketServerEventTarget<TestEvent>({ onDisconnection });
+      const ws = createMockWebSocket();
+
+      server.addConnection(ws as any);
+
+      server.close();
+      server.close();
+
+      expect(onDisconnection).toHaveBeenCalledTimes(1);
+    });
+  });
+});

test/event-target-worker.test.ts

@@ -0,0 +1,910 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { createWorkerHostEventTarget, createWorkerThreadEventTarget } from "../src/event-target-worker.js";
+import type { EventEnvelope, TypedEvent, TypedEventTarget } from "../src/types.js";
+
+type TestEvent = TypedEvent<string, EventEnvelope>;
+
+function createMockWorker() {
+  const posted: unknown[] = [];
+  let onmessageHandler: ((event: MessageEvent) => void) | null = null;
+  let onerrorHandler: ((event: ErrorEvent) => void) | null = null;
+
+  const worker = {
+    postMessage: vi.fn((data: unknown) => {
+      posted.push(data);
+    }),
+    get onmessage() {
+      return onmessageHandler;
+    },
+    set onmessage(handler: ((event: MessageEvent) => void) | null) {
+      onmessageHandler = handler;
+    },
+    get onerror() {
+      return onerrorHandler;
+    },
+    set onerror(handler: ((event: ErrorEvent) => void) | null) {
+      onerrorHandler = handler;
+    },
+    posted,
+    simulateMessage(data: unknown) {
+      if (onmessageHandler) {
+        onmessageHandler({ data } as MessageEvent);
+      }
+    },
+  };
+
+  Object.defineProperty(worker, "onmessage", {
+    get() {
+      return onmessageHandler;
+    },
+    set(handler: ((event: MessageEvent) => void) | null) {
+      onmessageHandler = handler;
+    },
+  });
+
+  Object.defineProperty(worker, "onerror", {
+    get() {
+      return onerrorHandler;
+    },
+    set(handler: ((event: ErrorEvent) => void) | null) {
+      onerrorHandler = handler;
+    },
+  });
+
+  return worker;
+}
+
+function createMockGlobalThis() {
+  const posted: unknown[] = [];
+  let onmessageHandler: ((event: MessageEvent) => void) | null = null;
+
+  const global = {
+    onmessage: null as ((event: MessageEvent) => void) | null,
+    postMessage: vi.fn((data: unknown) => {
+      posted.push(data);
+    }),
+    posted,
+    simulateMessage(data: unknown) {
+      if (onmessageHandler) {
+        onmessageHandler({ data } as MessageEvent);
+      }
+    },
+  };
+
+  Object.defineProperty(global, "onmessage", {
+    get() {
+      return onmessageHandler;
+    },
+    set(handler: ((event: MessageEvent) => void) | null) {
+      onmessageHandler = handler;
+    },
+  });
+
+  return global;
+}
+
+describe("createWorkerHostEventTarget", () => {
+  describe("dispatchEvent (send path)", () => {
+    it("posts event.detail to worker via worker.postMessage", () => {
+      const worker = createMockWorker();
+      const eventTarget = createWorkerHostEventTarget<TestEvent>(worker as any);
+
+      const envelope: EventEnvelope<"call.responded", { status: string }> = {
+        type: "call.responded",
+        id: "uuid-123",
+        payload: { status: "ok" },
+      };
+
+      const event = new CustomEvent("call.responded:uuid-123", {
+        detail: envelope,
+      }) as TestEvent;
+
+      eventTarget.dispatchEvent(event);
+
+      expect(worker.postMessage).toHaveBeenCalledTimes(1);
+      expect(worker.postMessage).toHaveBeenCalledWith(envelope);
+    });
+
+    it("returns true from dispatchEvent", () => {
+      const worker = createMockWorker();
+      const eventTarget = createWorkerHostEventTarget<TestEvent>(worker as any);
+
+      const event = new CustomEvent("test:event", {
+        detail: { type: "test", id: "event", payload: null },
+      }) as TestEvent;
+
+      const result = eventTarget.dispatchEvent(event);
+      expect(result).toBe(true);
+    });
+
+    it("posts envelope with null payload", () => {
+      const worker = createMockWorker();
+      const eventTarget = createWorkerHostEventTarget<TestEvent>(worker as any);
+
+      const event = new CustomEvent("notify:1", {
+        detail: { type: "notify", id: "1", payload: null },
+      }) as TestEvent;
+
+      eventTarget.dispatchEvent(event);
+
+      expect(worker.posted[0]).toEqual({ type: "notify", id: "1", payload: null });
+    });
+
+    it("posts multiple events in order", () => {
+      const worker = createMockWorker();
+      const eventTarget = createWorkerHostEventTarget<TestEvent>(worker as any);
+
+      const event1 = new CustomEvent("a:1", { detail: { type: "a", id: "1", payload: "first" } }) as TestEvent;
+      const event2 = new CustomEvent("b:2", { detail: { type: "b", id: "2", payload: "second" } }) as TestEvent;
+
+      eventTarget.dispatchEvent(event1);
+      eventTarget.dispatchEvent(event2);
+
+      expect(worker.posted).toHaveLength(2);
+      expect(worker.posted[0]).toEqual({ type: "a", id: "1", payload: "first" });
+      expect(worker.posted[1]).toEqual({ type: "b", id: "2", payload: "second" });
+    });
+  });
+
+  describe("addEventListener (subscribe path)", () => {
+    it("registers a listener for a topic", () => {
+      const worker = createMockWorker();
+      const eventTarget = createWorkerHostEventTarget<TestEvent>(worker as any);
+
+      const listener = vi.fn();
+      eventTarget.addEventListener("call.responded:uuid-123", listener);
+
+      const envelope: EventEnvelope = { type: "call.responded", id: "uuid-123", payload: "hello" };
+      worker.simulateMessage(envelope);
+
+      expect(listener).toHaveBeenCalledTimes(1);
+    });
+
+    it("does nothing when callback is null", () => {
+      const worker = createMockWorker();
+      const eventTarget = createWorkerHostEventTarget<TestEvent>(worker as any);
+
+      eventTarget.addEventListener("topic:a", null as any);
+
+      const envelope: EventEnvelope = { type: "topic", id: "a", payload: null };
+      worker.simulateMessage(envelope);
+    });
+
+    it("supports EventListenerObject with handleEvent", () => {
+      const worker = createMockWorker();
+      const eventTarget = createWorkerHostEventTarget<TestEvent>(worker as any);
+
+      const handleEvent = vi.fn();
+      const listenerObject = { handleEvent };
+
+      eventTarget.addEventListener("obj:test", listenerObject);
+
+      const envelope: EventEnvelope = { type: "obj", id: "test", payload: null };
+      worker.simulateMessage(envelope);
+
+      expect(handleEvent).toHaveBeenCalledTimes(1);
+    });
+
+    it("supports multiple listeners on the same topic", () => {
+      const worker = createMockWorker();
+      const eventTarget = createWorkerHostEventTarget<TestEvent>(worker as any);
+
+      const listener1 = vi.fn();
+      const listener2 = vi.fn();
+      eventTarget.addEventListener("topic:x", listener1);
+      eventTarget.addEventListener("topic:x", listener2);
+
+      const envelope: EventEnvelope = { type: "topic", id: "x", payload: "data" };
+      worker.simulateMessage(envelope);
+
+      expect(listener1).toHaveBeenCalledTimes(1);
+      expect(listener2).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe("removeEventListener (unsubscribe path)", () => {
+    it("removes a listener so it no longer receives events", () => {
+      const worker = createMockWorker();
+      const eventTarget = createWorkerHostEventTarget<TestEvent>(worker as any);
+
+      const listener = vi.fn();
+      eventTarget.addEventListener("topic:a", listener);
+
+      eventTarget.removeEventListener("topic:a", listener);
+
+      const envelope: EventEnvelope = { type: "topic", id: "a", payload: null };
+      worker.simulateMessage(envelope);
+
+      expect(listener).not.toHaveBeenCalled();
+    });
+
+    it("removes only the specified listener, keeping others", () => {
+      const worker = createMockWorker();
+      const eventTarget = createWorkerHostEventTarget<TestEvent>(worker as any);
+
+      const listener1 = vi.fn();
+      const listener2 = vi.fn();
+      eventTarget.addEventListener("topic:a", listener1);
+      eventTarget.addEventListener("topic:a", listener2);
+
+      eventTarget.removeEventListener("topic:a", listener1);
+
+      const envelope: EventEnvelope = { type: "topic", id: "a", payload: "data" };
+      worker.simulateMessage(envelope);
+
+      expect(listener1).not.toHaveBeenCalled();
+      expect(listener2).toHaveBeenCalledTimes(1);
+    });
+
+    it("supports EventListenerObject removal", () => {
+      const worker = createMockWorker();
+      const eventTarget = createWorkerHostEventTarget<TestEvent>(worker as any);
+
+      const handleEvent = vi.fn();
+      const listenerObject = { handleEvent };
+
+      eventTarget.addEventListener("obj:test", listenerObject);
+      eventTarget.removeEventListener("obj:test", listenerObject);
+
+      const envelope: EventEnvelope = { type: "obj", id: "test", payload: null };
+      worker.simulateMessage(envelope);
+
+      expect(handleEvent).not.toHaveBeenCalled();
+    });
+
+    it("does nothing when removing a callback that was never registered", () => {
+      const worker = createMockWorker();
+      const eventTarget = createWorkerHostEventTarget<TestEvent>(worker as any);
+
+      const unregisteredListener = vi.fn();
+      eventTarget.removeEventListener("topic:a", unregisteredListener);
+
+      expect(() => eventTarget.removeEventListener("topic:a", unregisteredListener)).not.toThrow();
+    });
+
+    it("does nothing when callback is null", () => {
+      const worker = createMockWorker();
+      const eventTarget = createWorkerHostEventTarget<TestEvent>(worker as any);
+
+      eventTarget.removeEventListener("topic:a", null as any);
+    });
+  });
+
+  describe("receive path (worker.onmessage)", () => {
+    it("parses envelope from event.data, creates CustomEvent with type:id topic, and dispatches to listeners", () => {
+      const worker = createMockWorker();
+      const eventTarget = createWorkerHostEventTarget<TestEvent>(worker as any);
+
+      const listener = vi.fn();
+      eventTarget.addEventListener("message.sent:msg1", listener);
+
+      const envelope: EventEnvelope = { type: "message.sent", id: "msg1", payload: "hello world" };
+      worker.simulateMessage(envelope);
+
+      expect(listener).toHaveBeenCalledTimes(1);
+      const receivedEvent = listener.mock.calls[0][0] as TestEvent;
+      expect(receivedEvent.type).toBe("message.sent:msg1");
+      expect(receivedEvent.detail).toEqual(envelope);
+    });
+
+    it("delivers messages to all listeners on the same topic", () => {
+      const worker = createMockWorker();
+      const eventTarget = createWorkerHostEventTarget<TestEvent>(worker as any);
+
+      const listener1 = vi.fn();
+      const listener2 = vi.fn();
+      eventTarget.addEventListener("topic:x", listener1);
+      eventTarget.addEventListener("topic:x", listener2);
+
+      const envelope: EventEnvelope = { type: "topic", id: "x", payload: "data" };
+      worker.simulateMessage(envelope);
+
+      expect(listener1).toHaveBeenCalledTimes(1);
+      expect(listener2).toHaveBeenCalledTimes(1);
+      expect((listener1.mock.calls[0][0] as TestEvent).detail).toEqual(envelope);
+      expect((listener2.mock.calls[0][0] as TestEvent).detail).toEqual(envelope);
+    });
+
+    it("ignores messages for topics with no registered listeners", () => {
+      const worker = createMockWorker();
+      const eventTarget = createWorkerHostEventTarget<TestEvent>(worker as any);
+
+      const listener = vi.fn();
+      eventTarget.addEventListener("topic:a", listener);
+
+      const envelope: EventEnvelope = { type: "other", id: "b", payload: null };
+      worker.simulateMessage(envelope);
+
+      expect(listener).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("malformed message handling", () => {
+    it("ignores messages where envelope.type is not a string", () => {
+      const worker = createMockWorker();
+      const eventTarget = createWorkerHostEventTarget<TestEvent>(worker as any);
+
+      const listener = vi.fn();
+      eventTarget.addEventListener("topic:a", listener);
+
+      worker.simulateMessage({ type: 123, id: "a", payload: null });
+
+      expect(listener).not.toHaveBeenCalled();
+    });
+
+    it("ignores messages where envelope is null", () => {
+      const worker = createMockWorker();
+      const eventTarget = createWorkerHostEventTarget<TestEvent>(worker as any);
+
+      const listener = vi.fn();
+      eventTarget.addEventListener("topic:a", listener);
+
+      worker.simulateMessage(null);
+
+      expect(listener).not.toHaveBeenCalled();
+    });
+
+    it("ignores messages where envelope is undefined", () => {
+      const worker = createMockWorker();
+      const eventTarget = createWorkerHostEventTarget<TestEvent>(worker as any);
+
+      const listener = vi.fn();
+      eventTarget.addEventListener("topic:a", listener);
+
+      worker.simulateMessage(undefined);
+
+      expect(listener).not.toHaveBeenCalled();
+    });
+
+    it("ignores messages where envelope.type starts with __", () => {
+      const worker = createMockWorker();
+      const eventTarget = createWorkerHostEventTarget<TestEvent>(worker as any);
+
+      const listener = vi.fn();
+      eventTarget.addEventListener("__custom:thing", listener);
+
+      worker.simulateMessage({ type: "__custom", id: "thing", payload: null });
+
+      expect(listener).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("topic scoping", () => {
+    it("forms topic from envelope type and id fields", () => {
+      const worker = createMockWorker();
+      const eventTarget = createWorkerHostEventTarget<TestEvent>(worker as any);
+
+      const listener = vi.fn();
+      eventTarget.addEventListener("user.action:abc-123", listener);
+
+      const envelope: EventEnvelope = { type: "user.action", id: "abc-123", payload: { done: true } };
+      worker.simulateMessage(envelope);
+
+      expect(listener).toHaveBeenCalledTimes(1);
+      expect((listener.mock.calls[0][0] as TestEvent).type).toBe("user.action:abc-123");
+    });
+
+    it("does not match when type differs even if id is the same", () => {
+      const worker = createMockWorker();
+      const eventTarget = createWorkerHostEventTarget<TestEvent>(worker as any);
+
+      const listener = vi.fn();
+      eventTarget.addEventListener("user.created:id1", listener);
+
+      worker.simulateMessage({ type: "user.deleted", id: "id1", payload: null });
+
+      expect(listener).not.toHaveBeenCalled();
+    });
+
+    it("does not match when id differs even if type is the same", () => {
+      const worker = createMockWorker();
+      const eventTarget = createWorkerHostEventTarget<TestEvent>(worker as any);
+
+      const listener = vi.fn();
+      eventTarget.addEventListener("event:alpha", listener);
+
+      worker.simulateMessage({ type: "event", id: "beta", payload: null });
+
+      expect(listener).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("EventEnvelope round-trip", () => {
+    it("round-trips full { type, id, payload } envelope through dispatch and receive", () => {
+      const worker = createMockWorker();
+      const eventTarget = createWorkerHostEventTarget<TestEvent>(worker as any);
+
+      const listener = vi.fn();
+      eventTarget.addEventListener("user.joined:user-99", listener);
+
+      const originalEnvelope: EventEnvelope<"user.joined", { name: string; role: string }> = {
+        type: "user.joined",
+        id: "user-99",
+        payload: { name: "Bob", role: "admin" },
+      };
+
+      const event = new CustomEvent("user.joined:user-99", {
+        detail: originalEnvelope,
+      }) as TestEvent;
+
+      eventTarget.dispatchEvent(event);
+
+      const dispatchedData = worker.posted[0];
+      expect(dispatchedData).toEqual(originalEnvelope);
+
+      worker.simulateMessage(dispatchedData);
+
+      expect(listener).toHaveBeenCalledTimes(1);
+      const receivedDetail = (listener.mock.calls[0][0] as TestEvent).detail as EventEnvelope;
+      expect(receivedDetail).toEqual(originalEnvelope);
+      expect(receivedDetail.type).toBe("user.joined");
+      expect(receivedDetail.id).toBe("user-99");
+      expect(receivedDetail.payload).toEqual({ name: "Bob", role: "admin" });
+    });
+
+    it("round-trips envelope with null payload", () => {
+      const worker = createMockWorker();
+      const eventTarget = createWorkerHostEventTarget<TestEvent>(worker as any);
+
+      const listener = vi.fn();
+      eventTarget.addEventListener("ping:1", listener);
+
+      const envelope: EventEnvelope = { type: "ping", id: "1", payload: null };
+      worker.simulateMessage(envelope);
+
+      expect(listener).toHaveBeenCalledTimes(1);
+      const receivedDetail = (listener.mock.calls[0][0] as TestEvent).detail as EventEnvelope;
+      expect(receivedDetail).toEqual(envelope);
+    });
+  });
+
+  describe("worker.onerror", () => {
+    it("does not propagate worker errors to event target listeners", () => {
+      const worker = createMockWorker();
+      const eventTarget = createWorkerHostEventTarget<TestEvent>(worker as any);
+
+      const listener = vi.fn();
+      eventTarget.addEventListener("topic:a", listener);
+
+      if (worker.onerror) {
+        worker.onerror(new ErrorEvent("error", { message: "Worker failed" }));
+      }
+
+      expect(listener).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("close()", () => {
+    it("restores original worker.onmessage handler", () => {
+      const worker = createMockWorker();
+      const originalOnmessage = vi.fn();
+      worker.onmessage = originalOnmessage as any;
+
+      const eventTarget = createWorkerHostEventTarget<TestEvent>(worker as any);
+      expect(worker.onmessage).not.toBe(originalOnmessage);
+
+      eventTarget.close();
+      expect(worker.onmessage).toBe(originalOnmessage);
+    });
+
+    it("clears all listeners so events are no longer delivered", () => {
+      const worker = createMockWorker();
+      const eventTarget = createWorkerHostEventTarget<TestEvent>(worker as any);
+
+      const listener = vi.fn();
+      eventTarget.addEventListener("topic:a", listener);
+
+      eventTarget.close();
+
+      const envelope: EventEnvelope = { type: "topic", id: "a", payload: "data" };
+      worker.simulateMessage(envelope);
+
+      expect(listener).not.toHaveBeenCalled();
+    });
+
+    it("is idempotent", () => {
+      const worker = createMockWorker();
+      const originalOnmessage = vi.fn();
+      worker.onmessage = originalOnmessage as any;
+
+      const eventTarget = createWorkerHostEventTarget<TestEvent>(worker as any);
+      eventTarget.close();
+      eventTarget.close();
+
+      expect(worker.onmessage).toBe(originalOnmessage);
+    });
+  });
+});
+
+describe("createWorkerThreadEventTarget", () => {
+  let originalGlobalThis: typeof globalThis;
+  let mockGlobal: ReturnType<typeof createMockGlobalThis>;
+
+  beforeEach(() => {
+    originalGlobalThis = globalThis;
+    mockGlobal = createMockGlobalThis();
+  });
+
+  function createThreadEventTargetWithMock() {
+    const callbacksForTopic = new Map<string, Set<EventListener>>();
+
+    mockGlobal.onmessage = (event: MessageEvent) => {
+      const envelope = event.data as EventEnvelope;
+      if (typeof envelope?.type !== "string" || envelope.type.startsWith("__")) {
+        return;
+      }
+
+      const topic = `${envelope.type}:${envelope.id}`;
+      const callbacks = callbacksForTopic.get(topic);
+      if (callbacks === undefined) {
+        return;
+      }
+
+      const customEvent = new CustomEvent(topic, {
+        detail: envelope,
+      }) as TestEvent;
+
+      for (const callback of callbacks) {
+        callback(customEvent);
+      }
+    };
+
+    function addCallback(topic: string, callback: EventListener) {
+      let callbacks = callbacksForTopic.get(topic);
+      if (callbacks === undefined) {
+        callbacks = new Set();
+        callbacksForTopic.set(topic, callbacks);
+      }
+      callbacks.add(callback);
+    }
+
+    function removeCallback(topic: string, callback: EventListener) {
+      const callbacks = callbacksForTopic.get(topic);
+      if (callbacks === undefined) {
+        return;
+      }
+      callbacks.delete(callback);
+      if (callbacks.size === 0) {
+        callbacksForTopic.delete(topic);
+      }
+    }
+
+    return {
+      eventTarget: {
+        addEventListener(topic: string, callbackOrOptions: EventListenerOrEventListenerObject) {
+          if (callbackOrOptions != null) {
+            const callback =
+              "handleEvent" in callbackOrOptions ? callbackOrOptions.handleEvent : callbackOrOptions;
+            addCallback(topic, callback);
+          }
+        },
+        dispatchEvent(event: TestEvent) {
+          mockGlobal.postMessage(event.detail);
+          return true;
+        },
+        removeEventListener(topic: string, callbackOrOptions: EventListenerOrEventListenerObject) {
+          if (callbackOrOptions != null) {
+            const callback =
+              "handleEvent" in callbackOrOptions ? callbackOrOptions.handleEvent : callbackOrOptions;
+            removeCallback(topic, callback);
+          }
+        },
+      } as TypedEventTarget<TestEvent>,
+      callbacksForTopic,
+    };
+  }
+
+  describe("dispatchEvent (send path)", () => {
+    it("posts event.detail via globalThis.postMessage", () => {
+      const { eventTarget } = createThreadEventTargetWithMock();
+
+      const envelope: EventEnvelope<"call.responded", { status: string }> = {
+        type: "call.responded",
+        id: "uuid-123",
+        payload: { status: "ok" },
+      };
+
+      const event = new CustomEvent("call.responded:uuid-123", {
+        detail: envelope,
+      }) as TestEvent;
+
+      eventTarget.dispatchEvent(event);
+
+      expect(mockGlobal.postMessage).toHaveBeenCalledTimes(1);
+      expect(mockGlobal.postMessage).toHaveBeenCalledWith(envelope);
+    });
+
+    it("returns true from dispatchEvent", () => {
+      const { eventTarget } = createThreadEventTargetWithMock();
+
+      const event = new CustomEvent("test:event", {
+        detail: { type: "test", id: "event", payload: null },
+      }) as TestEvent;
+
+      const result = eventTarget.dispatchEvent(event);
+      expect(result).toBe(true);
+    });
+
+    it("posts envelope with null payload", () => {
+      const { eventTarget } = createThreadEventTargetWithMock();
+
+      const event = new CustomEvent("notify:1", {
+        detail: { type: "notify", id: "1", payload: null },
+      }) as TestEvent;
+
+      eventTarget.dispatchEvent(event);
+
+      expect(mockGlobal.posted[0]).toEqual({ type: "notify", id: "1", payload: null });
+    });
+  });
+
+  describe("receive path (globalThis.onmessage)", () => {
+    it("parses envelope from event.data, creates CustomEvent with type:id topic, and dispatches to listeners", () => {
+      const { eventTarget } = createThreadEventTargetWithMock();
+
+      const listener = vi.fn();
+      eventTarget.addEventListener("message.sent:msg1", listener);
+
+      const envelope: EventEnvelope = { type: "message.sent", id: "msg1", payload: "hello" };
+      mockGlobal.simulateMessage(envelope);
+
+      expect(listener).toHaveBeenCalledTimes(1);
+      const receivedEvent = listener.mock.calls[0][0] as TestEvent;
+      expect(receivedEvent.type).toBe("message.sent:msg1");
+      expect(receivedEvent.detail).toEqual(envelope);
+    });
+
+    it("delivers messages to all listeners on the same topic", () => {
+      const { eventTarget } = createThreadEventTargetWithMock();
+
+      const listener1 = vi.fn();
+      const listener2 = vi.fn();
+      eventTarget.addEventListener("topic:x", listener1);
+      eventTarget.addEventListener("topic:x", listener2);
+
+      const envelope: EventEnvelope = { type: "topic", id: "x", payload: "data" };
+      mockGlobal.simulateMessage(envelope);
+
+      expect(listener1).toHaveBeenCalledTimes(1);
+      expect(listener2).toHaveBeenCalledTimes(1);
+    });
+
+    it("ignores messages for topics with no registered listeners", () => {
+      const { eventTarget } = createThreadEventTargetWithMock();
+
+      const listener = vi.fn();
+      eventTarget.addEventListener("topic:a", listener);
+
+      const envelope: EventEnvelope = { type: "other", id: "b", payload: null };
+      mockGlobal.simulateMessage(envelope);
+
+      expect(listener).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("addEventListener", () => {
+    it("supports EventListenerObject with handleEvent", () => {
+      const { eventTarget } = createThreadEventTargetWithMock();
+
+      const handleEvent = vi.fn();
+      const listenerObject = { handleEvent };
+
+      eventTarget.addEventListener("obj:test", listenerObject);
+
+      const envelope: EventEnvelope = { type: "obj", id: "test", payload: null };
+      mockGlobal.simulateMessage(envelope);
+
+      expect(handleEvent).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe("removeEventListener", () => {
+    it("removes a listener so it no longer receives events", () => {
+      const { eventTarget } = createThreadEventTargetWithMock();
+
+      const listener = vi.fn();
+      eventTarget.addEventListener("topic:a", listener);
+
+      eventTarget.removeEventListener("topic:a", listener);
+
+      const envelope: EventEnvelope = { type: "topic", id: "a", payload: null };
+      mockGlobal.simulateMessage(envelope);
+
+      expect(listener).not.toHaveBeenCalled();
+    });
+
+    it("supports EventListenerObject removal", () => {
+      const { eventTarget } = createThreadEventTargetWithMock();
+
+      const handleEvent = vi.fn();
+      const listenerObject = { handleEvent };
+
+      eventTarget.addEventListener("obj:test", listenerObject);
+      eventTarget.removeEventListener("obj:test", listenerObject);
+
+      const envelope: EventEnvelope = { type: "obj", id: "test", payload: null };
+      mockGlobal.simulateMessage(envelope);
+
+      expect(handleEvent).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("malformed message handling", () => {
+    it("ignores messages where envelope.type is not a string", () => {
+      const { eventTarget } = createThreadEventTargetWithMock();
+
+      const listener = vi.fn();
+      eventTarget.addEventListener("topic:a", listener);
+
+      mockGlobal.simulateMessage({ type: 123, id: "a", payload: null });
+
+      expect(listener).not.toHaveBeenCalled();
+    });
+
+    it("ignores messages where envelope is null", () => {
+      const { eventTarget } = createThreadEventTargetWithMock();
+
+      const listener = vi.fn();
+      eventTarget.addEventListener("topic:a", listener);
+
+      mockGlobal.simulateMessage(null);
+
+      expect(listener).not.toHaveBeenCalled();
+    });
+
+    it("ignores messages where envelope.type starts with __", () => {
+      const { eventTarget } = createThreadEventTargetWithMock();
+
+      const listener = vi.fn();
+      eventTarget.addEventListener("__custom:thing", listener);
+
+      mockGlobal.simulateMessage({ type: "__custom", id: "thing", payload: null });
+
+      expect(listener).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("EventEnvelope round-trip", () => {
+    it("round-trips full envelope through dispatch and receive", () => {
+      const { eventTarget } = createThreadEventTargetWithMock();
+
+      const listener = vi.fn();
+      eventTarget.addEventListener("user.joined:user-99", listener);
+
+      const originalEnvelope: EventEnvelope<"user.joined", { name: string; role: string }> = {
+        type: "user.joined",
+        id: "user-99",
+        payload: { name: "Bob", role: "admin" },
+      };
+
+      const event = new CustomEvent("user.joined:user-99", {
+        detail: originalEnvelope,
+      }) as TestEvent;
+
+      eventTarget.dispatchEvent(event);
+
+      const dispatchedData = mockGlobal.posted[0];
+      expect(dispatchedData).toEqual(originalEnvelope);
+
+      mockGlobal.simulateMessage(dispatchedData);
+
+      expect(listener).toHaveBeenCalledTimes(1);
+      const receivedDetail = (listener.mock.calls[0][0] as TestEvent).detail as EventEnvelope;
+      expect(receivedDetail).toEqual(originalEnvelope);
+    });
+  });
+
+  describe("topic scoping", () => {
+    it("forms topic from envelope type and id fields", () => {
+      const { eventTarget } = createThreadEventTargetWithMock();
+
+      const listener = vi.fn();
+      eventTarget.addEventListener("user.action:abc-123", listener);
+
+      const envelope: EventEnvelope = { type: "user.action", id: "abc-123", payload: { done: true } };
+      mockGlobal.simulateMessage(envelope);
+
+      expect(listener).toHaveBeenCalledTimes(1);
+      expect((listener.mock.calls[0][0] as TestEvent).type).toBe("user.action:abc-123");
+    });
+  });
+});
+
+describe("createWorkerThreadEventTarget context guard", () => {
+  it("throws if globalThis.postMessage is not available", () => {
+    const originalPostMessage = (globalThis as any).postMessage;
+    delete (globalThis as any).postMessage;
+    try {
+      expect(() => createWorkerThreadEventTarget<TestEvent>()).toThrow(
+        "createWorkerThreadEventTarget must be called inside a Worker context where globalThis.postMessage is available",
+      );
+    } finally {
+      (globalThis as any).postMessage = originalPostMessage;
+    }
+  });
+});
+
+describe("bidirectional communication (host + thread)", () => {
+  it("host sends envelope that thread receives", () => {
+    const worker = createMockWorker();
+    const hostTarget = createWorkerHostEventTarget<TestEvent>(worker as any);
+
+    let threadOnmessage: ((event: { data: unknown }) => void) | null = null;
+    const threadCallbacks = new Map<string, Set<EventListener>>();
+    const threadTarget = {
+      addEventListener(topic: string, callbackOrOptions: EventListenerOrEventListenerObject) {
+        if (callbackOrOptions != null) {
+          const callback =
+            "handleEvent" in callbackOrOptions ? callbackOrOptions.handleEvent : callbackOrOptions;
+          let callbacks = threadCallbacks.get(topic);
+          if (callbacks === undefined) {
+            callbacks = new Set();
+            threadCallbacks.set(topic, callbacks);
+          }
+          callbacks.add(callback);
+        }
+      },
+      dispatchEvent(event: TestEvent) {
+        return true;
+      },
+      removeEventListener(topic: string, callbackOrOptions: EventListenerOrEventListenerObject) {
+        if (callbackOrOptions != null) {
+          const callback =
+            "handleEvent" in callbackOrOptions ? callbackOrOptions.handleEvent : callbackOrOptions;
+          const callbacks = threadCallbacks.get(topic);
+          if (callbacks) {
+            callbacks.delete(callback);
+            if (callbacks.size === 0) {
+              threadCallbacks.delete(topic);
+            }
+          }
+        }
+      },
+    } as TypedEventTarget<TestEvent>;
+
+    threadOnmessage = (event: { data: unknown }) => {
+      const envelope = event.data as EventEnvelope;
+      if (typeof envelope?.type !== "string" || envelope.type.startsWith("__")) {
+        return;
+      }
+      const topic = `${envelope.type}:${envelope.id}`;
+      const callbacks = threadCallbacks.get(topic);
+      if (callbacks === undefined) return;
+      const customEvent = new CustomEvent(topic, { detail: envelope }) as TestEvent;
+      for (const callback of callbacks) {
+        callback(customEvent);
+      }
+    };
+
+    const threadListener = vi.fn();
+    threadTarget.addEventListener("task.assigned:task-1", threadListener);
+
+    const envelope: EventEnvelope = { type: "task.assigned", id: "task-1", payload: { work: "compute" } };
+    const hostEvent = new CustomEvent("task.assigned:task-1", { detail: envelope }) as TestEvent;
+
+    hostTarget.dispatchEvent(hostEvent);
+    expect(worker.postMessage).toHaveBeenCalledWith(envelope);
+
+    const postedEnvelope = worker.posted[0] as EventEnvelope;
+    threadOnmessage!({ data: postedEnvelope });
+
+    expect(threadListener).toHaveBeenCalledTimes(1);
+    const receivedDetail = (threadListener.mock.calls[0][0] as TestEvent).detail as EventEnvelope;
+    expect(receivedDetail).toEqual(envelope);
+  });
+
+  it("thread sends envelope that host receives", () => {
+    const worker = createMockWorker();
+    const hostTarget = createWorkerHostEventTarget<TestEvent>(worker as any);
+
+    const hostListener = vi.fn();
+    hostTarget.addEventListener("result.ready:res-1", hostListener);
+
+    const envelope: EventEnvelope = { type: "result.ready", id: "res-1", payload: { output: 42 } };
+    worker.simulateMessage(envelope);
+
+    expect(hostListener).toHaveBeenCalledTimes(1);
+    const receivedDetail = (hostListener.mock.calls[0][0] as TestEvent).detail as EventEnvelope;
+    expect(receivedDetail).toEqual(envelope);
+  });
+});

test/integration-pubsub-redis.test.ts

@@ -0,0 +1,346 @@
+import { describe, it, expect, vi } from "vitest";
+import { createPubSub } from "../src/create_pubsub.js";
+import { createRedisEventTarget } from "../src/event-target-redis.js";
+import type { EventEnvelope } from "../src/types.js";
+
+type TestEventMap = {
+  "message.sent": string;
+  "user.joined": { name: string };
+  "call.responded": { status: string };
+  "session.started": { sessionId: string; timestamp: number };
+};
+
+function createLinkedMockRedis() {
+  const publications: { channel: string; message: string }[] = [];
+  const subscriptions: { channel: string }[] = [];
+  const unsubscriptions: { channel: string }[] = [];
+  let messageListener: ((channel: string, message: string) => void) | null = null;
+
+  const publishClient = {
+    publish: vi.fn((channel: string, message: string) => {
+      publications.push({ channel, message });
+      if (messageListener) {
+        setImmediate(() => messageListener!(channel, message));
+      }
+      return 1;
+    }),
+    publications,
+  };
+
+  const subscribeClient = {
+    subscribe: vi.fn((channel: string) => {
+      subscriptions.push({ channel });
+    }),
+    unsubscribe: vi.fn((channel: string) => {
+      unsubscriptions.push({ channel });
+    }),
+    on: vi.fn((event: string, callback: (channel: string, message: string) => void) => {
+      if (event === "message") {
+        messageListener = callback;
+      }
+      return {} as any;
+    }),
+    subscriptions,
+    unsubscriptions,
+  };
+
+  return { publishClient, subscribeClient };
+}
+
+describe("createPubSub with Redis event target", () => {
+  describe("publish", () => {
+    it("dispatches event through Redis and subscriber receives it", async () => {
+      const { publishClient, subscribeClient } = createLinkedMockRedis();
+      const eventTarget = createRedisEventTarget({
+        publishClient: publishClient as any,
+        subscribeClient: subscribeClient as any,
+      });
+      const pubsub = createPubSub<TestEventMap>({ eventTarget: eventTarget as any });
+
+      const received: EventEnvelope<"message.sent", string>[] = [];
+      const iterator = pubsub.subscribe("message.sent", "msg1");
+
+      const consume = (async () => {
+        for await (const envelope of iterator) {
+          received.push(envelope);
+          if (received.length >= 1) break;
+        }
+      })();
+
+      pubsub.publish("message.sent", "msg1", "hello redis");
+
+      await consume;
+
+      expect(received).toHaveLength(1);
+      expect(received[0].type).toBe("message.sent");
+      expect(received[0].id).toBe("msg1");
+      expect(received[0].payload).toBe("hello redis");
+    });
+
+    it("publishes to Redis with correct channel name matching type:id", () => {
+      const { publishClient, subscribeClient } = createLinkedMockRedis();
+      const eventTarget = createRedisEventTarget({
+        publishClient: publishClient as any,
+        subscribeClient: subscribeClient as any,
+      });
+      const pubsub = createPubSub<TestEventMap>({ eventTarget: eventTarget as any });
+
+      pubsub.publish("user.joined", "user-42", { name: "Alice" });
+
+      expect(publishClient.publish).toHaveBeenCalledTimes(1);
+      expect(publishClient.publish).toHaveBeenCalledWith(
+        "user.joined:user-42",
+        JSON.stringify({ type: "user.joined", id: "user-42", payload: { name: "Alice" } }),
+      );
+    });
+  });
+
+  describe("subscribe", () => {
+    it("subscribes to Redis channel on subscribe call", async () => {
+      const { publishClient, subscribeClient } = createLinkedMockRedis();
+      const eventTarget = createRedisEventTarget({
+        publishClient: publishClient as any,
+        subscribeClient: subscribeClient as any,
+      });
+      const pubsub = createPubSub<TestEventMap>({ eventTarget: eventTarget as any });
+
+      const iterator = pubsub.subscribe("message.sent", "sub1");
+
+      const consume = (async () => {
+        for await (const envelope of iterator) {
+          if (envelope.payload === "done") break;
+        }
+      })();
+
+      expect(subscribeClient.subscribe).toHaveBeenCalledWith("message.sent:sub1");
+
+      pubsub.publish("message.sent", "sub1", "done");
+      await consume;
+    });
+
+    it("receives events only for the subscribed topic", async () => {
+      const { publishClient, subscribeClient } = createLinkedMockRedis();
+      const eventTarget = createRedisEventTarget({
+        publishClient: publishClient as any,
+        subscribeClient: subscribeClient as any,
+      });
+      const pubsub = createPubSub<TestEventMap>({ eventTarget: eventTarget as any });
+
+      const received: EventEnvelope<"message.sent", string>[] = [];
+
+      const iterator = pubsub.subscribe("message.sent", "filtered");
+
+      const consume = (async () => {
+        for await (const envelope of iterator) {
+          received.push(envelope);
+          if (received.length >= 2) break;
+        }
+      })();
+
+      pubsub.publish("message.sent", "filtered", "first");
+      pubsub.publish("message.sent", "other", "wrong topic");
+      pubsub.publish("message.sent", "filtered", "second");
+
+      await consume;
+
+      expect(received).toHaveLength(2);
+      expect(received[0].payload).toBe("first");
+      expect(received[1].payload).toBe("second");
+    });
+
+    it("multiple subscribers on the same topic all receive events", async () => {
+      const { publishClient, subscribeClient } = createLinkedMockRedis();
+      const eventTarget = createRedisEventTarget({
+        publishClient: publishClient as any,
+        subscribeClient: subscribeClient as any,
+      });
+      const pubsub = createPubSub<TestEventMap>({ eventTarget: eventTarget as any });
+
+      const received1: EventEnvelope<"message.sent", string>[] = [];
+      const received2: EventEnvelope<"message.sent", string>[] = [];
+
+      const iterator1 = pubsub.subscribe("message.sent", "broadcast1");
+      const iterator2 = pubsub.subscribe("message.sent", "broadcast1");
+
+      const consume1 = (async () => {
+        for await (const envelope of iterator1) {
+          received1.push(envelope);
+          if (received1.length >= 1) break;
+        }
+      })();
+
+      const consume2 = (async () => {
+        for await (const envelope of iterator2) {
+          received2.push(envelope);
+          if (received2.length >= 1) break;
+        }
+      })();
+
+      pubsub.publish("message.sent", "broadcast1", "hello all");
+
+      await Promise.all([consume1, consume2]);
+
+      expect(received1).toHaveLength(1);
+      expect(received2).toHaveLength(1);
+      expect(received1[0].payload).toBe("hello all");
+      expect(received2[0].payload).toBe("hello all");
+    });
+  });
+
+  describe("full envelope round-trip", () => {
+    it("preserves type, id, and payload through serialization/deserialization", async () => {
+      const { publishClient, subscribeClient } = createLinkedMockRedis();
+      const eventTarget = createRedisEventTarget({
+        publishClient: publishClient as any,
+        subscribeClient: subscribeClient as any,
+      });
+      const pubsub = createPubSub<TestEventMap>({ eventTarget: eventTarget as any });
+
+      const received: EventEnvelope<"session.started", { sessionId: string; timestamp: number }>[] = [];
+      const iterator = pubsub.subscribe("session.started", "sess-abc");
+
+      const consume = (async () => {
+        for await (const envelope of iterator) {
+          received.push(envelope);
+          if (received.length >= 1) break;
+        }
+      })();
+
+      pubsub.publish("session.started", "sess-abc", { sessionId: "sess-abc", timestamp: 1700000000 });
+
+      await consume;
+
+      expect(received).toHaveLength(1);
+      expect(received[0]).toEqual({
+        type: "session.started",
+        id: "sess-abc",
+        payload: { sessionId: "sess-abc", timestamp: 1700000000 },
+      });
+    });
+
+    it("round-trips envelope with simple string payload", async () => {
+      const { publishClient, subscribeClient } = createLinkedMockRedis();
+      const eventTarget = createRedisEventTarget({
+        publishClient: publishClient as any,
+        subscribeClient: subscribeClient as any,
+      });
+      const pubsub = createPubSub<TestEventMap>({ eventTarget: eventTarget as any });
+
+      const received: EventEnvelope<"message.sent", string>[] = [];
+      const iterator = pubsub.subscribe("message.sent", "rt1");
+
+      const consume = (async () => {
+        for await (const envelope of iterator) {
+          received.push(envelope);
+          if (received.length >= 1) break;
+        }
+      })();
+
+      pubsub.publish("message.sent", "rt1", "round-trip test");
+
+      await consume;
+
+      expect(received[0].type).toBe("message.sent");
+      expect(received[0].id).toBe("rt1");
+      expect(received[0].payload).toBe("round-trip test");
+    });
+  });
+
+  describe("topic scoping with type:id through Redis", () => {
+    it("scoped topics like call.responded:uuid-123 work correctly", async () => {
+      const { publishClient, subscribeClient } = createLinkedMockRedis();
+      const eventTarget = createRedisEventTarget({
+        publishClient: publishClient as any,
+        subscribeClient: subscribeClient as any,
+      });
+      const pubsub = createPubSub<TestEventMap>({ eventTarget: eventTarget as any });
+
+      const received: EventEnvelope<"call.responded", { status: string }>[] = [];
+      const iterator = pubsub.subscribe("call.responded", "uuid-123");
+
+      const consume = (async () => {
+        for await (const envelope of iterator) {
+          received.push(envelope);
+          if (received.length >= 1) break;
+        }
+      })();
+
+      pubsub.publish("call.responded", "uuid-123", { status: "ok" });
+
+      await consume;
+
+      expect(received).toHaveLength(1);
+      expect(received[0].type).toBe("call.responded");
+      expect(received[0].id).toBe("uuid-123");
+      expect(received[0].payload).toEqual({ status: "ok" });
+
+      expect(publishClient.publish).toHaveBeenCalledWith(
+        "call.responded:uuid-123",
+        JSON.stringify({ type: "call.responded", id: "uuid-123", payload: { status: "ok" } }),
+      );
+      expect(subscribeClient.subscribe).toHaveBeenCalledWith("call.responded:uuid-123");
+    });
+
+    it("events on one scoped topic do not leak to another scoped topic", async () => {
+      const { publishClient, subscribeClient } = createLinkedMockRedis();
+      const eventTarget = createRedisEventTarget({
+        publishClient: publishClient as any,
+        subscribeClient: subscribeClient as any,
+      });
+      const pubsub = createPubSub<TestEventMap>({ eventTarget: eventTarget as any });
+
+      const received: EventEnvelope<"call.responded", { status: string }>[] = [];
+      const iterator = pubsub.subscribe("call.responded", "uuid-aaa");
+
+      const consume = (async () => {
+        for await (const envelope of iterator) {
+          received.push(envelope);
+          if (received.length >= 1) break;
+        }
+      })();
+
+      pubsub.publish("call.responded", "uuid-bbb", { status: "wrong" });
+      pubsub.publish("call.responded", "uuid-aaa", { status: "correct" });
+
+      await consume;
+
+      expect(received).toHaveLength(1);
+      expect(received[0].id).toBe("uuid-aaa");
+      expect(received[0].payload).toEqual({ status: "correct" });
+    });
+  });
+
+  describe("channel prefix", () => {
+    it("applies prefix to both publish and subscribe channels", async () => {
+      const { publishClient, subscribeClient } = createLinkedMockRedis();
+      const eventTarget = createRedisEventTarget({
+        publishClient: publishClient as any,
+        subscribeClient: subscribeClient as any,
+        prefix: "alk:events:",
+      });
+      const pubsub = createPubSub<TestEventMap>({ eventTarget: eventTarget as any });
+
+      const received: EventEnvelope<"message.sent", string>[] = [];
+      const iterator = pubsub.subscribe("message.sent", "prefixed-1");
+
+      const consume = (async () => {
+        for await (const envelope of iterator) {
+          received.push(envelope);
+          if (received.length >= 1) break;
+        }
+      })();
+
+      pubsub.publish("message.sent", "prefixed-1", "with prefix");
+
+      await consume;
+
+      expect(subscribeClient.subscribe).toHaveBeenCalledWith("alk:events:message.sent:prefixed-1");
+      expect(publishClient.publish).toHaveBeenCalledWith(
+        "alk:events:message.sent:prefixed-1",
+        JSON.stringify({ type: "message.sent", id: "prefixed-1", payload: "with prefix" }),
+      );
+      expect(received).toHaveLength(1);
+      expect(received[0].payload).toBe("with prefix");
+    });
+  });
+});

test/integration-websocket.test.ts

@@ -0,0 +1,729 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { createWebSocketClientEventTarget } from "../src/event-target-websocket-client.js";
+import { createWebSocketServerEventTarget } from "../src/event-target-websocket-server.js";
+import type { SpokeEventTarget } from "../src/event-target-websocket-server.js";
+import { createPubSub } from "../src/create_pubsub.js";
+import type { EventEnvelope, TypedEvent } from "../src/types.js";
+
+type TestEvent = TypedEvent<string, EventEnvelope>;
+
+function createPipe() {
+  let serverOnmessage: ((ev: { data: string }) => void) | null = null;
+  let clientOnmessage: ((ev: { data: string }) => void) | null = null;
+  let serverOnclose: ((ev: { code: number; reason?: string }) => void) | null = null;
+
+  const serverSideWs = {
+    bufferedAmount: 0,
+    sent: [] as string[],
+    send: vi.fn((data: string) => {
+      clientOnmessage?.({ data });
+    }) as any,
+    close: vi.fn() as any,
+    get onmessage() {
+      return serverOnmessage;
+    },
+    set onmessage(handler: ((ev: { data: string }) => void) | null) {
+      serverOnmessage = handler;
+    },
+    get onclose() {
+      return serverOnclose;
+    },
+    set onclose(handler: ((ev: { code: number; reason?: string }) => void) | null) {
+      serverOnclose = handler;
+    },
+    simulateMessage(data: string) {
+      if (serverOnmessage) {
+        serverOnmessage({ data });
+      }
+    },
+    simulateClose(code = 1000, reason = "") {
+      if (serverOnclose) {
+        serverOnclose({ code, reason });
+      }
+    },
+  };
+
+  Object.defineProperty(serverSideWs, "onmessage", {
+    get() {
+      return serverOnmessage;
+    },
+    set(handler: ((ev: { data: string }) => void) | null) {
+      serverOnmessage = handler;
+    },
+  });
+
+  Object.defineProperty(serverSideWs, "onclose", {
+    get() {
+      return serverOnclose;
+    },
+    set(handler: ((ev: { code: number; reason?: string }) => void) | null) {
+      serverOnclose = handler;
+    },
+  });
+
+  let clientOnclose: ((ev: { code: number; reason?: string }) => void) | null = null;
+
+  const clientSideWs = {
+    sent: [] as string[],
+    send: vi.fn((data: string) => {
+      serverOnmessage?.({ data });
+    }) as any,
+    get onmessage() {
+      return clientOnmessage;
+    },
+    set onmessage(handler: ((ev: { data: string }) => void) | null) {
+      clientOnmessage = handler;
+    },
+    get onclose() {
+      return clientOnclose;
+    },
+    set onclose(handler: ((ev: { code: number; reason?: string }) => void) | null) {
+      clientOnclose = handler;
+    },
+    simulateMessage(data: string) {
+      if (clientOnmessage) {
+        clientOnmessage({ data });
+      }
+    },
+    simulateClose(code = 1000, reason = "") {
+      if (clientOnclose) {
+        clientOnclose({ code, reason });
+      }
+    },
+  };
+
+  Object.defineProperty(clientSideWs, "onmessage", {
+    get() {
+      return clientOnmessage;
+    },
+    set(handler: ((ev: { data: string }) => void) | null) {
+      clientOnmessage = handler;
+    },
+  });
+
+  Object.defineProperty(clientSideWs, "onclose", {
+    get() {
+      return clientOnclose;
+    },
+    set(handler: ((ev: { code: number; reason?: string }) => void) | null) {
+      clientOnclose = handler;
+    },
+  });
+
+  return { serverSideWs, clientSideWs };
+}
+
+describe("WebSocket Client-Server Integration", () => {
+  describe("bidirectional communication", () => {
+    it("client sends event to server via dispatchEvent, server fan-out delivers to subscribed clients", () => {
+      const server = createWebSocketServerEventTarget<TestEvent>();
+      const { serverSideWs: s1, clientSideWs: c1 } = createPipe();
+      const { serverSideWs: s2, clientSideWs: c2 } = createPipe();
+
+      server.addConnection(s1 as any);
+      server.addConnection(s2 as any);
+
+      const client1 = createWebSocketClientEventTarget<TestEvent>(c1 as any);
+      const client2 = createWebSocketClientEventTarget<TestEvent>(c2 as any);
+
+      const client1Listener = vi.fn();
+      client1.addEventListener("chat:room1", client1Listener);
+
+      const client2Listener = vi.fn();
+      client2.addEventListener("chat:room1", client2Listener);
+
+      const serverListener = vi.fn();
+      server.addEventListener("chat:room1", serverListener);
+
+      const envelope: EventEnvelope = { type: "chat", id: "room1", payload: "hello" };
+      const event = new CustomEvent("chat:room1", { detail: envelope }) as TestEvent;
+      server.dispatchEvent(event);
+
+      expect(client1Listener).toHaveBeenCalledTimes(1);
+      expect(client2Listener).toHaveBeenCalledTimes(1);
+      expect(serverListener).toHaveBeenCalledTimes(1);
+
+      expect((client1Listener.mock.calls[0][0] as TestEvent).detail).toEqual(envelope);
+      expect((client2Listener.mock.calls[0][0] as TestEvent).detail).toEqual(envelope);
+      expect(serverListener.mock.calls[0][0].detail).toEqual(envelope);
+    });
+
+    it("client dispatches event, server local listener receives it, and it fans out to other subscribed clients", () => {
+      const server = createWebSocketServerEventTarget<TestEvent>();
+      const { serverSideWs: s1, clientSideWs: c1 } = createPipe();
+      const { serverSideWs: s2, clientSideWs: c2 } = createPipe();
+
+      server.addConnection(s1 as any);
+      server.addConnection(s2 as any);
+
+      const client1 = createWebSocketClientEventTarget<TestEvent>(c1 as any);
+      const client2 = createWebSocketClientEventTarget<TestEvent>(c2 as any);
+
+      client2.addEventListener("chat:room1", vi.fn());
+
+      const serverListener = vi.fn();
+      server.addEventListener("chat:room1", serverListener);
+
+      const envelope: EventEnvelope = { type: "chat", id: "room1", payload: "from client1" };
+      const event = new CustomEvent("chat:room1", { detail: envelope }) as TestEvent;
+      client1.dispatchEvent(event);
+
+      expect(serverListener).toHaveBeenCalledTimes(1);
+      expect((serverListener.mock.calls[0][0] as TestEvent).detail).toEqual(envelope);
+    });
+  });
+
+  describe("subscription control protocol end-to-end", () => {
+    it("client addEventListener sends __subscribe, server tracks subscription, server dispatchEvent sends to subscribed client, client removeEventListener sends __unsubscribe, server removes from subscription map", () => {
+      const server = createWebSocketServerEventTarget<TestEvent>();
+      const { serverSideWs, clientSideWs } = createPipe();
+
+      server.addConnection(serverSideWs as any);
+      const client = createWebSocketClientEventTarget<TestEvent>(clientSideWs as any);
+
+      const listener = vi.fn();
+      client.addEventListener("chat:room1", listener);
+
+      const envelope: EventEnvelope = { type: "chat", id: "room1", payload: "hello" };
+      const event = new CustomEvent("chat:room1", { detail: envelope }) as TestEvent;
+      server.dispatchEvent(event);
+
+      expect(listener).toHaveBeenCalledTimes(1);
+      expect((listener.mock.calls[0][0] as TestEvent).detail).toEqual(envelope);
+
+      client.removeEventListener("chat:room1", listener);
+
+      const event2 = new CustomEvent("chat:room1", {
+        detail: { type: "chat", id: "room1", payload: "world" },
+      }) as TestEvent;
+      server.dispatchEvent(event2);
+
+      expect(listener).toHaveBeenCalledTimes(1);
+    });
+
+    it("__subscribe is only sent once for multiple listeners on the same topic", () => {
+      const server = createWebSocketServerEventTarget<TestEvent>();
+      const { serverSideWs, clientSideWs } = createPipe();
+
+      server.addConnection(serverSideWs as any);
+      const client = createWebSocketClientEventTarget<TestEvent>(clientSideWs as any);
+
+      const listener1 = vi.fn();
+      const listener2 = vi.fn();
+      client.addEventListener("chat:room1", listener1);
+      client.addEventListener("chat:room1", listener2);
+
+      const envelope: EventEnvelope = { type: "chat", id: "room1", payload: "hello" };
+      const event = new CustomEvent("chat:room1", { detail: envelope }) as TestEvent;
+      server.dispatchEvent(event);
+
+      expect(listener1).toHaveBeenCalledTimes(1);
+      expect(listener2).toHaveBeenCalledTimes(1);
+    });
+
+    it("__unsubscribe is sent only when the last listener is removed", () => {
+      const server = createWebSocketServerEventTarget<TestEvent>();
+      const { serverSideWs, clientSideWs } = createPipe();
+
+      server.addConnection(serverSideWs as any);
+      const client = createWebSocketClientEventTarget<TestEvent>(clientSideWs as any);
+
+      const listener1 = vi.fn();
+      const listener2 = vi.fn();
+      client.addEventListener("chat:room1", listener1);
+      client.addEventListener("chat:room1", listener2);
+
+      client.removeEventListener("chat:room1", listener1);
+
+      const envelope: EventEnvelope = { type: "chat", id: "room1", payload: "still here" };
+      const event = new CustomEvent("chat:room1", { detail: envelope }) as TestEvent;
+      server.dispatchEvent(event);
+
+      expect(listener2).toHaveBeenCalledTimes(1);
+
+      client.removeEventListener("chat:room1", listener2);
+
+      const event2 = new CustomEvent("chat:room1", {
+        detail: { type: "chat", id: "room1", payload: "gone" },
+      }) as TestEvent;
+      server.dispatchEvent(event2);
+
+      expect(listener2).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe("topic-based fan-out", () => {
+    it("subscribed clients receive events on their topic, unsubscribed clients do NOT", () => {
+      const server = createWebSocketServerEventTarget<TestEvent>();
+      const { serverSideWs: s1, clientSideWs: c1 } = createPipe();
+      const { serverSideWs: s2, clientSideWs: c2 } = createPipe();
+
+      server.addConnection(s1 as any);
+      server.addConnection(s2 as any);
+
+      const client1 = createWebSocketClientEventTarget<TestEvent>(c1 as any);
+      const client2 = createWebSocketClientEventTarget<TestEvent>(c2 as any);
+
+      const room1Listener = vi.fn();
+      client1.addEventListener("chat:room1", room1Listener);
+
+      const room2Listener = vi.fn();
+      client2.addEventListener("chat:room2", room2Listener);
+
+      const envelope1: EventEnvelope = { type: "chat", id: "room1", payload: "hello room1" };
+      const event1 = new CustomEvent("chat:room1", { detail: envelope1 }) as TestEvent;
+      server.dispatchEvent(event1);
+
+      expect(room1Listener).toHaveBeenCalledTimes(1);
+      expect(room2Listener).not.toHaveBeenCalled();
+
+      const envelope2: EventEnvelope = { type: "chat", id: "room2", payload: "hello room2" };
+      const event2 = new CustomEvent("chat:room2", { detail: envelope2 }) as TestEvent;
+      server.dispatchEvent(event2);
+
+      expect(room1Listener).toHaveBeenCalledTimes(1);
+      expect(room2Listener).toHaveBeenCalledTimes(1);
+    });
+
+    it("multiple clients subscribed to the same topic all receive events", () => {
+      const server = createWebSocketServerEventTarget<TestEvent>();
+      const { serverSideWs: s1, clientSideWs: c1 } = createPipe();
+      const { serverSideWs: s2, clientSideWs: c2 } = createPipe();
+      const { serverSideWs: s3, clientSideWs: c3 } = createPipe();
+
+      server.addConnection(s1 as any);
+      server.addConnection(s2 as any);
+      server.addConnection(s3 as any);
+
+      const client1 = createWebSocketClientEventTarget<TestEvent>(c1 as any);
+      const client2 = createWebSocketClientEventTarget<TestEvent>(c2 as any);
+      const client3 = createWebSocketClientEventTarget<TestEvent>(c3 as any);
+
+      const listener1 = vi.fn();
+      const listener2 = vi.fn();
+      const listener3 = vi.fn();
+
+      client1.addEventListener("chat:room1", listener1);
+      client2.addEventListener("chat:room1", listener2);
+      client3.addEventListener("chat:room2", listener3);
+
+      const envelope: EventEnvelope = { type: "chat", id: "room1", payload: "broadcast" };
+      const event = new CustomEvent("chat:room1", { detail: envelope }) as TestEvent;
+      server.dispatchEvent(event);
+
+      expect(listener1).toHaveBeenCalledTimes(1);
+      expect(listener2).toHaveBeenCalledTimes(1);
+      expect(listener3).not.toHaveBeenCalled();
+    });
+
+    it("client that unsubscribes stops receiving events", () => {
+      const server = createWebSocketServerEventTarget<TestEvent>();
+      const { serverSideWs: s1, clientSideWs: c1 } = createPipe();
+      const { serverSideWs: s2, clientSideWs: c2 } = createPipe();
+
+      server.addConnection(s1 as any);
+      server.addConnection(s2 as any);
+
+      const client1 = createWebSocketClientEventTarget<TestEvent>(c1 as any);
+      const client2 = createWebSocketClientEventTarget<TestEvent>(c2 as any);
+
+      const listener1 = vi.fn();
+      const listener2 = vi.fn();
+
+      client1.addEventListener("chat:room1", listener1);
+      client2.addEventListener("chat:room1", listener2);
+
+      const envelope1: EventEnvelope = { type: "chat", id: "room1", payload: "first" };
+      const event1 = new CustomEvent("chat:room1", { detail: envelope1 }) as TestEvent;
+      server.dispatchEvent(event1);
+
+      expect(listener1).toHaveBeenCalledTimes(1);
+      expect(listener2).toHaveBeenCalledTimes(1);
+
+      client2.removeEventListener("chat:room1", listener2);
+
+      const envelope2: EventEnvelope = { type: "chat", id: "room1", payload: "second" };
+      const event2 = new CustomEvent("chat:room1", { detail: envelope2 }) as TestEvent;
+      server.dispatchEvent(event2);
+
+      expect(listener1).toHaveBeenCalledTimes(2);
+      expect(listener2).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe("direct messaging via topic scoping", () => {
+    it("server dispatches to direct:${spokeId}, only that specific spoke receives it", () => {
+      const onConnection = vi.fn();
+      const server = createWebSocketServerEventTarget<TestEvent>({ onConnection });
+      const { serverSideWs: s1, clientSideWs: c1 } = createPipe();
+      const { serverSideWs: s2, clientSideWs: c2 } = createPipe();
+
+      server.addConnection(s1 as any);
+      server.addConnection(s2 as any);
+
+      const spoke1 = onConnection.mock.calls[0][0] as SpokeEventTarget<TestEvent>;
+      const spoke2 = onConnection.mock.calls[1][0] as SpokeEventTarget<TestEvent>;
+
+      const client1 = createWebSocketClientEventTarget<TestEvent>(c1 as any);
+      const client2 = createWebSocketClientEventTarget<TestEvent>(c2 as any);
+
+      const client1DirectListener = vi.fn();
+      const client2DirectListener = vi.fn();
+      client1.addEventListener("direct:spoke1", client1DirectListener);
+      client2.addEventListener("direct:spoke2", client2DirectListener);
+
+      const directEnvelope: EventEnvelope = { type: "direct", id: "spoke1", payload: "secret for spoke1" };
+      const directEvent = new CustomEvent("direct:spoke1", { detail: directEnvelope }) as TestEvent;
+      spoke1.dispatchEvent(directEvent);
+
+      expect(client1DirectListener).toHaveBeenCalledTimes(1);
+      expect((client1DirectListener.mock.calls[0][0] as TestEvent).detail).toEqual(directEnvelope);
+      expect(client2DirectListener).not.toHaveBeenCalled();
+
+      const directEnvelope2: EventEnvelope = { type: "direct", id: "spoke2", payload: "secret for spoke2" };
+      const directEvent2 = new CustomEvent("direct:spoke2", { detail: directEnvelope2 }) as TestEvent;
+      spoke2.dispatchEvent(directEvent2);
+
+      expect(client2DirectListener).toHaveBeenCalledTimes(1);
+      expect((client2DirectListener.mock.calls[0][0] as TestEvent).detail).toEqual(directEnvelope2);
+      expect(client1DirectListener).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe("createPubSub with WS client event target", () => {
+    it("subscribe and publish through PubSub wired to WS client", () => {
+      const server = createWebSocketServerEventTarget<TestEvent>();
+      const { serverSideWs, clientSideWs } = createPipe();
+
+      server.addConnection(serverSideWs as any);
+      const clientET = createWebSocketClientEventTarget<TestEvent>(clientSideWs as any);
+
+      type EventMap = { "chat": string };
+      const pubsub = createPubSub<EventMap>({ eventTarget: clientET });
+
+      const received: EventEnvelope<"chat", string>[] = [];
+
+      const iterator = pubsub.subscribe("chat", "room1");
+      const consume = (async () => {
+        for await (const envelope of iterator) {
+          received.push(envelope);
+          if (received.length >= 1) break;
+        }
+      })();
+
+      server.dispatchEvent(
+        new CustomEvent("chat:room1", {
+          detail: { type: "chat", id: "room1", payload: "hello from server" },
+        }) as TestEvent,
+      );
+
+      return consume.then(() => {
+        expect(received).toHaveLength(1);
+        expect(received[0]).toEqual({
+          type: "chat",
+          id: "room1",
+          payload: "hello from server",
+        });
+      });
+    });
+
+    it("publish through PubSub on client dispatches event that reaches server local listener", () => {
+      const server = createWebSocketServerEventTarget<TestEvent>();
+      const { serverSideWs, clientSideWs } = createPipe();
+
+      server.addConnection(serverSideWs as any);
+      const clientET = createWebSocketClientEventTarget<TestEvent>(clientSideWs as any);
+
+      type EventMap = { "chat": string };
+      const pubsub = createPubSub<EventMap>({ eventTarget: clientET });
+
+      const serverListener = vi.fn();
+      server.addEventListener("chat:room1", serverListener);
+
+      pubsub.publish("chat", "room1", "from client pubsub");
+
+      expect(serverListener).toHaveBeenCalledTimes(1);
+      expect((serverListener.mock.calls[0][0] as TestEvent).detail).toEqual({
+        type: "chat",
+        id: "room1",
+        payload: "from client pubsub",
+      });
+    });
+
+    it("multiple PubSub subscribers on same topic all receive events from server", () => {
+      const server = createWebSocketServerEventTarget<TestEvent>();
+      const { serverSideWs: s1, clientSideWs: c1 } = createPipe();
+      const { serverSideWs: s2, clientSideWs: c2 } = createPipe();
+
+      server.addConnection(s1 as any);
+      server.addConnection(s2 as any);
+
+      const clientET1 = createWebSocketClientEventTarget<TestEvent>(c1 as any);
+      const clientET2 = createWebSocketClientEventTarget<TestEvent>(c2 as any);
+
+      type EventMap = { "chat": string };
+      const pubsub1 = createPubSub<EventMap>({ eventTarget: clientET1 });
+      const pubsub2 = createPubSub<EventMap>({ eventTarget: clientET2 });
+
+      const received1: EventEnvelope<"chat", string>[] = [];
+      const received2: EventEnvelope<"chat", string>[] = [];
+
+      const iterator1 = pubsub1.subscribe("chat", "room1");
+      const consume1 = (async () => {
+        for await (const envelope of iterator1) {
+          received1.push(envelope);
+          if (received1.length >= 1) break;
+        }
+      })();
+
+      const iterator2 = pubsub2.subscribe("chat", "room1");
+      const consume2 = (async () => {
+        for await (const envelope of iterator2) {
+          received2.push(envelope);
+          if (received2.length >= 1) break;
+        }
+      })();
+
+      server.dispatchEvent(
+        new CustomEvent("chat:room1", {
+          detail: { type: "chat", id: "room1", payload: "broadcast" },
+        }) as TestEvent,
+      );
+
+      return Promise.all([consume1, consume2]).then(() => {
+        expect(received1).toHaveLength(1);
+        expect(received2).toHaveLength(1);
+        expect(received1[0].payload).toBe("broadcast");
+        expect(received2[0].payload).toBe("broadcast");
+      });
+    });
+  });
+
+  describe("createPubSub with WS server event target", () => {
+    it("subscribe and publish through PubSub wired to WS server", async () => {
+      const server = createWebSocketServerEventTarget<TestEvent>();
+      const { serverSideWs, clientSideWs } = createPipe();
+
+      server.addConnection(serverSideWs as any);
+      const client = createWebSocketClientEventTarget<TestEvent>(clientSideWs as any);
+
+      type EventMap = { "chat": string };
+      const pubsub = createPubSub<EventMap>({ eventTarget: server });
+
+      const clientListener = vi.fn();
+      client.addEventListener("chat:room1", clientListener);
+
+      const received: EventEnvelope<"chat", string>[] = [];
+      const iterator = pubsub.subscribe("chat", "room1");
+      const consume = (async () => {
+        for await (const envelope of iterator) {
+          received.push(envelope);
+          if (received.length >= 1) break;
+        }
+      })();
+
+      pubsub.publish("chat", "room1", "hello from server pubsub");
+
+      await consume;
+
+      expect(received).toHaveLength(1);
+      expect(received[0]).toEqual({
+        type: "chat",
+        id: "room1",
+        payload: "hello from server pubsub",
+      });
+
+      expect(clientListener).toHaveBeenCalledTimes(1);
+      expect((clientListener.mock.calls[0][0] as TestEvent).detail).toEqual({
+        type: "chat",
+        id: "room1",
+        payload: "hello from server pubsub",
+      });
+    });
+
+    it("server PubSub publish fans out to subscribed WS clients", async () => {
+      const server = createWebSocketServerEventTarget<TestEvent>();
+      const { serverSideWs: s1, clientSideWs: c1 } = createPipe();
+      const { serverSideWs: s2, clientSideWs: c2 } = createPipe();
+
+      server.addConnection(s1 as any);
+      server.addConnection(s2 as any);
+
+      const client1 = createWebSocketClientEventTarget<TestEvent>(c1 as any);
+      const client2 = createWebSocketClientEventTarget<TestEvent>(c2 as any);
+
+      type EventMap = { "chat": string };
+      const pubsub = createPubSub<EventMap>({ eventTarget: server });
+
+      const listener1 = vi.fn();
+      const listener2 = vi.fn();
+      client1.addEventListener("chat:room1", listener1);
+      client2.addEventListener("chat:room1", listener2);
+
+      const received: EventEnvelope<"chat", string>[] = [];
+      const iterator = pubsub.subscribe("chat", "room1");
+      const consume = (async () => {
+        for await (const envelope of iterator) {
+          received.push(envelope);
+          if (received.length >= 1) break;
+        }
+      })();
+
+      pubsub.publish("chat", "room1", "fan-out");
+
+      await consume;
+
+      expect(received).toHaveLength(1);
+      expect(received[0].payload).toBe("fan-out");
+
+      expect(listener1).toHaveBeenCalledTimes(1);
+      expect(listener2).toHaveBeenCalledTimes(1);
+    });
+
+    it("server PubSub publish does not reach unsubscribed clients", async () => {
+      const server = createWebSocketServerEventTarget<TestEvent>();
+      const { serverSideWs: s1, clientSideWs: c1 } = createPipe();
+      const { serverSideWs: s2, clientSideWs: c2 } = createPipe();
+
+      server.addConnection(s1 as any);
+      server.addConnection(s2 as any);
+
+      const client1 = createWebSocketClientEventTarget<TestEvent>(c1 as any);
+      const client2 = createWebSocketClientEventTarget<TestEvent>(c2 as any);
+
+      type EventMap = { "chat": string };
+      const pubsub = createPubSub<EventMap>({ eventTarget: server });
+
+      const subscribedListener = vi.fn();
+      const unsubscribedListener = vi.fn();
+      client1.addEventListener("chat:room1", subscribedListener);
+      client2.addEventListener("chat:room2", unsubscribedListener);
+
+      const received: EventEnvelope<"chat", string>[] = [];
+      const iterator = pubsub.subscribe("chat", "room1");
+      const consume = (async () => {
+        for await (const envelope of iterator) {
+          received.push(envelope);
+          if (received.length >= 1) break;
+        }
+      })();
+
+      pubsub.publish("chat", "room1", "directed");
+
+      await consume;
+
+      expect(subscribedListener).toHaveBeenCalledTimes(1);
+      expect(unsubscribedListener).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("end-to-end event envelope round-trip", () => {
+    it("preserves full EventEnvelope through client dispatch → server fan-out → client receive", () => {
+      const server = createWebSocketServerEventTarget<TestEvent>();
+      const { serverSideWs: s1, clientSideWs: c1 } = createPipe();
+      const { serverSideWs: s2, clientSideWs: c2 } = createPipe();
+
+      server.addConnection(s1 as any);
+      server.addConnection(s2 as any);
+
+      const client1 = createWebSocketClientEventTarget<TestEvent>(c1 as any);
+      const client2 = createWebSocketClientEventTarget<TestEvent>(c2 as any);
+
+      const listener2 = vi.fn();
+      client2.addEventListener("chat:room1", listener2);
+
+      const envelope: EventEnvelope<"chat", { msg: string; ts: number }> = {
+        type: "chat",
+        id: "room1",
+        payload: { msg: "hello world", ts: 1234567890 },
+      };
+
+      const event = new CustomEvent("chat:room1", { detail: envelope }) as TestEvent;
+      server.dispatchEvent(event);
+
+      expect(listener2).toHaveBeenCalledTimes(1);
+      const receivedEvent = listener2.mock.calls[0][0] as TestEvent;
+      expect(receivedEvent.detail).toEqual(envelope);
+      expect(receivedEvent.type).toBe("chat:room1");
+    });
+
+    it("preserves envelope when client publishes and server re-dispatches to subscribed clients", () => {
+      const onConnection = vi.fn();
+      const server = createWebSocketServerEventTarget<TestEvent>({ onConnection });
+      const { serverSideWs: s1, clientSideWs: c1 } = createPipe();
+      const { serverSideWs: s2, clientSideWs: c2 } = createPipe();
+
+      server.addConnection(s1 as any);
+      server.addConnection(s2 as any);
+
+      const spoke1 = onConnection.mock.calls[0][0] as SpokeEventTarget<TestEvent>;
+
+      const client1 = createWebSocketClientEventTarget<TestEvent>(c1 as any);
+      const client2 = createWebSocketClientEventTarget<TestEvent>(c2 as any);
+
+      const listener2 = vi.fn();
+      client2.addEventListener("chat:room1", listener2);
+
+      const envelope: EventEnvelope = { type: "chat", id: "room1", payload: "from client1" };
+
+      spoke1.addEventListener("chat:room1", (event: Event) => {
+        server.dispatchEvent(event as TestEvent);
+      });
+
+      const event = new CustomEvent("chat:room1", { detail: envelope }) as TestEvent;
+      client1.dispatchEvent(event);
+
+      expect(listener2).toHaveBeenCalledTimes(1);
+      const received = (listener2.mock.calls[0][0] as TestEvent).detail as EventEnvelope;
+      expect(received).toEqual(envelope);
+    });
+  });
+
+  describe("connection lifecycle", () => {
+    it("disconnecting a client removes it from server subscription map", () => {
+      const server = createWebSocketServerEventTarget<TestEvent>();
+      const { serverSideWs, clientSideWs } = createPipe();
+
+      server.addConnection(serverSideWs as any);
+      const client = createWebSocketClientEventTarget<TestEvent>(clientSideWs as any);
+
+      const listener = vi.fn();
+      client.addEventListener("chat:room1", listener);
+
+      serverSideWs.simulateClose();
+
+      const envelope: EventEnvelope = { type: "chat", id: "room1", payload: "after close" };
+      const event = new CustomEvent("chat:room1", { detail: envelope }) as TestEvent;
+      server.dispatchEvent(event);
+
+      expect(listener).not.toHaveBeenCalled();
+    });
+
+    it("one client disconnecting does not affect other clients", () => {
+      const server = createWebSocketServerEventTarget<TestEvent>();
+      const { serverSideWs: s1, clientSideWs: c1 } = createPipe();
+      const { serverSideWs: s2, clientSideWs: c2 } = createPipe();
+
+      server.addConnection(s1 as any);
+      server.addConnection(s2 as any);
+
+      const client1 = createWebSocketClientEventTarget<TestEvent>(c1 as any);
+      const client2 = createWebSocketClientEventTarget<TestEvent>(c2 as any);
+
+      const listener1 = vi.fn();
+      const listener2 = vi.fn();
+      client1.addEventListener("chat:room1", listener1);
+      client2.addEventListener("chat:room1", listener2);
+
+      s1.simulateClose();
+
+      const envelope: EventEnvelope = { type: "chat", id: "room1", payload: "after close" };
+      const event = new CustomEvent("chat:room1", { detail: envelope }) as TestEvent;
+      server.dispatchEvent(event);
+
+      expect(listener1).not.toHaveBeenCalled();
+      expect(listener2).toHaveBeenCalledTimes(1);
+      expect((listener2.mock.calls[0][0] as TestEvent).detail).toEqual(envelope);
+    });
+  });
+});

test/operators.test.ts

@@ -0,0 +1,511 @@
+import { describe, it, expect } from "vitest";
+import {
+  filter,
+  map,
+  pipe,
+  take,
+  reduce,
+  toArray,
+  batch,
+  dedupe,
+  window,
+  flat,
+  groupBy,
+  chain,
+  join,
+} from "../src/operators.js";
+import { createPubSub } from "../src/create_pubsub.js";
+import { Repeater } from "../src/repeater.js";
+
+async function* fromArray<T>(items: T[]): AsyncIterable<T> {
+  for (const item of items) {
+    yield item;
+  }
+}
+
+async function collect<T>(source: AsyncIterable<T>): Promise<T[]> {
+  const result: T[] = [];
+  for await (const item of source) {
+    result.push(item);
+  }
+  return result;
+}
+
+describe("filter", () => {
+  it("filters items by predicate", async () => {
+    const source = fromArray([1, 2, 3, 4, 5]);
+    const result = await collect(filter((x: number) => x % 2 === 0)(source));
+    expect(result).toEqual([2, 4]);
+  });
+
+  it("supports type-narrowing overload", async () => {
+    type Fish = { type: "fish"; swim: boolean };
+    type Bird = { type: "bird"; fly: boolean };
+    type Animal = Fish | Bird;
+
+    const animals: Animal[] = [
+      { type: "fish", swim: true },
+      { type: "bird", fly: true },
+      { type: "fish", swim: false },
+    ];
+    const source = fromArray(animals);
+    const isFish = (a: Animal): a is Fish => a.type === "fish";
+    const result = await collect(filter(isFish)(source));
+    expect(result).toEqual([
+      { type: "fish", swim: true },
+      { type: "fish", swim: false },
+    ]);
+  });
+
+  it("supports async predicate", async () => {
+    const source = fromArray([1, 2, 3, 4, 5]);
+    const result = await collect(
+      filter(async (x: number) => {
+        await Promise.resolve();
+        return x > 3;
+      })(source),
+    );
+    expect(result).toEqual([4, 5]);
+  });
+
+  it("yields nothing when all items are filtered", async () => {
+    const source = fromArray([1, 3, 5]);
+    const result = await collect(filter((x: number) => x % 2 === 0)(source));
+    expect(result).toEqual([]);
+  });
+
+  it("yields all items when nothing is filtered", async () => {
+    const source = fromArray([2, 4, 6]);
+    const result = await collect(filter((x: number) => x % 2 === 0)(source));
+    expect(result).toEqual([2, 4, 6]);
+  });
+});
+
+describe("map", () => {
+  it("transforms items", async () => {
+    const source = fromArray([1, 2, 3]);
+    const result = await collect(map((x: number) => x * 2)(source));
+    expect(result).toEqual([2, 4, 6]);
+  });
+
+  it("supports async mapper", async () => {
+    const source = fromArray([1, 2, 3]);
+    const result = await collect(
+      map(async (x: number) => {
+        await Promise.resolve();
+        return x + 10;
+      })(source),
+    );
+    expect(result).toEqual([11, 12, 13]);
+  });
+
+  it("transforms types", async () => {
+    const source = fromArray([1, 2, 3]);
+    const result = await collect(map((x: number) => `num:${x}`)(source));
+    expect(result).toEqual(["num:1", "num:2", "num:3"]);
+  });
+});
+
+describe("pipe", () => {
+  it("returns input when no functions provided", () => {
+    const result = pipe(42);
+    expect(result).toBe(42);
+  });
+
+  it("composes 1 function", () => {
+    const result = pipe(5, (x: number) => x * 2);
+    expect(result).toBe(10);
+  });
+
+  it("composes 2 functions", () => {
+    const result = pipe(5, (x: number) => x * 2, (x: number) => x + 1);
+    expect(result).toBe(11);
+  });
+
+  it("composes 3 functions", () => {
+    const result = pipe(
+      5,
+      (x: number) => x * 2,
+      (x: number) => x + 1,
+      (x: number) => x * 3,
+    );
+    expect(result).toBe(33);
+  });
+
+  it("composes 4 functions", () => {
+    const result = pipe(
+      5,
+      (x: number) => x * 2,
+      (x: number) => x + 1,
+      (x: number) => x * 3,
+      (x: number) => x - 5,
+    );
+    expect(result).toBe(28);
+  });
+
+  it("composes filter and map with subscribe", async () => {
+    type Events = {
+      message: string;
+    };
+    const pubsub = createPubSub<Events>();
+    const id = "test-id";
+
+    const subscription = pubsub.subscribe("message", id);
+    const filtered = filter((e: { type: string; id: string; payload: string }) => e.payload.startsWith("hello"));
+    const mapped = map((e: { type: string; id: string; payload: string }) => e.payload.toUpperCase());
+
+    const result = pipe(subscription, filtered, mapped);
+    const iterator = result[Symbol.asyncIterator]();
+
+    const results: string[] = [];
+
+    const collectNext = () => iterator.next().then((r) => {
+      if (!r.done) results.push(r.value);
+    });
+
+    void collectNext();
+    void collectNext();
+
+    pubsub.publish("message", id, "hello world");
+    pubsub.publish("message", id, "goodbye");
+    pubsub.publish("message", id, "hello again");
+
+    await new Promise((r) => setTimeout(r, 50));
+    await iterator.return?.();
+
+    expect(results).toEqual(["HELLO WORLD", "HELLO AGAIN"]);
+  });
+});
+
+describe("take", () => {
+  it("yields first N items, then stops", async () => {
+    const source = fromArray([1, 2, 3, 4, 5]);
+    const result = await collect(take(source, 3));
+    expect(result).toEqual([1, 2, 3]);
+  });
+
+  it("yields all items if count exceeds source length", async () => {
+    const source = fromArray([1, 2]);
+    const result = await collect(take(source, 5));
+    expect(result).toEqual([1, 2]);
+  });
+
+  it("yields nothing when count is 0", async () => {
+    const source = fromArray([1, 2, 3]);
+    const result = await collect(take(source, 0));
+    expect(result).toEqual([]);
+  });
+
+  it("works with single item", async () => {
+    const source = fromArray([42]);
+    const result = await collect(take(source, 1));
+    expect(result).toEqual([42]);
+  });
+});
+
+describe("reduce", () => {
+  it("reduces to single value", async () => {
+    const source = fromArray([1, 2, 3, 4]);
+    const result = await reduce(source, (acc: number, val: number) => acc + val, 0);
+    expect(result).toBe(10);
+  });
+
+  it("returns initial value for empty source", async () => {
+    const source = fromArray<number>([]);
+    const result = await reduce(source, (acc: number, val: number) => acc + val, 0);
+    expect(result).toBe(0);
+  });
+
+  it("supports async reducer", async () => {
+    const source = fromArray([1, 2, 3]);
+    const result = await reduce(
+      source,
+      async (acc: number, val: number) => {
+        await Promise.resolve();
+        return acc + val;
+      },
+      0,
+    );
+    expect(result).toBe(6);
+  });
+
+  it("reduces with string concatenation", async () => {
+    const source = fromArray(["a", "b", "c"]);
+    const result = await reduce(source, (acc: string, val: string) => acc + val, "");
+    expect(result).toBe("abc");
+  });
+});
+
+describe("toArray", () => {
+  it("collects all items into array", async () => {
+    const source = fromArray([1, 2, 3]);
+    const result = await toArray(source);
+    expect(result).toEqual([1, 2, 3]);
+  });
+
+  it("returns empty array for empty source", async () => {
+    const source = fromArray<number>([]);
+    const result = await toArray(source);
+    expect(result).toEqual([]);
+  });
+
+  it("preserves order", async () => {
+    const source = fromArray([5, 3, 1, 4, 2]);
+    const result = await toArray(source);
+    expect(result).toEqual([5, 3, 1, 4, 2]);
+  });
+});
+
+describe("batch", () => {
+  it("groups into arrays of size", async () => {
+    const source = fromArray([1, 2, 3, 4, 5, 6]);
+    const result = await collect(batch(source, 2));
+    expect(result).toEqual([[1, 2], [3, 4], [5, 6]]);
+  });
+
+  it("yields remaining items if not a full batch", async () => {
+    const source = fromArray([1, 2, 3, 4, 5]);
+    const result = await collect(batch(source, 2));
+    expect(result).toEqual([[1, 2], [3, 4], [5]]);
+  });
+
+  it("yields single batch when source length equals size", async () => {
+    const source = fromArray([1, 2, 3]);
+    const result = await collect(batch(source, 3));
+    expect(result).toEqual([[1, 2, 3]]);
+  });
+
+  it("yields each item individually when size is 1", async () => {
+    const source = fromArray([1, 2, 3]);
+    const result = await collect(batch(source, 1));
+    expect(result).toEqual([[1], [2], [3]]);
+  });
+
+  it("returns empty for empty source", async () => {
+    const source = fromArray<number>([]);
+    const result = await collect(batch(source, 3));
+    expect(result).toEqual([]);
+  });
+});
+
+describe("dedupe", () => {
+  it("yields only unique items", async () => {
+    const source = fromArray([1, 2, 2, 3, 1, 4, 3]);
+    const result = await collect(dedupe(source));
+    expect(result).toEqual([1, 2, 3, 4]);
+  });
+
+  it("yields all items when no duplicates", async () => {
+    const source = fromArray([1, 2, 3]);
+    const result = await collect(dedupe(source));
+    expect(result).toEqual([1, 2, 3]);
+  });
+
+  it("returns empty for empty source", async () => {
+    const source = fromArray<number>([]);
+    const result = await collect(dedupe(source));
+    expect(result).toEqual([]);
+  });
+
+  it("handles all same values", async () => {
+    const source = fromArray([5, 5, 5, 5]);
+    const result = await collect(dedupe(source));
+    expect(result).toEqual([5]);
+  });
+});
+
+describe("window", () => {
+  it("produces sliding window of size with default step 1", async () => {
+    const source = fromArray([1, 2, 3, 4, 5]);
+    const result = await collect(window(source, 3));
+    expect(result).toEqual([[1, 2, 3], [2, 3, 4], [3, 4, 5]]);
+  });
+
+  it("advances by step greater than 1", async () => {
+    const source = fromArray([1, 2, 3, 4, 5, 6]);
+    const result = await collect(window(source, 3, 2));
+    expect(result).toEqual([[1, 2, 3], [3, 4, 5]]);
+  });
+
+  it("yields nothing when source is shorter than window size", async () => {
+    const source = fromArray([1, 2]);
+    const result = await collect(window(source, 3));
+    expect(result).toEqual([]);
+  });
+
+  it("yields single window when source length equals size", async () => {
+    const source = fromArray([1, 2, 3]);
+    const result = await collect(window(source, 3));
+    expect(result).toEqual([[1, 2, 3]]);
+  });
+
+  it("returns empty for empty source", async () => {
+    const source = fromArray<number>([]);
+    const result = await collect(window(source, 2));
+    expect(result).toEqual([]);
+  });
+});
+
+describe("flat", () => {
+  it("flattens AsyncIterable<T[]> into AsyncIterable<T>", async () => {
+    async function* arrays() {
+      yield [1, 2];
+      yield [3, 4];
+      yield [5];
+    }
+    const result = await collect(flat(arrays()));
+    expect(result).toEqual([1, 2, 3, 4, 5]);
+  });
+
+  it("handles empty inner arrays", async () => {
+    async function* arrays() {
+      yield [1, 2];
+      yield [] as number[];
+      yield [3];
+    }
+    const result = await collect(flat(arrays()));
+    expect(result).toEqual([1, 2, 3]);
+  });
+
+  it("returns empty for empty source", async () => {
+    async function* arrays() {
+      // empty
+    }
+    const result = await collect(flat(arrays()));
+    expect(result).toEqual([]);
+  });
+});
+
+describe("groupBy", () => {
+  it("groups items by key into Map", async () => {
+    const source = fromArray([
+      { name: "alice", dept: "eng" },
+      { name: "bob", dept: "eng" },
+      { name: "carol", dept: "sales" },
+    ]);
+    const result = await groupBy(source, (v: { name: string; dept: string }) => v.dept);
+    expect(result.get("eng")).toEqual([
+      { name: "alice", dept: "eng" },
+      { name: "bob", dept: "eng" },
+    ]);
+    expect(result.get("sales")).toEqual([{ name: "carol", dept: "sales" }]);
+  });
+
+  it("returns empty Map for empty source", async () => {
+    const source = fromArray<number>([]);
+    const result = await groupBy(source, (v: number) => v);
+    expect(result.size).toBe(0);
+  });
+
+  it("groups with numeric keys", async () => {
+    const source = fromArray([1, 2, 3, 4, 5, 6]);
+    const result = await groupBy(source, (v: number) => v % 2);
+    expect(result.get(0)).toEqual([2, 4, 6]);
+    expect(result.get(1)).toEqual([1, 3, 5]);
+  });
+});
+
+describe("chain", () => {
+  it("concatenates multiple async iterables", async () => {
+    const source = chain(fromArray([1, 2]), fromArray([3, 4]), fromArray([5]));
+    const result = await collect(source);
+    expect(result).toEqual([1, 2, 3, 4, 5]);
+  });
+
+  it("handles single iterable", async () => {
+    const source = chain(fromArray([1, 2, 3]));
+    const result = await collect(source);
+    expect(result).toEqual([1, 2, 3]);
+  });
+
+  it("handles empty iterables", async () => {
+    const source = chain(fromArray<number>([]), fromArray([1, 2]), fromArray<number>([]));
+    const result = await collect(source);
+    expect(result).toEqual([1, 2]);
+  });
+
+  it("returns empty when all sources are empty", async () => {
+    const source = chain(fromArray<number>([]), fromArray<number>([]));
+    const result = await collect(source);
+    expect(result).toEqual([]);
+  });
+});
+
+describe("join", () => {
+  it("joins two sources on matching keys", async () => {
+    const source1 = fromArray([
+      { id: 1, name: "alice" },
+      { id: 2, name: "bob" },
+      { id: 3, name: "carol" },
+    ]);
+    const source2 = fromArray([
+      { userId: 2, role: "admin" },
+      { userId: 3, role: "user" },
+      { userId: 1, role: "user" },
+    ]);
+    const result = await collect(
+      join(
+        source1,
+        source2,
+        (v: { id: number; name: string }) => v.id,
+        (v: { userId: number; role: string }) => v.userId,
+      ),
+    );
+    expect(result).toEqual([
+      [
+        { id: 1, name: "alice" },
+        { userId: 1, role: "user" },
+      ],
+      [
+        { id: 2, name: "bob" },
+        { userId: 2, role: "admin" },
+      ],
+      [
+        { id: 3, name: "carol" },
+        { userId: 3, role: "user" },
+      ],
+    ]);
+  });
+
+  it("yields nothing when no keys match", async () => {
+    const source1 = fromArray([{ id: 1, name: "alice" }]);
+    const source2 = fromArray([{ userId: 99, role: "admin" }]);
+    const result = await collect(
+      join(
+        source1,
+        source2,
+        (v: { id: number; name: string }) => v.id,
+        (v: { userId: number; role: string }) => v.userId,
+      ),
+    );
+    expect(result).toEqual([]);
+  });
+
+  it("handles empty sources", async () => {
+    const source1 = fromArray<{ id: number; name: string }>([]);
+    const source2 = fromArray<{ userId: number; role: string }>([]);
+    const result = await collect(
+      join(source1, source2, (v) => v.id, (v) => v.userId),
+    );
+    expect(result).toEqual([]);
+  });
+
+  it("joins with duplicate keys in source2 (last wins)", async () => {
+    const source1 = fromArray([{ id: 1, name: "alice" }]);
+    const source2 = fromArray([
+      { userId: 1, role: "admin" },
+      { userId: 1, role: "user" },
+    ]);
+    const result = await collect(
+      join(
+        source1,
+        source2,
+        (v: { id: number; name: string }) => v.id,
+        (v: { userId: number; role: string }) => v.userId,
+      ),
+    );
+    expect(result).toHaveLength(1);
+    expect(result[0][0]).toEqual({ id: 1, name: "alice" });
+    expect(result[0][1].role).toBe("user");
+  });
+});

tsup.config.ts

@@ -4,6 +4,9 @@ export default defineConfig({
   entry: [
     'src/index.ts',
     'src/event-target-redis.ts',
+    'src/event-target-websocket-client.ts',
+    'src/event-target-websocket-server.ts',
+    'src/event-target-worker.ts',
   ],
   format: ['esm', 'cjs'],
   dts: true,