feat(message-bus)!: rewrite around class-based events and per-broker queues

[johngeorgewright]

Replace the old MessageBus API (string event names, tuple args, generators and
RPC-style invokables) with a class-based bus modelled on Enterprise Integration
Patterns. Messages are plain class instances routed by constructor identity, so
EventDescriptions are no longer needed. The invokable and generator APIs collapse
into a single streaming register/invoke pair, and the RPC-style request/response
model is removed.

Each bus member is a Participant with its own queue, so members can be paused
and resumed independently. A participant has two faces onto the same kernel: a
MessageGateway (outbound — what the application holds, to subscribe, emit and
invoke) and a MessageDispatcher (inbound — what the bus drives to deliver
messages to the registered handlers). The handler roles are named after their EIP
counterparts: Subscribers (on/once/until), Responders (register) that
stream values back for a CommandMessage, and Interceptors (intercept) that form
a Message Translator / Pipes-and-Filters chain able to transform or CANCEL a
message before subscribers see it. Filters are a Message Filter (whole-message
pass/discard).

Changes since this description was first written

The branch has moved on considerably since the PR was opened:

• Enterprise Integration Patterns rename: Bus → MessageBus, broker →
  participant (facade: MessageGateway), Event → Message, Invocation →
  CommandMessage, and handlers are now Subscriber / Responder / Interceptor.
• Externally abortable participants: bus.gateway(name, signal) ties a
  participant's lifetime to an AbortSignal; aborting tears down its handlers and
  frees its name for reuse.
• Serializable payloads: emit/invoke arguments are constrained at compile
  time to JSON-safe data. Because a message can sit in a paused queue and be
  delivered later, a payload holding a live reference (e.g. an HTMLElement)
  would no longer be a faithful snapshot; the constraint guarantees a subscriber
  receives what was emitted, whenever it is emitted. It is a type-level rule
  only — nothing is cloned at runtime.

Bug fixes found while reviewing the rewrite

Each is covered by tests:

• filters now AND their keys instead of OR
• each emit() call resolves to its own result rather than a shared promise
• invoke completion is the settling of each responder, not a finish() count, so a
  filtered-out or negligent responder can no longer hang or truncate the stream
• invoke gains an error channel: fail-loud by default, isolate with { onError }
• interceptor routing is cleaned up when a participant aborts
• queueMethod no longer resets a running queue

BREAKING CHANGE: the entire public API of @plugola/message-bus has changed.

• MessageBus replaces the old bus; bus.gateway(name) returns a MessageGateway,
  optionally scoped to an AbortSignal. EventDescriptions are removed.
• Messages are classes implementing Message (or extending CommandMessage) and
  are subscribed to by class, not string name.
• Invokables and generators are unified into a streaming API: register a responder
  with gateway.register(Command, (command, { send, signal }) => ...) and call
  gateway.invoke(new Command()).collect() / .iterate(). There is no finish() — a
  responder completes when it returns or its promise settles. The RPC-style
  request/response model is removed.
• invoke errors are fail-loud by default; pass { onError } to invoke() to isolate
  responders and keep the stream running.
• Message and command payloads must be Serializable (JSON-safe), enforced at the
  type level on emit/invoke.
• Lifecycle methods are renamed: start/stop are now resume/pause on both
  MessageBus and MessageGateway, with abort for permanent teardown.
• CancelEvent is renamed to CANCEL.

🤖 Generated with Claude Code