Simplify to transport-only: remove call protocol, add EventEnvelope, expand stream operators

- Remove src/call.ts (PendingRequestMap, CallEventSchema, CallError) — call protocol belongs in @alkdev/operations
- Add EventEnvelope type ({ type, id, payload }) as the cross-platform serialization contract
- Simplify createPubSub: replace PubSubPublishArgsByKey tuple model with PubSubEventMap; publish(type, id, payload) and subscribe(type, id) use explicit id for topic scoping
- Update Redis adapter to serialize/deserialize full EventEnvelope
- Expand operators: add take, reduce, toArray, batch, dedupe, window, flat, groupBy, chain, join
- Remove @alkdev/typebox runtime dependency (was only used by call.ts)
- Remove ./call sub-path export from package.json and tsup config
- Update all architecture docs to reflect transport-only scope, add Worker adapter, remove call protocol references
- Remove docs/architecture/call-protocol.md
- Update AGENTS.md with new source layout and transport-only principle

src/create_pubsub.ts

@@ -25,69 +25,62 @@
  */
 
 import { Repeater } from "./repeater.js";
-import type { TypedEventTarget, TypedEvent } from "./types.js";
+import type { TypedEventTarget, TypedEvent, EventEnvelope } from "./types.js";
 
-export type PubSubPublishArgsByKey = {
-  [key: string]: [] | [unknown] | [number | string, unknown];
+export type PubSubEventMap = {
+  [eventType: string]: unknown;
 };
 
 export type PubSubEvent<
-  TPubSubPublishArgsByKey extends PubSubPublishArgsByKey,
-  TKey extends Extract<keyof TPubSubPublishArgsByKey, string>,
-> = TypedEvent<
-  TKey,
-  TPubSubPublishArgsByKey[TKey][1] extends undefined
-    ? TPubSubPublishArgsByKey[TKey][0]
-    : TPubSubPublishArgsByKey[TKey][1]
->;
+  TEventMap extends PubSubEventMap,
+  TType extends Extract<keyof TEventMap, string> = Extract<keyof TEventMap, string>,
+> = TypedEvent<TType, EventEnvelope<TType, TEventMap[TType]>>;
 
-export type PubSubEventTarget<TPubSubPublishArgsByKey extends PubSubPublishArgsByKey> =
+export type PubSubEventTarget<TEventMap extends PubSubEventMap> =
   TypedEventTarget<
-    PubSubEvent<TPubSubPublishArgsByKey, Extract<keyof TPubSubPublishArgsByKey, string>>
+    PubSubEvent<TEventMap>
   >;
 
-export type PubSubConfig<TPubSubPublishArgsByKey extends PubSubPublishArgsByKey> = {
-  eventTarget?: PubSubEventTarget<TPubSubPublishArgsByKey>;
+export type PubSubConfig<TEventMap extends PubSubEventMap> = {
+  eventTarget?: PubSubEventTarget<TEventMap>;
 };
 
-export type PubSub<TPubSubPublishArgsByKey extends PubSubPublishArgsByKey> = {
-  publish<TKey extends Extract<keyof TPubSubPublishArgsByKey, string>>(
-    routingKey: TKey,
-    ...args: TPubSubPublishArgsByKey[TKey]
+export type PubSub<TEventMap extends PubSubEventMap> = {
+  publish<TType extends Extract<keyof TEventMap, string>>(
+    type: TType,
+    id: string,
+    payload: TEventMap[TType],
   ): void;
-  subscribe<TKey extends Extract<keyof TPubSubPublishArgsByKey, string>>(
-    ...[routingKey, id]: TPubSubPublishArgsByKey[TKey][1] extends undefined
-      ? [TKey]
-      : [TKey, TPubSubPublishArgsByKey[TKey][0]]
-  ): Repeater<unknown>;
+  subscribe<TType extends Extract<keyof TEventMap, string>>(
+    type: TType,
+    id: string,
+  ): Repeater<EventEnvelope<TType, TEventMap[TType]>>;
 };
 
-export function createPubSub<TPubSubPublishArgsByKey extends PubSubPublishArgsByKey>(
-  config?: PubSubConfig<TPubSubPublishArgsByKey>,
-): PubSub<TPubSubPublishArgsByKey> {
+export function createPubSub<TEventMap extends PubSubEventMap>(
+  config?: PubSubConfig<TEventMap>,
+): PubSub<TEventMap> {
   const target =
-    config?.eventTarget ?? (new EventTarget() as PubSubEventTarget<TPubSubPublishArgsByKey>);
+    config?.eventTarget ?? (new EventTarget() as PubSubEventTarget<TEventMap>);
 
   return {
-    publish<TKey extends Extract<keyof TPubSubPublishArgsByKey, string>>(
-      routingKey: TKey,
-      ...args: TPubSubPublishArgsByKey[TKey]
+    publish<TType extends Extract<keyof TEventMap, string>>(
+      type: TType,
+      id: string,
+      payload: TEventMap[TType],
     ) {
-      const payload = args[1] ?? args[0] ?? null;
-      const topic = args[1] === undefined ? routingKey : `${routingKey}:${args[0] as number}`;
-
-      const event = new CustomEvent(topic, { detail: payload }) as PubSubEvent<
-        TPubSubPublishArgsByKey,
-        TKey
+      const envelope: EventEnvelope<TType, TEventMap[TType]> = { type, id, payload };
+      const event = new CustomEvent(type, { detail: envelope }) as PubSubEvent<
+        TEventMap,
+        TType
       >;
       target.dispatchEvent(event);
     },
-    subscribe<TKey extends Extract<keyof TPubSubPublishArgsByKey, string>>(
-      ...[routingKey, id]: TPubSubPublishArgsByKey[TKey][1] extends undefined
-        ? [TKey]
-        : [TKey, TPubSubPublishArgsByKey[TKey][0]]
-    ): Repeater<unknown> {
-      const topic: TKey = (id === undefined ? routingKey : `${routingKey}:${id as number}`) as TKey;
+    subscribe<TType extends Extract<keyof TEventMap, string>>(
+      type: TType,
+      id: string,
+    ): Repeater<EventEnvelope<TType, TEventMap[TType]>> {
+      const topic = `${type}:${id}`;
 
       return new Repeater(function subscriptionRepeater(
         next: (value: unknown) => Promise<void>,
@@ -98,11 +91,11 @@ export function createPubSub<TPubSubPublishArgsByKey extends PubSubPublishArgsBy
         }
 
         stop.then(function subscriptionRepeaterStopHandler() {
-          target.removeEventListener(topic, pubsubEventListener as EventListener);
+          target.removeEventListener(topic as TType, pubsubEventListener as EventListener);
         });
 
-        target.addEventListener(topic, pubsubEventListener as EventListener, undefined);
-      });
+        target.addEventListener(topic as TType, pubsubEventListener as EventListener, undefined);
+      }) as Repeater<EventEnvelope<TType, TEventMap[TType]>>;
     },
   };
 }