@parsrun/realtime 0.1.0

package/dist/index.js

@@ -0,0 +1,1084 @@
+// src/types.ts
+var RealtimeError = class extends Error {
+  constructor(message, code, cause) {
+    super(message);
+    this.code = code;
+    this.cause = cause;
+    this.name = "RealtimeError";
+  }
+};
+var RealtimeErrorCodes = {
+  CONNECTION_FAILED: "CONNECTION_FAILED",
+  CHANNEL_NOT_FOUND: "CHANNEL_NOT_FOUND",
+  UNAUTHORIZED: "UNAUTHORIZED",
+  MESSAGE_TOO_LARGE: "MESSAGE_TOO_LARGE",
+  RATE_LIMITED: "RATE_LIMITED",
+  ADAPTER_ERROR: "ADAPTER_ERROR",
+  INVALID_MESSAGE: "INVALID_MESSAGE"
+};
+function createMessage(options) {
+  return {
+    id: crypto.randomUUID(),
+    event: options.event,
+    channel: options.channel,
+    data: options.data,
+    senderId: options.senderId,
+    timestamp: Date.now(),
+    metadata: options.metadata
+  };
+}
+function parseSSEEvent(eventString) {
+  try {
+    const lines = eventString.split("\n");
+    let event = "message";
+    let data = "";
+    let id = "";
+    for (const line of lines) {
+      if (line.startsWith("event:")) {
+        event = line.slice(6).trim();
+      } else if (line.startsWith("data:")) {
+        data = line.slice(5).trim();
+      } else if (line.startsWith("id:")) {
+        id = line.slice(3).trim();
+      }
+    }
+    if (!data) return null;
+    const parsed = JSON.parse(data);
+    return {
+      id: id || parsed.id || crypto.randomUUID(),
+      event,
+      channel: parsed.channel || "",
+      data: parsed.data ?? parsed,
+      senderId: parsed.senderId,
+      timestamp: parsed.timestamp || Date.now(),
+      metadata: parsed.metadata
+    };
+  } catch {
+    return null;
+  }
+}
+function formatSSEEvent(message) {
+  const lines = [];
+  lines.push(`id:${message.id}`);
+  lines.push(`event:${message.event}`);
+  lines.push(`data:${JSON.stringify(message)}`);
+  lines.push("");
+  return lines.join("\n") + "\n";
+}
+
+// src/adapters/sse.ts
+var DEFAULT_OPTIONS = {
+  pingInterval: 3e4,
+  connectionTimeout: 0,
+  maxConnectionsPerChannel: 1e3,
+  retryDelay: 3e3
+};
+var SSEAdapter = class {
+  type = "sse";
+  options;
+  connections = /* @__PURE__ */ new Map();
+  channelSubscribers = /* @__PURE__ */ new Map();
+  presence = /* @__PURE__ */ new Map();
+  pingIntervalId = null;
+  constructor(options = {}) {
+    this.options = {
+      pingInterval: options.pingInterval ?? DEFAULT_OPTIONS.pingInterval,
+      connectionTimeout: options.connectionTimeout ?? DEFAULT_OPTIONS.connectionTimeout,
+      maxConnectionsPerChannel: options.maxConnectionsPerChannel ?? DEFAULT_OPTIONS.maxConnectionsPerChannel,
+      retryDelay: options.retryDelay ?? DEFAULT_OPTIONS.retryDelay
+    };
+    if (this.options.pingInterval > 0) {
+      this.startPingInterval();
+    }
+  }
+  /**
+   * Create SSE response for a new connection
+   */
+  createConnection(sessionId, userId) {
+    const { readable, writable } = new TransformStream();
+    const writer = writable.getWriter();
+    const connection = {
+      sessionId,
+      userId,
+      channels: /* @__PURE__ */ new Set(),
+      writer,
+      state: "open",
+      createdAt: Date.now(),
+      lastPingAt: Date.now()
+    };
+    this.connections.set(sessionId, connection);
+    const encoder = new TextEncoder();
+    writer.write(encoder.encode(`retry:${this.options.retryDelay}
+
+`));
+    const response = new Response(readable, {
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        "Connection": "keep-alive",
+        "X-Accel-Buffering": "no"
+        // Disable nginx buffering
+      }
+    });
+    return { response, connection };
+  }
+  /**
+   * Close a connection
+   */
+  async closeConnection(sessionId) {
+    const connection = this.connections.get(sessionId);
+    if (!connection) return;
+    connection.state = "closed";
+    for (const channel of connection.channels) {
+      await this.unsubscribe(channel, sessionId);
+      await this.removePresence(channel, sessionId);
+    }
+    try {
+      await connection.writer.close();
+    } catch {
+    }
+    this.connections.delete(sessionId);
+  }
+  /**
+   * Get a connection by session ID
+   */
+  getConnection(sessionId) {
+    return this.connections.get(sessionId);
+  }
+  /**
+   * Get all active connections
+   */
+  getConnections() {
+    return this.connections;
+  }
+  // ============================================================================
+  // RealtimeAdapter Implementation
+  // ============================================================================
+  async subscribe(channel, sessionId, handler) {
+    const connection = this.connections.get(sessionId);
+    if (!connection) {
+      throw new RealtimeError(
+        "Connection not found",
+        RealtimeErrorCodes.CONNECTION_FAILED
+      );
+    }
+    const subscribers = this.channelSubscribers.get(channel);
+    if (subscribers && subscribers.size >= this.options.maxConnectionsPerChannel) {
+      throw new RealtimeError(
+        "Channel subscriber limit reached",
+        RealtimeErrorCodes.RATE_LIMITED
+      );
+    }
+    if (!this.channelSubscribers.has(channel)) {
+      this.channelSubscribers.set(channel, /* @__PURE__ */ new Map());
+    }
+    this.channelSubscribers.get(channel).set(sessionId, handler);
+    connection.channels.add(channel);
+    await this.sendToConnection(connection, {
+      id: crypto.randomUUID(),
+      event: "channel:subscribe",
+      channel,
+      data: { channel },
+      timestamp: Date.now()
+    });
+  }
+  async unsubscribe(channel, sessionId) {
+    const subscribers = this.channelSubscribers.get(channel);
+    if (subscribers) {
+      subscribers.delete(sessionId);
+      if (subscribers.size === 0) {
+        this.channelSubscribers.delete(channel);
+      }
+    }
+    const connection = this.connections.get(sessionId);
+    if (connection) {
+      connection.channels.delete(channel);
+    }
+  }
+  async publish(channel, message) {
+    const subscribers = this.channelSubscribers.get(channel);
+    if (!subscribers) return;
+    const promises = [];
+    for (const [sessionId, handler] of subscribers) {
+      const connection = this.connections.get(sessionId);
+      if (connection && connection.state === "open") {
+        promises.push(this.sendToConnection(connection, message));
+        try {
+          const result = handler(message);
+          if (result instanceof Promise) {
+            promises.push(result.then(() => {
+            }));
+          }
+        } catch {
+        }
+      }
+    }
+    await Promise.allSettled(promises);
+  }
+  async sendToSession(sessionId, message) {
+    const connection = this.connections.get(sessionId);
+    if (!connection || connection.state !== "open") {
+      return false;
+    }
+    try {
+      await this.sendToConnection(connection, message);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async getSubscribers(channel) {
+    const subscribers = this.channelSubscribers.get(channel);
+    return subscribers ? Array.from(subscribers.keys()) : [];
+  }
+  async setPresence(channel, sessionId, userId, data) {
+    if (!this.presence.has(channel)) {
+      this.presence.set(channel, /* @__PURE__ */ new Map());
+    }
+    const now = Date.now();
+    const existing = this.presence.get(channel).get(sessionId);
+    const user = {
+      userId,
+      sessionId,
+      data,
+      joinedAt: existing?.joinedAt ?? now,
+      lastSeenAt: now
+    };
+    this.presence.get(channel).set(sessionId, user);
+    const eventType = existing ? "presence:update" : "presence:join";
+    await this.publish(channel, {
+      id: crypto.randomUUID(),
+      event: eventType,
+      channel,
+      data: {
+        type: existing ? "update" : "join",
+        user,
+        presence: await this.getPresence(channel)
+      },
+      timestamp: now
+    });
+  }
+  async removePresence(channel, sessionId) {
+    const channelPresence = this.presence.get(channel);
+    if (!channelPresence) return;
+    const user = channelPresence.get(sessionId);
+    if (!user) return;
+    channelPresence.delete(sessionId);
+    if (channelPresence.size === 0) {
+      this.presence.delete(channel);
+    }
+    await this.publish(channel, {
+      id: crypto.randomUUID(),
+      event: "presence:leave",
+      channel,
+      data: {
+        type: "leave",
+        user,
+        presence: await this.getPresence(channel)
+      },
+      timestamp: Date.now()
+    });
+  }
+  async getPresence(channel) {
+    const channelPresence = this.presence.get(channel);
+    if (!channelPresence) return [];
+    return Array.from(channelPresence.values());
+  }
+  async close() {
+    if (this.pingIntervalId) {
+      clearInterval(this.pingIntervalId);
+      this.pingIntervalId = null;
+    }
+    const closePromises = Array.from(this.connections.keys()).map(
+      (sessionId) => this.closeConnection(sessionId)
+    );
+    await Promise.allSettled(closePromises);
+    this.connections.clear();
+    this.channelSubscribers.clear();
+    this.presence.clear();
+  }
+  // ============================================================================
+  // Private Methods
+  // ============================================================================
+  async sendToConnection(connection, message) {
+    if (connection.state !== "open") return;
+    const encoder = new TextEncoder();
+    const sseEvent = formatSSEEvent(message);
+    try {
+      await connection.writer.write(encoder.encode(sseEvent));
+    } catch (err) {
+      connection.state = "closed";
+      await this.closeConnection(connection.sessionId);
+    }
+  }
+  startPingInterval() {
+    this.pingIntervalId = setInterval(() => {
+      this.sendPingToAll();
+    }, this.options.pingInterval);
+  }
+  async sendPingToAll() {
+    const now = Date.now();
+    const encoder = new TextEncoder();
+    const pingEvent = `event:ping
+data:${now}
+
+`;
+    for (const [sessionId, connection] of this.connections) {
+      if (connection.state !== "open") continue;
+      if (this.options.connectionTimeout > 0 && now - connection.lastPingAt > this.options.connectionTimeout) {
+        await this.closeConnection(sessionId);
+        continue;
+      }
+      try {
+        await connection.writer.write(encoder.encode(pingEvent));
+        connection.lastPingAt = now;
+      } catch {
+        await this.closeConnection(sessionId);
+      }
+    }
+  }
+  /**
+   * Update last ping time (call when receiving client ping)
+   */
+  updateLastPing(sessionId) {
+    const connection = this.connections.get(sessionId);
+    if (connection) {
+      connection.lastPingAt = Date.now();
+    }
+  }
+  /**
+   * Get statistics
+   */
+  getStats() {
+    const connectionsByChannel = {};
+    for (const [channel, subscribers] of this.channelSubscribers) {
+      connectionsByChannel[channel] = subscribers.size;
+    }
+    return {
+      totalConnections: this.connections.size,
+      totalChannels: this.channelSubscribers.size,
+      connectionsByChannel
+    };
+  }
+};
+function createSSEAdapter(options) {
+  return new SSEAdapter(options);
+}
+
+// src/adapters/durable-objects.ts
+var RealtimeChannelDO = class {
+  sessions = /* @__PURE__ */ new Map();
+  presence = /* @__PURE__ */ new Map();
+  channelName = "";
+  state;
+  constructor(state, _env) {
+    this.state = state;
+    this.state.getWebSockets().forEach((ws) => {
+      const meta = ws.deserializeAttachment();
+      if (meta) {
+        this.sessions.set(meta.sessionId, {
+          sessionId: meta.sessionId,
+          userId: meta.userId,
+          webSocket: ws,
+          state: "open",
+          createdAt: Date.now()
+        });
+      }
+    });
+  }
+  async fetch(request) {
+    const url = new URL(request.url);
+    const pathParts = url.pathname.split("/").filter(Boolean);
+    const lastPart = pathParts[pathParts.length - 1];
+    if (lastPart) {
+      this.channelName = lastPart;
+    }
+    if (request.headers.get("Upgrade") === "websocket") {
+      return this.handleWebSocketUpgrade(request);
+    }
+    switch (url.pathname.split("/").pop()) {
+      case "broadcast":
+        return this.handleBroadcast(request);
+      case "presence":
+        return this.handleGetPresence();
+      case "info":
+        return this.handleGetInfo();
+      case "send":
+        return this.handleSendToUser(request);
+      default:
+        return new Response("Not found", { status: 404 });
+    }
+  }
+  // ============================================================================
+  // WebSocket Handling
+  // ============================================================================
+  handleWebSocketUpgrade(request) {
+    const url = new URL(request.url);
+    const sessionId = url.searchParams.get("sessionId") || crypto.randomUUID();
+    const userId = url.searchParams.get("userId") || void 0;
+    const pair = new WebSocketPair();
+    const client = pair[0];
+    const server = pair[1];
+    server.serializeAttachment({ sessionId, userId });
+    this.state.acceptWebSocket(server);
+    const session = {
+      sessionId,
+      userId,
+      webSocket: server,
+      state: "open",
+      createdAt: Date.now()
+    };
+    this.sessions.set(sessionId, session);
+    server.send(
+      JSON.stringify(
+        createMessage({
+          event: "connection:open",
+          channel: this.channelName,
+          data: { sessionId, userId }
+        })
+      )
+    );
+    return new Response(null, { status: 101, webSocket: client });
+  }
+  async webSocketMessage(ws, message) {
+    const session = this.getSessionByWebSocket(ws);
+    if (!session) return;
+    try {
+      const data = typeof message === "string" ? message : new TextDecoder().decode(message);
+      const parsed = JSON.parse(data);
+      await this.handleMessage(session, parsed);
+    } catch {
+    }
+  }
+  async webSocketClose(ws, code, reason, _wasClean) {
+    const session = this.getSessionByWebSocket(ws);
+    if (!session) return;
+    this.presence.delete(session.sessionId);
+    await this.broadcastPresenceUpdate();
+    this.sessions.delete(session.sessionId);
+    await this.broadcastToAll({
+      event: "connection:close",
+      channel: this.channelName,
+      data: {
+        sessionId: session.sessionId,
+        userId: session.userId,
+        code,
+        reason
+      }
+    });
+  }
+  async webSocketError(ws, _error) {
+    const session = this.getSessionByWebSocket(ws);
+    if (session) {
+      session.state = "closed";
+      this.sessions.delete(session.sessionId);
+      this.presence.delete(session.sessionId);
+    }
+  }
+  // ============================================================================
+  // Message Handling
+  // ============================================================================
+  async handleMessage(session, message) {
+    switch (message.event) {
+      case "ping":
+        session.webSocket.send(
+          JSON.stringify(
+            createMessage({
+              event: "pong",
+              channel: this.channelName,
+              data: { timestamp: Date.now() }
+            })
+          )
+        );
+        break;
+      case "presence:join":
+        await this.handlePresenceJoin(session, message.data);
+        break;
+      case "presence:update":
+        await this.handlePresenceUpdate(session, message.data);
+        break;
+      case "presence:leave":
+        await this.handlePresenceLeave(session);
+        break;
+      case "broadcast":
+        await this.broadcastToAll(
+          {
+            event: message.event,
+            channel: this.channelName,
+            data: message.data,
+            senderId: session.sessionId
+          },
+          session.sessionId
+        );
+        break;
+      default:
+        await this.broadcastToAll(
+          {
+            event: message.event,
+            channel: this.channelName,
+            data: message.data,
+            senderId: session.sessionId
+          },
+          session.sessionId
+        );
+    }
+  }
+  // ============================================================================
+  // Presence Handling
+  // ============================================================================
+  async handlePresenceJoin(session, data) {
+    const now = Date.now();
+    const user = {
+      userId: session.userId || session.sessionId,
+      sessionId: session.sessionId,
+      data,
+      joinedAt: now,
+      lastSeenAt: now
+    };
+    this.presence.set(session.sessionId, user);
+    session.presence = data;
+    await this.broadcastPresenceUpdate();
+  }
+  async handlePresenceUpdate(session, data) {
+    const existing = this.presence.get(session.sessionId);
+    if (existing) {
+      existing.data = data;
+      existing.lastSeenAt = Date.now();
+      session.presence = data;
+      await this.broadcastPresenceUpdate();
+    }
+  }
+  async handlePresenceLeave(session) {
+    this.presence.delete(session.sessionId);
+    session.presence = void 0;
+    await this.broadcastPresenceUpdate();
+  }
+  async broadcastPresenceUpdate() {
+    const presenceList = Array.from(this.presence.values());
+    await this.broadcastToAll({
+      event: "presence:sync",
+      channel: this.channelName,
+      data: presenceList
+    });
+  }
+  // ============================================================================
+  // REST API Handlers
+  // ============================================================================
+  async handleBroadcast(request) {
+    try {
+      const body = await request.json();
+      await this.broadcastToAll({
+        event: body.event,
+        channel: this.channelName,
+        data: body.data
+      });
+      return new Response(JSON.stringify({ success: true }), {
+        headers: { "Content-Type": "application/json" }
+      });
+    } catch (err) {
+      return new Response(
+        JSON.stringify({ success: false, error: String(err) }),
+        { status: 400, headers: { "Content-Type": "application/json" } }
+      );
+    }
+  }
+  handleGetPresence() {
+    const presenceList = Array.from(this.presence.values());
+    return new Response(JSON.stringify(presenceList), {
+      headers: { "Content-Type": "application/json" }
+    });
+  }
+  handleGetInfo() {
+    return new Response(
+      JSON.stringify({
+        channel: this.channelName,
+        connections: this.sessions.size,
+        presence: this.presence.size
+      }),
+      { headers: { "Content-Type": "application/json" } }
+    );
+  }
+  async handleSendToUser(request) {
+    try {
+      const body = await request.json();
+      let sent = false;
+      for (const session of this.sessions.values()) {
+        if (session.userId === body.userId && session.state === "open") {
+          session.webSocket.send(
+            JSON.stringify(
+              createMessage({
+                event: body.event,
+                channel: this.channelName,
+                data: body.data
+              })
+            )
+          );
+          sent = true;
+        }
+      }
+      return new Response(JSON.stringify({ success: true, sent }), {
+        headers: { "Content-Type": "application/json" }
+      });
+    } catch (err) {
+      return new Response(
+        JSON.stringify({ success: false, error: String(err) }),
+        { status: 400, headers: { "Content-Type": "application/json" } }
+      );
+    }
+  }
+  // ============================================================================
+  // Helpers
+  // ============================================================================
+  getSessionByWebSocket(ws) {
+    for (const session of this.sessions.values()) {
+      if (session.webSocket === ws) {
+        return session;
+      }
+    }
+    return void 0;
+  }
+  async broadcastToAll(messageData, excludeSessionId) {
+    const message = createMessage(messageData);
+    const payload = JSON.stringify(message);
+    for (const session of this.sessions.values()) {
+      if (session.sessionId === excludeSessionId) continue;
+      if (session.state !== "open") continue;
+      try {
+        session.webSocket.send(payload);
+      } catch {
+        session.state = "closed";
+      }
+    }
+  }
+};
+var DurableObjectsAdapter = class {
+  type = "durable-objects";
+  namespace;
+  channelPrefix;
+  localHandlers = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.namespace = options.namespace;
+    this.channelPrefix = options.channelPrefix ?? "channel:";
+  }
+  /**
+   * Get Durable Object stub for a channel
+   */
+  getChannelStub(channel) {
+    const id = this.namespace.idFromName(`${this.channelPrefix}${channel}`);
+    return this.namespace.get(id);
+  }
+  /**
+   * Get WebSocket URL for a channel
+   */
+  getWebSocketUrl(channel, sessionId, userId, baseUrl) {
+    const base = baseUrl || "wss://your-worker.your-subdomain.workers.dev";
+    const params = new URLSearchParams({ sessionId });
+    if (userId) params.set("userId", userId);
+    return `${base}/realtime/${channel}?${params}`;
+  }
+  // ============================================================================
+  // RealtimeAdapter Implementation
+  // ============================================================================
+  async subscribe(channel, sessionId, handler) {
+    if (!this.localHandlers.has(channel)) {
+      this.localHandlers.set(channel, /* @__PURE__ */ new Map());
+    }
+    this.localHandlers.get(channel).set(sessionId, handler);
+  }
+  async unsubscribe(channel, sessionId) {
+    const handlers = this.localHandlers.get(channel);
+    if (handlers) {
+      handlers.delete(sessionId);
+      if (handlers.size === 0) {
+        this.localHandlers.delete(channel);
+      }
+    }
+  }
+  async publish(channel, message) {
+    const stub = this.getChannelStub(channel);
+    await stub.fetch(new Request("https://do/broadcast", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        event: message.event,
+        data: message.data
+      })
+    }));
+    const handlers = this.localHandlers.get(channel);
+    if (handlers) {
+      for (const handler of handlers.values()) {
+        try {
+          await handler(message);
+        } catch {
+        }
+      }
+    }
+  }
+  async sendToSession(_sessionId, _message) {
+    return false;
+  }
+  async getSubscribers(channel) {
+    const handlers = this.localHandlers.get(channel);
+    return handlers ? Array.from(handlers.keys()) : [];
+  }
+  async setPresence(_channel, _sessionId, _userId, _data) {
+  }
+  async removePresence(_channel, _sessionId) {
+  }
+  async getPresence(channel) {
+    const stub = this.getChannelStub(channel);
+    const response = await stub.fetch(new Request("https://do/presence"));
+    return response.json();
+  }
+  async close() {
+    this.localHandlers.clear();
+  }
+  /**
+   * Get channel info from Durable Object
+   */
+  async getChannelInfo(channel) {
+    const stub = this.getChannelStub(channel);
+    const response = await stub.fetch(new Request("https://do/info"));
+    return response.json();
+  }
+  /**
+   * Send message to specific user in a channel
+   */
+  async sendToUser(channel, userId, event, data) {
+    const stub = this.getChannelStub(channel);
+    const response = await stub.fetch(
+      new Request("https://do/send", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ userId, event, data })
+      })
+    );
+    const result = await response.json();
+    return result.sent;
+  }
+};
+function createDurableObjectsAdapter(options) {
+  return new DurableObjectsAdapter(options);
+}
+
+// src/hono.ts
+import { Hono } from "hono";
+function sseMiddleware(options) {
+  const adapter = new SSEAdapter(options);
+  return async (c, next) => {
+    const sessionId = c.req.query("sessionId") || crypto.randomUUID();
+    const vars = c.var;
+    const userId = typeof vars["userId"] === "string" ? vars["userId"] : void 0;
+    c.set("realtime", {
+      adapter,
+      sessionId,
+      userId
+    });
+    await next();
+  };
+}
+function createSSEHandler(adapter, options = {}) {
+  return async (c) => {
+    const sessionId = options.getSessionId?.(c) || c.req.query("sessionId") || crypto.randomUUID();
+    const vars = c.var;
+    const userId = options.getUserId?.(c) || (typeof vars["userId"] === "string" ? vars["userId"] : void 0);
+    const channels = options.getChannels?.(c) || c.req.query("channels")?.split(",") || [];
+    const { response } = adapter.createConnection(sessionId, userId);
+    for (const channel of channels) {
+      await adapter.subscribe(channel, sessionId, () => {
+      });
+    }
+    if (options.onConnect) {
+      await options.onConnect(c, sessionId);
+    }
+    c.req.raw.signal.addEventListener("abort", async () => {
+      await adapter.closeConnection(sessionId);
+      if (options.onDisconnect) {
+        await options.onDisconnect(c, sessionId);
+      }
+    });
+    return response;
+  };
+}
+function createSSERoutes(adapter, options = {}) {
+  const app = new Hono();
+  app.get("/subscribe", createSSEHandler(adapter, options));
+  app.post("/subscribe/:channel", async (c) => {
+    const channel = c.req.param("channel");
+    const sessionId = c.req.query("sessionId");
+    if (!sessionId) {
+      return c.json({ error: "sessionId required" }, 400);
+    }
+    const connection = adapter.getConnection(sessionId);
+    if (!connection) {
+      return c.json({ error: "Connection not found" }, 404);
+    }
+    await adapter.subscribe(channel, sessionId, () => {
+    });
+    return c.json({ success: true, channel });
+  });
+  app.post("/unsubscribe/:channel", async (c) => {
+    const channel = c.req.param("channel");
+    const sessionId = c.req.query("sessionId");
+    if (!sessionId) {
+      return c.json({ error: "sessionId required" }, 400);
+    }
+    await adapter.unsubscribe(channel, sessionId);
+    return c.json({ success: true, channel });
+  });
+  app.post("/broadcast/:channel", async (c) => {
+    const channel = c.req.param("channel");
+    const body = await c.req.json();
+    const message = createMessage({
+      event: body.event,
+      channel,
+      data: body.data
+    });
+    await adapter.publish(channel, message);
+    return c.json({ success: true });
+  });
+  app.get("/presence/:channel", async (c) => {
+    const channel = c.req.param("channel");
+    const presence = await adapter.getPresence(channel);
+    return c.json(presence);
+  });
+  app.post("/presence/:channel", async (c) => {
+    const channel = c.req.param("channel");
+    const sessionId = c.req.query("sessionId");
+    const userId = c.req.query("userId") || sessionId;
+    const data = await c.req.json();
+    if (!sessionId) {
+      return c.json({ error: "sessionId required" }, 400);
+    }
+    await adapter.setPresence(channel, sessionId, userId, data);
+    return c.json({ success: true });
+  });
+  app.delete("/presence/:channel", async (c) => {
+    const channel = c.req.param("channel");
+    const sessionId = c.req.query("sessionId");
+    if (!sessionId) {
+      return c.json({ error: "sessionId required" }, 400);
+    }
+    await adapter.removePresence(channel, sessionId);
+    return c.json({ success: true });
+  });
+  app.get("/stats", (c) => {
+    return c.json(adapter.getStats());
+  });
+  return app;
+}
+function createDORoutes(options) {
+  const app = new Hono();
+  const prefix = options.channelPrefix ?? "channel:";
+  app.get("/ws/:channel", async (c) => {
+    const channel = c.req.param("channel");
+    if (options.authorize) {
+      const authorized = await options.authorize(c, channel);
+      if (!authorized) {
+        return c.json({ error: "Unauthorized" }, 403);
+      }
+    }
+    const env = c.env;
+    const namespace = env[options.namespaceBinding];
+    if (!namespace) {
+      return c.json(
+        { error: `Namespace ${options.namespaceBinding} not found` },
+        500
+      );
+    }
+    const id = namespace.idFromName(`${prefix}${channel}`);
+    const stub = namespace.get(id);
+    const url = new URL(c.req.url);
+    url.pathname = `/ws/${channel}`;
+    return stub.fetch(new Request(url.toString(), c.req.raw));
+  });
+  app.post("/broadcast/:channel", async (c) => {
+    const channel = c.req.param("channel");
+    const env = c.env;
+    const namespace = env[options.namespaceBinding];
+    if (!namespace) {
+      return c.json(
+        { error: `Namespace ${options.namespaceBinding} not found` },
+        500
+      );
+    }
+    const id = namespace.idFromName(`${prefix}${channel}`);
+    const stub = namespace.get(id);
+    const body = await c.req.json();
+    const response = await stub.fetch(
+      new Request("https://do/broadcast", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body)
+      })
+    );
+    return new Response(response.body, {
+      status: response.status,
+      headers: response.headers
+    });
+  });
+  app.get("/presence/:channel", async (c) => {
+    const channel = c.req.param("channel");
+    const env = c.env;
+    const namespace = env[options.namespaceBinding];
+    if (!namespace) {
+      return c.json(
+        { error: `Namespace ${options.namespaceBinding} not found` },
+        500
+      );
+    }
+    const id = namespace.idFromName(`${prefix}${channel}`);
+    const stub = namespace.get(id);
+    const response = await stub.fetch(new Request("https://do/presence"));
+    return new Response(response.body, {
+      status: response.status,
+      headers: response.headers
+    });
+  });
+  app.get("/info/:channel", async (c) => {
+    const channel = c.req.param("channel");
+    const env = c.env;
+    const namespace = env[options.namespaceBinding];
+    if (!namespace) {
+      return c.json(
+        { error: `Namespace ${options.namespaceBinding} not found` },
+        500
+      );
+    }
+    const id = namespace.idFromName(`${prefix}${channel}`);
+    const stub = namespace.get(id);
+    const response = await stub.fetch(new Request("https://do/info"));
+    return new Response(response.body, {
+      status: response.status,
+      headers: response.headers
+    });
+  });
+  return app;
+}
+async function broadcast(adapter, channel, event, data) {
+  const message = createMessage({ event, channel, data });
+  await adapter.publish(channel, message);
+}
+async function sendToUser(adapter, channel, userId, event, data) {
+  const presence = await adapter.getPresence(channel);
+  const userSessions = presence.filter((p) => p.userId === userId);
+  const message = createMessage({ event, channel, data });
+  for (const session of userSessions) {
+    await adapter.sendToSession(session.sessionId, message);
+  }
+}
+
+// src/core/channel.ts
+var ChannelImpl = class {
+  constructor(name, adapter, sessionId) {
+    this.name = name;
+    this.adapter = adapter;
+    this.sessionId = sessionId;
+  }
+  presenceHandlers = /* @__PURE__ */ new Set();
+  async broadcast(event, data) {
+    const message = createMessage({
+      event,
+      channel: this.name,
+      data
+    });
+    await this.adapter.publish(this.name, message);
+  }
+  async send(userId, event, data) {
+    const message = createMessage({
+      event,
+      channel: this.name,
+      data,
+      metadata: { targetUserId: userId }
+    });
+    const presence = await this.adapter.getPresence(this.name);
+    for (const user of presence) {
+      if (user.userId === userId) {
+        await this.adapter.sendToSession(user.sessionId, message);
+      }
+    }
+  }
+  async getPresence() {
+    return this.adapter.getPresence(this.name);
+  }
+  subscribe(handler) {
+    this.adapter.subscribe(this.name, this.sessionId, handler);
+    return () => {
+      this.adapter.unsubscribe(this.name, this.sessionId);
+    };
+  }
+  onPresence(handler) {
+    this.presenceHandlers.add(handler);
+    return () => {
+      this.presenceHandlers.delete(handler);
+    };
+  }
+  /**
+   * Emit presence event to handlers
+   */
+  emitPresence(event) {
+    for (const handler of this.presenceHandlers) {
+      try {
+        handler(event);
+      } catch {
+      }
+    }
+  }
+  async getInfo() {
+    const subscribers = await this.adapter.getSubscribers(this.name);
+    const presence = await this.adapter.getPresence(this.name);
+    return {
+      name: this.name,
+      subscriberCount: subscribers.length,
+      presence
+    };
+  }
+};
+function createChannel(name, adapter, sessionId) {
+  return new ChannelImpl(name, adapter, sessionId);
+}
+
+// src/index.ts
+function createRealtimeAdapter(config) {
+  switch (config.adapter) {
+    case "sse":
+      return new SSEAdapter(config.sse);
+    case "durable-objects":
+      if (!config.durableObjects) {
+        throw new Error("durableObjects config required for durable-objects adapter");
+      }
+      return new DurableObjectsAdapter(config.durableObjects);
+    case "memory":
+      return new SSEAdapter({ pingInterval: 0 });
+    default:
+      throw new Error(`Unknown adapter type: ${config.adapter}`);
+  }
+}
+var index_default = {
+  createRealtimeAdapter,
+  createSSEAdapter,
+  createDurableObjectsAdapter
+};
+export {
+  ChannelImpl,
+  DurableObjectsAdapter,
+  RealtimeChannelDO,
+  RealtimeError,
+  RealtimeErrorCodes,
+  SSEAdapter,
+  broadcast,
+  createChannel,
+  createDORoutes,
+  createDurableObjectsAdapter,
+  createMessage,
+  createRealtimeAdapter,
+  createSSEAdapter,
+  createSSEHandler,
+  createSSERoutes,
+  index_default as default,
+  formatSSEEvent,
+  parseSSEEvent,
+  sendToUser,
+  sseMiddleware
+};
+//# sourceMappingURL=index.js.map