@zerotal/broadcasting 1.0.0

package/src/TypedBroadcastManager.ts

@@ -0,0 +1,185 @@
+import { BroadcastManager } from "./BroadcastManager.ts";
+import { MissingChannelParameterError } from "./errors.ts";
+import type { BroadcastEvent } from "./types.ts";
+
+// ── Channel-map type ──────────────────────────────────────────────────────────
+
+/**
+ * Shape of a typed broadcast channel map.
+ *
+ * Keys are channel name patterns (may include `[param]` placeholders).
+ * Values are objects mapping event names to their payload types.
+ *
+ * @example
+ * export interface Channels extends BroadcastChannelMap {
+ *   'posts': {
+ *     PostCreated: { id: number; title: string };
+ *     PostDeleted: { id: number };
+ *   };
+ *   'private-orders.[orderId]': {
+ *     OrderShipped: { orderId: number; trackingCode: string };
+ *     OrderCancelled: { orderId: number; reason: string };
+ *   };
+ *   'presence-room.[roomId]': {
+ *     MessageSent: { userId: number; text: string };
+ *   };
+ * }
+ *
+ * const manager = new TypedBroadcastManager<Channels>();
+ *
+ * // Static channel — fully typed
+ * manager.to('posts', 'PostCreated', { id: 1, title: 'Hello' });
+ *
+ * // Parameterised channel — pass the pattern + params separately
+ * manager.toChannel('private-orders.[orderId]', { orderId: 42 }, 'OrderShipped', {
+ *   orderId: 42,
+ *   trackingCode: 'UPS-123',
+ * });
+ */
+export type BroadcastChannelMap = Record<string, Record<string, object>>;
+
+// ── Type helpers ──────────────────────────────────────────────────────────────
+
+/** Extract `[param]` names from a channel pattern string. */
+export type ChannelParams<Pattern extends string> =
+  Pattern extends `${string}[${infer Param}]${infer Tail}` ? Param | ChannelParams<Tail> : never;
+
+/** Build the params record for a channel pattern. `undefined` when there are no params. */
+export type ChannelParamRecord<Pattern extends string> = [ChannelParams<Pattern>] extends [never]
+  ? undefined
+  : { [K in ChannelParams<Pattern>]: string | number };
+
+/** All event names for a given channel pattern in the map. */
+export type EventsOf<M extends BroadcastChannelMap, Ch extends keyof M & string> = keyof M[Ch] &
+  string;
+
+/** The payload type for a specific event on a channel. */
+export type PayloadOf<
+  M extends BroadcastChannelMap,
+  Ch extends keyof M & string,
+  Ev extends EventsOf<M, Ch>,
+> = M[Ch][Ev];
+
+/** Channel patterns that have NO `[param]` placeholders. */
+export type StaticChannels<M extends BroadcastChannelMap> = {
+  [K in keyof M & string]: [ChannelParams<K>] extends [never] ? K : never;
+}[keyof M & string];
+
+/** Channel patterns that DO contain `[param]` placeholders. */
+export type ParameterizedChannels<M extends BroadcastChannelMap> = {
+  [K in keyof M & string]: [ChannelParams<K>] extends [never] ? never : K;
+}[keyof M & string];
+
+// ── Typed event interface ─────────────────────────────────────────────────────
+
+/**
+ * Implement on an event class to make it a typed broadcast event.
+ * The type parameters enforce that the event name and payload match the channel map.
+ *
+ * @example
+ * class PostCreated implements TypedBroadcastEvent<Channels, 'posts', 'PostCreated'> {
+ *   constructor(private post: Post) {}
+ *
+ *   broadcastOn()   { return 'posts' as const; }
+ *   broadcastAs()   { return 'PostCreated' as const; }
+ *   broadcastWith() { return { id: this.post.id, title: this.post.title }; }
+ * }
+ */
+export interface TypedBroadcastEvent<
+  M extends BroadcastChannelMap,
+  Ch extends keyof M & string,
+  Ev extends EventsOf<M, Ch> = EventsOf<M, Ch>,
+> extends BroadcastEvent {
+  broadcastOn(): Ch | Ch[];
+  broadcastAs(): Ev;
+  broadcastWith(): PayloadOf<M, Ch, Ev>;
+}
+
+// ── Runtime helper ────────────────────────────────────────────────────────────
+
+function interpolateChannel(pattern: string, params: Record<string, string | number>): string {
+  return pattern.replace(/\[(\w+)\]/g, (_, key: string) => {
+    const val = params[key];
+    if (val === undefined) throw new MissingChannelParameterError(key);
+    return String(val);
+  });
+}
+
+// ── TypedBroadcastManager ─────────────────────────────────────────────────────
+
+/**
+ * A `BroadcastManager` variant that enforces payload types against a channel map.
+ *
+ * All `BroadcastManager` APIs (WebSocket lifecycle, auth, presence) are inherited
+ * unchanged. Only `to()` and `toChannel()` gain type constraints.
+ *
+ * @example
+ * const manager = new TypedBroadcastManager<Channels>();
+ *
+ * // Static channel
+ * manager.to('posts', 'PostCreated', { id: 1, title: 'Hello' });
+ *
+ * // Parameterised channel
+ * manager.toChannel('private-orders.[orderId]', { orderId: 42 }, 'OrderShipped', {
+ *   orderId: 42, trackingCode: 'UPS-123',
+ * });
+ */
+export class TypedBroadcastManager<Channels extends BroadcastChannelMap> extends BroadcastManager {
+  /**
+   * Typed broadcast to a static channel (no `[param]` placeholders).
+   *
+   * TypeScript will enforce that `event` and `data` match the channel map entry.
+   * Falls back to the untyped base method for any string channel (e.g. if you
+   * need to broadcast on a dynamically constructed name).
+   */
+  to<Ch extends StaticChannels<Channels>, Ev extends EventsOf<Channels, Ch>>(
+    channel: Ch,
+    event: Ev,
+    data: PayloadOf<Channels, Ch, Ev>,
+    opts?: { exceptSocketId?: string },
+  ): void;
+  /** Untyped fallback — preserves compatibility with the base class signature. */
+  to(channel: string, event: string, data?: unknown, opts?: { exceptSocketId?: string }): void;
+  to(channel: string, event: string, data: unknown = {}, opts?: { exceptSocketId?: string }): void {
+    // `opts` is forwarded, not dropped. Declaring three parameters and omitting the fourth
+    // is not a type error on an override, so `toOthers()` silently stopped excluding
+    // anything the moment a broadcast went through this class.
+    super.to(channel, event, data, opts);
+  }
+
+  /**
+   * Typed broadcast to a parameterised channel pattern.
+   *
+   * The pattern is interpolated with `params` at runtime. TypeScript enforces
+   * that the pattern key exists in the channel map and that `event` and `data`
+   * match its declared event types.
+   *
+   * @example
+   * manager.toChannel('private-orders.[orderId]', { orderId: 42 }, 'OrderShipped', {
+   *   orderId: 42, trackingCode: 'UPS-123',
+   * });
+   */
+  toChannel<
+    Pattern extends ParameterizedChannels<Channels>,
+    Ev extends EventsOf<Channels, Pattern>,
+  >(
+    pattern: Pattern,
+    params: ChannelParamRecord<Pattern>,
+    event: Ev,
+    data: PayloadOf<Channels, Pattern, Ev>,
+  ): void {
+    const ch = interpolateChannel(pattern as string, params as Record<string, string | number>);
+    super.to(ch, event as string, data);
+  }
+
+  /**
+   * Dispatch a typed broadcast event.
+   *
+   * Accepts both `TypedBroadcastEvent` (with map-matched payload types) and the
+   * untyped `BroadcastEvent` interface, so this is a drop-in replacement for
+   * the base `send()`.
+   */
+  send(event: TypedBroadcastEvent<Channels, keyof Channels & string> | BroadcastEvent): void {
+    super.send(event);
+  }
+}

package/src/commands/ChannelListCommand.ts

@@ -0,0 +1,35 @@
+import { Command } from "@zerotal/core";
+import { Broadcast } from "../facades/Broadcast.ts";
+
+export class ChannelListCommand extends Command {
+  static override commandName = "channel:list";
+  static override description = "List registered broadcast channel authorization rules";
+  static override needsApp = true;
+
+  async run(): Promise<void> {
+    // Ensure routes/channels.ts has registered its rules.
+    const channelsFile = `${process.cwd()}/routes/channels.ts`;
+    if (await Bun.file(channelsFile).exists()) {
+      try {
+        await import(channelsFile);
+      } catch (err) {
+        this.warn(`Failed to load routes/channels.ts: ${(err as Error).message}`);
+      }
+    }
+
+    const channels = Broadcast.channels();
+    if (channels.length === 0) {
+      this.info("No channel authorization rules registered. Define them in routes/channels.ts.");
+      return;
+    }
+
+    this.section(`Broadcast channels (${channels.length})`);
+    for (const ch of channels) {
+      this.table([
+        ["Pattern", ch.pattern],
+        ["Params", ch.paramNames.length ? ch.paramNames.join(", ") : "(none)"],
+      ]);
+      this.newLine();
+    }
+  }
+}

package/src/commands/MakeChannelCommand.ts

@@ -0,0 +1,108 @@
+import { Command, tableNameFor } from "@zerotal/core";
+
+const HEADER = `// Channel authorization rules. Loaded once at boot by BroadcastProvider.
+// Patterns use the file-routing [param] placeholder syntax.
+`;
+
+const BROADCAST_IMPORT = `import { Broadcast } from "@zerotal/broadcasting";`;
+const USER_IMPORT = `import type { User } from "../app/models/User.ts";`;
+
+/**
+ * Scaffolds a channel authorization rule into `routes/channels.ts`. Channels are plain
+ * `Broadcast.channel(...)` registrations, not classes — so this appends a rule rather than
+ * creating a new file per channel.
+ *
+ * @example
+ *   bun zt make:channel Order            // -> orders.[id]   (private)
+ *   bun zt make:channel orders.[orderId] // -> orders.[orderId] (private)
+ *   bun zt make:channel chat.[roomId] -p // -> presence rule
+ */
+export class MakeChannelCommand extends Command {
+  static override commandName = "make:channel";
+  static override description = "Add a channel authorization rule to routes/channels.ts";
+  static override needsApp = false;
+  static override args = [
+    {
+      name: "name",
+      required: true,
+      description: "Channel pattern or model name (e.g. orders.[orderId] or Order)",
+    },
+  ];
+  static override flags = [
+    {
+      name: "presence",
+      short: "p",
+      type: "boolean" as const,
+      description: "Generate a presence-channel rule (returns member data)",
+      default: false,
+    },
+  ];
+
+  async run(): Promise<void> {
+    const raw = this.args["name"]!;
+    const presence = this.flags["presence"] as boolean;
+    const pattern = normalizePattern(raw);
+    const path = "routes/channels.ts";
+
+    let content = (await Bun.file(path).exists())
+      ? await Bun.file(path).text()
+      : `${HEADER}${BROADCAST_IMPORT}\n${USER_IMPORT}\n`;
+
+    if (content.includes(`Broadcast.channel("${pattern}"`)) {
+      this.error(`A rule for "${pattern}" already exists in ${path}.`);
+      return;
+    }
+
+    // Ensure the required imports exist when appending to a hand-written file.
+    if (!content.includes("@zerotal/broadcasting")) {
+      content = `${BROADCAST_IMPORT}\n${content}`;
+    }
+    if (!content.includes("models/User")) {
+      content = content.replace(BROADCAST_IMPORT, `${BROADCAST_IMPORT}\n${USER_IMPORT}`);
+    }
+
+    content = `${content.replace(/\n*$/, "")}\n\n${channelBlock(pattern, presence)}\n`;
+    await Bun.write(path, content);
+    this.info(`Added ${presence ? "presence" : "private"} channel rule "${pattern}" to ${path}`);
+  }
+}
+
+/** A bare model-ish name (no dot, no bracket) becomes `<plural snake>.[id]`. `Order` -> `orders.[id]`. */
+function normalizePattern(name: string): string {
+  if (!name.includes(".") && !name.includes("[")) {
+    return `${tableNameFor(name)}.[id]`;
+  }
+  return name;
+}
+
+/** Extract `[param]` names from a channel pattern, in order. */
+function paramNames(pattern: string): string[] {
+  const out: string[] = [];
+  const re = /\[(\w+)\]/g;
+  let m: RegExpExecArray | null;
+  while ((m = re.exec(pattern)) !== null) out.push(m[1]!);
+  return out;
+}
+
+function channelBlock(pattern: string, presence: boolean): string {
+  const params = paramNames(pattern);
+  // Channel params are unused in the stub body; prefix with `_` so they pass noUnusedParameters.
+  // Rename (drop the underscore) when you reference them.
+  const sig = ["user: User", ...params.map((p) => `_${p}: string`)].join(", ");
+  const subject = params.length ? params.map((p) => `\`${p}\``).join(", ") : "this channel";
+
+  if (presence) {
+    return `// ${pattern} — presence channel: return member data to authorize + publish presence, or null to deny.
+Broadcast.channel("${pattern}", (${sig}) => {
+  if (user == null) return null;
+  // TODO: authorize \`user\` against ${subject}, then return the info to expose to other members.
+  return { id: user.id };
+});`;
+  }
+
+  return `// ${pattern} — private channel: return true when the user may listen.
+Broadcast.channel("${pattern}", (${sig}) => {
+  // TODO: authorize \`user\` against ${subject}.
+  return user != null;
+});`;
+}

package/src/config.ts

@@ -0,0 +1,106 @@
+import { deepMerge } from "@zerotal/core";
+import type { ConfigValidator, ConfigIssue } from "@zerotal/core/config";
+
+export interface BroadcastConfigShape {
+  /** WebSocket upgrade path. Default: '/app/ws'. For the pusher driver, clients connect to /app/{APP_KEY}. */
+  path: string;
+  /**
+   * Broadcast driver.
+   *  - `'null'`   - disabled (default)
+   *  - `'ws'`     - single-server in-process WebSocket (Zerotal native protocol)
+   *  - `'redis'`  - Redis Pub/Sub fan-out for horizontal scaling (Zerotal native protocol)
+   *  - `'pusher'` - Pusher-compatible wire protocol (works with any Pusher-protocol client)
+   */
+  driver: "null" | "ws" | "redis" | "pusher";
+  /**
+   * Redis connection options - required when driver is `'redis'`.
+   * @example
+   * redis: { url: Bun.env.REDIS_URL ?? 'redis://localhost:6379' }
+   */
+  redis?: { url: string };
+  /**
+   * Pusher credentials - required when driver is `'pusher'`.
+   * Configure a Pusher-compatible client to connect to ws://host/app/{appKey}.
+   * @example
+   * pusher: {
+   *   appKey:    Bun.env.PUSHER_APP_KEY!,
+   *   appSecret: Bun.env.PUSHER_APP_SECRET!,
+   * }
+   */
+  pusher?: {
+    appKey: string;
+    appSecret: string;
+  };
+}
+
+const defaults: BroadcastConfigShape = {
+  path: "/app/ws",
+  driver: "null",
+};
+
+export function BroadcastConfig(
+  overrides: Partial<BroadcastConfigShape> = {},
+): BroadcastConfigShape {
+  return deepMerge(defaults, overrides);
+}
+
+const DRIVERS = new Set<string>(["null", "ws", "redis", "pusher"]);
+
+/**
+ * Validate the `broadcasting` config namespace at boot. A driver whose required
+ * credentials are missing can never deliver a message, so those are errors in
+ * any environment. Registered by {@link BroadcastProvider} via
+ * `app.registerConfigValidator("broadcasting", …)`.
+ */
+export const validateBroadcastConfig: ConfigValidator = (value) => {
+  const cfg = value as Partial<BroadcastConfigShape> | undefined;
+  const issues: ConfigIssue[] = [];
+  const driver = cfg?.driver ?? "null";
+
+  if (!DRIVERS.has(driver)) {
+    issues.push({
+      level: "error",
+      message: `broadcasting.driver "${driver}" is unknown — use "null", "ws", "redis", or "pusher".`,
+    });
+    return issues;
+  }
+
+  if (driver === "redis") {
+    const url = cfg?.redis?.url ?? "";
+    if (url.length === 0) {
+      issues.push({
+        level: "error",
+        message:
+          'broadcasting.driver is "redis" but broadcasting.redis.url is unset — an unset ' +
+          "REDIS_URL is the usual culprit. Point it at the Redis instance all servers share.",
+      });
+    } else if (!/^rediss?:\/\//.test(url)) {
+      issues.push({
+        level: "error",
+        message:
+          "broadcasting.redis.url does not start with redis:// (or rediss:// for TLS) — " +
+          "set a full Redis connection URL.",
+      });
+    }
+  }
+
+  if (driver === "pusher") {
+    if (!cfg?.pusher?.appKey || !cfg.pusher.appSecret) {
+      issues.push({
+        level: "error",
+        message:
+          'broadcasting.driver is "pusher" but pusher.appKey/appSecret are not both set — ' +
+          "clients cannot authenticate to private channels without them.",
+      });
+    }
+  }
+
+  return issues;
+};
+
+// Register this package's config namespace for typed config() dot-paths.
+declare module "@zerotal/core" {
+  interface ConfigRegistry {
+    broadcasting: BroadcastConfigShape;
+  }
+}

package/src/currentSocketId.ts

@@ -0,0 +1,6 @@
+import { RequestContext } from "@zerotal/core";
+
+/** Read the client's Echo socket id from the current request's `X-Socket-ID` header, if any. */
+export function currentSocketId(): string | undefined {
+  return RequestContext.tryGet()?.header("x-socket-id") ?? undefined;
+}

package/src/errors.ts

@@ -0,0 +1,32 @@
+import { ZerotalError } from "@zerotal/core";
+
+/** Base class for all @zerotal/broadcasting errors. */
+export class BroadcastError extends ZerotalError {
+  constructor(
+    message: string,
+    code = "E_BROADCAST",
+    status = 500,
+    context?: Record<string, unknown>,
+  ) {
+    super(message, code, status, context);
+  }
+}
+
+/** Thrown when the Broadcast facade is used before BroadcastProvider is registered. */
+export class BroadcastProviderNotRegisteredError extends BroadcastError {
+  constructor() {
+    super("[Zerotal] BroadcastProvider not registered.", "E_BROADCAST_NOT_REGISTERED", 500);
+  }
+}
+
+/** Thrown when a channel pattern is interpolated without a required parameter. */
+export class MissingChannelParameterError extends BroadcastError {
+  constructor(key: string) {
+    super(
+      `[Zerotal Broadcasting] Missing channel parameter: "${key}"`,
+      "E_BROADCAST_MISSING_PARAM",
+      500,
+      { key },
+    );
+  }
+}

package/src/facades/Broadcast.ts

@@ -0,0 +1,135 @@
+import { currentApp } from "@zerotal/core";
+import { BroadcastProviderNotRegisteredError } from "../errors.ts";
+import { BroadcastFake } from "../BroadcastFake.ts";
+import { channelRegistry } from "../ChannelRegistry.ts";
+import type { ChannelCallback } from "../ChannelRegistry.ts";
+import { AnonymousBroadcast } from "../AnonymousBroadcast.ts";
+import { privateChannel, presenceChannel } from "../Channel.ts";
+import type { BroadcastManager } from "../BroadcastManager.ts";
+import type { BroadcastEvent } from "../types.ts";
+import type { PresenceMember } from "../BroadcastManager.ts";
+
+/**
+ * Test-only override. When set by `Broadcast.fake()`, it takes priority over the
+ * container binding so tests can assert broadcasts without a live driver. This
+ * is the package's single documented test hatch (cf. `DB._connection`); the
+ * container remains the source of truth in production.
+ */
+let _fake: BroadcastFake | null = null;
+
+/**
+ * Broadcast facade — thin proxy to the active BroadcastManager.
+ *
+ * @example
+ * // In a controller
+ * Broadcast.send(new PostUpdated(post));
+ * Broadcast.to('posts', 'PostDeleted', { id: post.id });
+ *
+ * // In tests
+ * const fake = Broadcast.fake();
+ * // ... trigger action ...
+ * fake.assertBroadcast('PostUpdated', 'posts');
+ * Broadcast.resetFake();
+ */
+export class Broadcast {
+  private static _get(): BroadcastManager | BroadcastFake {
+    if (_fake) return _fake;
+    try {
+      return currentApp().container.makeSync("broadcast");
+    } catch {
+      throw new BroadcastProviderNotRegisteredError();
+    }
+  }
+
+  /**
+   * Register a channel authorization callback. Call this in `routes/channels.ts`.
+   *
+   * Patterns use `[param]` placeholders (one channel segment each), passed to the callback
+   * positionally after the authenticated user. Return a boolean for private channels, or a
+   * member-data object for presence channels (`false`/`null` to deny).
+   *
+   * @example
+   * // routes/channels.ts
+   * Broadcast.channel("orders.[orderId]", async (user: User, orderId: string) => {
+   *   return user.id === (await Order.findOrNew(orderId)).userId;
+   * });
+   *
+   * Broadcast.channel("chat.[roomId]", (user: User, roomId: string) => {
+   *   return user.canJoin(roomId) ? { id: user.id, name: user.name } : null;
+   * });
+   */
+  static channel(pattern: string, callback: ChannelCallback): void {
+    channelRegistry.register(pattern, callback);
+  }
+
+  /** Registered channel patterns (for inspection / `channel:list`). */
+  static channels(): { pattern: string; paramNames: string[] }[] {
+    return channelRegistry.all();
+  }
+
+  /**
+   * Begin an anonymous broadcast (no event class) on a public channel.
+   * @example Broadcast.on(`orders.${id}`).as("OrderPlaced").with(order).send();
+   */
+  static on(channel: string): AnonymousBroadcast {
+    return new AnonymousBroadcast(channel);
+  }
+
+  /** Anonymous broadcast on a private channel (prefixes `private-`). */
+  static private(channel: string): AnonymousBroadcast {
+    return new AnonymousBroadcast(privateChannel(channel));
+  }
+
+  /** Anonymous broadcast on a presence channel (prefixes `presence-`). */
+  static presence(channel: string): AnonymousBroadcast {
+    return new AnonymousBroadcast(presenceChannel(channel));
+  }
+
+  /**
+   * Broadcast an event to all channels declared in broadcastOn().
+   * `opts.exceptSocketId` skips one connection (used by `broadcast(event).toOthers()`).
+   */
+  static send(event: BroadcastEvent, opts?: { exceptSocketId?: string }): void {
+    Broadcast._get().send(event, opts);
+  }
+
+  /**
+   * Broadcast a raw event to a specific channel.
+   * @example
+   * Broadcast.to('posts', 'PostViewed', { id: 1, viewedAt: new Date() });
+   */
+  static to(
+    channel: string,
+    eventName: string,
+    data?: unknown,
+    opts?: { exceptSocketId?: string },
+  ): void {
+    Broadcast._get().to(channel, eventName, data, opts);
+  }
+
+  /**
+   * Return all members currently subscribed to a presence channel.
+   * Only works with the real BroadcastManager (not the fake).
+   */
+  static getMembers(channel: string): PresenceMember[] {
+    const inst = Broadcast._get();
+    if (inst instanceof BroadcastFake) return [];
+    return inst.getMembers(channel);
+  }
+
+  /**
+   * Replace the real manager with a BroadcastFake for the duration of the test.
+   * Call `Broadcast.resetFake()` in afterEach to restore.
+   *
+   * @returns the fake, for assertions
+   */
+  static fake(): BroadcastFake {
+    _fake = new BroadcastFake();
+    return _fake;
+  }
+
+  /** Remove the fake and restore container-backed resolution. */
+  static resetFake(): void {
+    _fake = null;
+  }
+}

package/src/global.d.ts

@@ -0,0 +1,10 @@
+// Ambient declarations specific to this package.
+// Bun, Node (node:*), and bun:test types come from @types/bun (→ bun-types).
+// Only declarations bun-types does NOT provide are kept here.
+
+interface ServerWebSocket<T = unknown> {
+  readonly data: T;
+  send(message: string | Uint8Array): void;
+  close(code?: number, reason?: string): void;
+  readyState: number;
+}

package/src/index.ts

@@ -0,0 +1,36 @@
+export { BroadcastManager } from "./BroadcastManager.ts";
+export type { PresenceMember, PresenceAuthFn } from "./BroadcastManager.ts";
+export { TypedBroadcastManager } from "./TypedBroadcastManager.ts";
+export type {
+  BroadcastChannelMap,
+  ChannelParams,
+  ChannelParamRecord,
+  EventsOf,
+  PayloadOf,
+  StaticChannels,
+  ParameterizedChannels,
+  TypedBroadcastEvent,
+} from "./TypedBroadcastManager.ts";
+export { PusherCompatManager } from "./PusherCompatManager.ts";
+export type { PusherPresenceResolver } from "./PusherCompatManager.ts";
+export { RedisBroadcastDriver } from "./RedisBroadcastDriver.ts";
+export { BroadcastFake } from "./BroadcastFake.ts";
+export { Broadcast } from "./facades/Broadcast.ts";
+export { BroadcastProvider } from "./provider/BroadcastProvider.ts";
+export { BroadcastConfig } from "./config.ts";
+export { channel, privateChannel, presenceChannel, isPrivateChannel } from "./Channel.ts";
+export { BroadcastingEvent, broadcastOnce } from "./BroadcastingEvent.ts";
+export { broadcastsModelEvents } from "./BroadcastsModelEvents.ts";
+export type {
+  BroadcastsModelEventsOptions,
+  ModelBroadcastEventName,
+} from "./BroadcastsModelEvents.ts";
+export { broadcast, PendingBroadcast } from "./PendingBroadcast.ts";
+export { AnonymousBroadcast } from "./AnonymousBroadcast.ts";
+export { ChannelRegistry, channelRegistry, compileChannelPattern } from "./ChannelRegistry.ts";
+export type { ChannelCallback, PresenceMemberData, AuthorizeResult } from "./ChannelRegistry.ts";
+export type { BroadcastEvent, WsConnectionData, ChannelAuthFn } from "./types.ts";
+export type { RecordedBroadcast, RecordedBroadcast as BroadcastRecord } from "./BroadcastFake.ts";
+
+// Typed error vocabulary
+export * from "./errors.ts";