vg-x07df 1.5.0 → 1.6.1

package/dist/channel/index.cjs

@@ -0,0 +1,915 @@
+'use strict';
+
+var react = require('react');
+var livekitClient = require('livekit-client');
+var zustand = require('zustand');
+var immer = require('zustand/middleware/immer');
+var nanoid = require('nanoid');
+var jsxRuntime = require('react/jsx-runtime');
+
+// src/channel/DataChannelProvider.tsx
+var DataChannelContext = react.createContext(null);
+function useDataChannelContext() {
+  const context = react.useContext(DataChannelContext);
+  if (!context) {
+    throw new Error("useDataChannelContext must be used within DataChannelProvider");
+  }
+  return context;
+}
+function useFeatureService(featureName) {
+  const { services } = useDataChannelContext();
+  const service = services.get(featureName);
+  if (!service) {
+    throw new Error(
+      `Feature service "${featureName}" not found. Make sure it's enabled in DataChannelProvider.`
+    );
+  }
+  return service;
+}
+var defaultChatState = {
+  byId: {},
+  order: [],
+  pendingOps: {},
+  participantCache: {},
+  maxEntries: 1e3
+};
+function applyReactionToEntry(entry, emoji, participantId, op) {
+  const emojiSet = entry.reactions[emoji];
+  if (!emojiSet) {
+    entry.reactions[emoji] = /* @__PURE__ */ new Set();
+  }
+  if (op === "add") {
+    entry.reactions[emoji]?.add(participantId);
+  } else {
+    entry.reactions[emoji]?.delete(participantId);
+    if (entry.reactions[emoji]?.size === 0) {
+      delete entry.reactions[emoji];
+    }
+  }
+}
+function trimEntriesIfNeeded(state) {
+  if (Object.keys(state.byId).length > state.maxEntries) {
+    const entriesToRemove = Object.keys(state.byId).length - state.maxEntries;
+    for (let i = 0; i < entriesToRemove; i++) {
+      const oldestId = state.order[i];
+      if (oldestId) {
+        delete state.byId[oldestId];
+      }
+    }
+    state.order = state.order.slice(entriesToRemove);
+  }
+}
+var useChatStore = zustand.create()(
+  immer.immer((set) => ({
+    ...defaultChatState,
+    patch: (fn) => set((state) => {
+      fn(state);
+    }),
+    applyIncoming: (envelope) => set((state) => {
+      if (envelope.kind === "entry") {
+        if (state.byId[envelope.entryId]) {
+          return;
+        }
+        if (envelope.sender.info) {
+          state.participantCache[envelope.sender.id] = envelope.sender.info;
+        }
+        const entry = {
+          id: envelope.entryId,
+          content: envelope.payload.content,
+          sender: {
+            id: envelope.sender.id
+          },
+          createdAt: envelope.ts,
+          version: 1,
+          reactions: {},
+          status: "sent"
+        };
+        state.byId[envelope.entryId] = entry;
+        state.order.push(envelope.entryId);
+        trimEntriesIfNeeded(state);
+        const pendingOps = state.pendingOps[envelope.entryId];
+        if (pendingOps) {
+          delete state.pendingOps[envelope.entryId];
+          for (const op of pendingOps) {
+            if (op.kind === "edit") {
+              const entry2 = state.byId[op.entryId];
+              if (entry2 && op.payload.version > entry2.version) {
+                entry2.content = op.payload.newContent;
+                entry2.version = op.payload.version;
+                entry2.editedAt = op.ts;
+              }
+            } else if (op.kind === "remove") {
+              const entry2 = state.byId[op.entryId];
+              if (entry2 && !entry2.removedAt) {
+                entry2.removedAt = op.ts;
+              }
+            } else if (op.kind === "reaction") {
+              if (op.sender.info) {
+                state.participantCache[op.sender.id] = op.sender.info;
+              }
+              const entry2 = state.byId[op.entryId];
+              if (entry2) {
+                applyReactionToEntry(
+                  entry2,
+                  op.payload.emoji,
+                  op.sender.id,
+                  op.payload.op
+                );
+              }
+            }
+          }
+        }
+      } else if (envelope.kind === "edit") {
+        const entry = state.byId[envelope.entryId];
+        if (entry) {
+          if (envelope.payload.version > entry.version) {
+            entry.content = envelope.payload.newContent;
+            entry.version = envelope.payload.version;
+            entry.editedAt = envelope.ts;
+          }
+        } else {
+          if (!state.pendingOps[envelope.entryId]) {
+            state.pendingOps[envelope.entryId] = [];
+          }
+          state.pendingOps[envelope.entryId]?.push(envelope);
+        }
+      } else if (envelope.kind === "remove") {
+        const entry = state.byId[envelope.entryId];
+        if (entry) {
+          if (!entry.removedAt) {
+            entry.removedAt = envelope.ts;
+          }
+        } else {
+          if (!state.pendingOps[envelope.entryId]) {
+            state.pendingOps[envelope.entryId] = [];
+          }
+          state.pendingOps[envelope.entryId]?.push(envelope);
+        }
+      } else if (envelope.kind === "reaction") {
+        if (envelope.sender.info) {
+          state.participantCache[envelope.sender.id] = envelope.sender.info;
+        }
+        const entry = state.byId[envelope.entryId];
+        if (entry) {
+          applyReactionToEntry(
+            entry,
+            envelope.payload.emoji,
+            envelope.sender.id,
+            envelope.payload.op
+          );
+        } else {
+          if (!state.pendingOps[envelope.entryId]) {
+            state.pendingOps[envelope.entryId] = [];
+          }
+          state.pendingOps[envelope.entryId]?.push(envelope);
+        }
+      }
+    }),
+    addEntryOptimistic: (entry) => set((state) => {
+      state.byId[entry.id] = entry;
+      state.order.push(entry.id);
+      trimEntriesIfNeeded(state);
+    }),
+    markEntrySent: (entryId) => set((state) => {
+      const entry = state.byId[entryId];
+      if (entry) {
+        entry.status = "sent";
+      }
+    }),
+    markEntryFailed: (entryId) => set((state) => {
+      const entry = state.byId[entryId];
+      if (entry) {
+        entry.status = "failed";
+      }
+    }),
+    applyEdit: (entryId, newContent, version) => set((state) => {
+      const entry = state.byId[entryId];
+      if (entry && version > entry.version) {
+        entry.content = newContent;
+        entry.version = version;
+        entry.editedAt = Date.now();
+      }
+    }),
+    applyRemove: (entryId) => set((state) => {
+      const entry = state.byId[entryId];
+      if (entry && !entry.removedAt) {
+        entry.removedAt = Date.now();
+      }
+    }),
+    applyReaction: (entryId, emoji, participantId, op) => set((state) => {
+      const entry = state.byId[entryId];
+      if (entry) {
+        applyReactionToEntry(entry, emoji, participantId, op);
+      }
+    }),
+    queuePendingOp: (entryId, envelope) => set((state) => {
+      if (!state.pendingOps[entryId]) {
+        state.pendingOps[entryId] = [];
+      }
+      state.pendingOps[entryId].push(envelope);
+    }),
+    processPendingOps: (entryId) => set((state) => {
+      const pendingOps = state.pendingOps[entryId];
+      if (!pendingOps) {
+        return;
+      }
+      delete state.pendingOps[entryId];
+      for (const envelope of pendingOps) {
+        if (envelope.kind === "edit") {
+          const entry = state.byId[envelope.entryId];
+          if (entry && envelope.payload.version > entry.version) {
+            entry.content = envelope.payload.newContent;
+            entry.version = envelope.payload.version;
+            entry.editedAt = envelope.ts;
+          }
+        } else if (envelope.kind === "remove") {
+          const entry = state.byId[envelope.entryId];
+          if (entry && !entry.removedAt) {
+            entry.removedAt = envelope.ts;
+          }
+        } else if (envelope.kind === "reaction") {
+          if (envelope.sender.info) {
+            state.participantCache[envelope.sender.id] = envelope.sender.info;
+          }
+          const entry = state.byId[envelope.entryId];
+          if (entry) {
+            applyReactionToEntry(
+              entry,
+              envelope.payload.emoji,
+              envelope.sender.id,
+              envelope.payload.op
+            );
+          }
+        }
+      }
+    }),
+    trimOldEntries: () => set((state) => {
+      trimEntriesIfNeeded(state);
+    }),
+    clearChat: () => set(() => defaultChatState)
+  }))
+);
+
+// src/state/types.ts
+var defaultState = {
+  initiated: false,
+  session: null,
+  incomingInvite: null,
+  outgoingInvites: {},
+  errors: []
+};
+
+// src/state/store.ts
+var useRtcStore = zustand.create()(
+  immer.immer((set) => ({
+    ...defaultState,
+    patch: (fn) => set((state) => {
+      fn(state);
+    }),
+    reset: () => set(() => defaultState),
+    addError: (error) => set((state) => {
+      state.errors.push(error);
+    }),
+    clearErrors: () => set((state) => {
+      state.errors = [];
+    })
+  }))
+);
+function compareEntries(a, b) {
+  if (a.createdAt !== b.createdAt) {
+    return a.createdAt - b.createdAt;
+  }
+  if (a.sender.id !== b.sender.id) {
+    return a.sender.id.localeCompare(b.sender.id);
+  }
+  return a.id.localeCompare(b.id);
+}
+function validateContent(content) {
+  const trimmed = content.trim();
+  if (trimmed.length === 0) {
+    return { valid: false, error: "Content cannot be empty" };
+  }
+  const sizeInBytes = new TextEncoder().encode(content).length;
+  if (sizeInBytes > 16384) {
+    return { valid: false, error: "Content exceeds 16KB limit" };
+  }
+  return { valid: true };
+}
+function isValidEnvelope(data) {
+  if (!data || typeof data !== "object") {
+    return false;
+  }
+  if (data.v !== 1) {
+    return false;
+  }
+  if (!["entry", "edit", "remove", "reaction"].includes(data.kind)) {
+    return false;
+  }
+  if (typeof data.roomId !== "string" || typeof data.entryId !== "string" || typeof data.ts !== "number") {
+    return false;
+  }
+  if (!data.sender || typeof data.sender.id !== "string") {
+    return false;
+  }
+  if (data.kind === "entry" || data.kind === "edit" || data.kind === "reaction") {
+    if (!data.payload || typeof data.payload !== "object") {
+      return false;
+    }
+  }
+  return true;
+}
+function generateEntryId() {
+  return nanoid.nanoid();
+}
+function getCurrentTimestamp() {
+  return Date.now();
+}
+
+// src/utils/logger.ts
+var LOG_LEVELS = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+var CallpadLoggerImpl = class _CallpadLoggerImpl {
+  constructor(namespace = "callpad", options = {}) {
+    this.namespace = namespace;
+    this.level = options.level ?? this.getDefaultLevel();
+    this.enableDebug = options.enableDebug ?? this.shouldEnableDebug();
+    if (options.customLogger) {
+      this.customLogger = options.customLogger;
+    }
+  }
+  getDefaultLevel() {
+    const envLevel = typeof window !== "undefined" ? window.__CALLPAD_LOG_LEVEL__ : typeof globalThis !== "undefined" && globalThis.process?.env?.CALLPAD_LOG_LEVEL;
+    if (envLevel && this.isValidLogLevel(envLevel)) {
+      return envLevel;
+    }
+    const isProduction = typeof globalThis !== "undefined" && globalThis.process?.env?.NODE_ENV === "production";
+    return isProduction ? "warn" : "info";
+  }
+  shouldEnableDebug() {
+    const debugEnv = typeof window !== "undefined" ? window.__DEBUG__ : typeof globalThis !== "undefined" && globalThis.process?.env?.DEBUG;
+    if (!debugEnv) return false;
+    const debugPatterns = debugEnv.split(/[\s,]+/);
+    return debugPatterns.some((pattern) => {
+      if (pattern === "*") return true;
+      if (pattern.endsWith("*")) {
+        const prefix = pattern.slice(0, -1);
+        return this.namespace.startsWith(prefix);
+      }
+      return this.namespace === pattern;
+    });
+  }
+  isValidLogLevel(level) {
+    return Object.keys(LOG_LEVELS).includes(level);
+  }
+  shouldLog(level) {
+    if (level === "debug" && !this.enableDebug) {
+      return false;
+    }
+    return LOG_LEVELS[level] >= LOG_LEVELS[this.level];
+  }
+  formatMessage(level, message, meta) {
+    if (!this.shouldLog(level)) return;
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const prefix = `[${timestamp}] [${this.namespace}] [${level.toUpperCase()}]`;
+    if (this.customLogger) {
+      this.customLogger(level, message, meta);
+      return;
+    }
+    const logMethod = level === "error" ? console.error : level === "warn" ? console.warn : level === "info" ? console.info : console.log;
+    if (meta !== void 0) {
+      logMethod(`${prefix} ${message}`, meta);
+    } else {
+      logMethod(`${prefix} ${message}`);
+    }
+  }
+  debug(message, meta) {
+    this.formatMessage("debug", message, meta);
+  }
+  info(message, meta) {
+    this.formatMessage("info", message, meta);
+  }
+  warn(message, meta) {
+    this.formatMessage("warn", message, meta);
+  }
+  error(message, meta) {
+    this.formatMessage("error", message, meta);
+  }
+  child(namespace) {
+    const childNamespace = `${this.namespace}:${namespace}`;
+    const childOptions = {
+      level: this.level,
+      enableDebug: this.enableDebug
+    };
+    if (this.customLogger) {
+      childOptions.customLogger = this.customLogger;
+    }
+    return new _CallpadLoggerImpl(childNamespace, childOptions);
+  }
+  setLevel(level) {
+    this.level = level;
+  }
+  isLevelEnabled(level) {
+    return this.shouldLog(level);
+  }
+};
+var rootLogger = null;
+function createLogger(namespace, options) {
+  if (!namespace) {
+    if (!rootLogger) {
+      rootLogger = new CallpadLoggerImpl("callpad", options);
+    }
+    return rootLogger;
+  }
+  return new CallpadLoggerImpl(`callpad:${namespace}`, options);
+}
+
+// src/channel/chat/service.ts
+var logger = createLogger("chat");
+var ChatService = class {
+  constructor(room) {
+    this.isSubscribed = false;
+    this.room = room;
+  }
+  isRoomReady() {
+    if (!this.room) {
+      logger.warn("Room not initialized");
+      return false;
+    }
+    if (this.room.state !== livekitClient.ConnectionState.Connected) {
+      logger.warn("Room not connected", { state: this.room.state });
+      return false;
+    }
+    if (!this.room.localParticipant) {
+      logger.warn("Local participant not available");
+      return false;
+    }
+    return true;
+  }
+  subscribe() {
+    if (this.isSubscribed) {
+      return;
+    }
+    this.room.registerTextStreamHandler(
+      "chat:v1",
+      async (reader, participantInfo) => {
+        try {
+          const text = await reader.readAll();
+          this.handleIncomingMessage(text);
+        } catch (error) {
+          logger.error("Error reading text stream", error);
+        }
+      }
+    );
+    this.isSubscribed = true;
+  }
+  unsubscribe() {
+    this.isSubscribed = false;
+  }
+  getLocalParticipantId() {
+    return this.room.localParticipant.identity;
+  }
+  async send(content) {
+    if (!this.isRoomReady()) {
+      useRtcStore.getState().addError({
+        code: "CHAT_ROOM_NOT_READY",
+        message: "Cannot send message: room not connected",
+        timestamp: Date.now()
+      });
+      return;
+    }
+    const validation = validateContent(content);
+    if (!validation.valid) {
+      useRtcStore.getState().addError({
+        code: "CHAT_INVALID_CONTENT",
+        message: validation.error || "Invalid content",
+        timestamp: Date.now()
+      });
+      return;
+    }
+    const entryId = generateEntryId();
+    const chatStore = useChatStore.getState();
+    const senderInfo = this.getSenderInfo();
+    if (senderInfo.info) {
+      chatStore.patch((state) => {
+        state.participantCache[senderInfo.id] = senderInfo.info;
+      });
+    }
+    const entry = {
+      id: entryId,
+      content,
+      sender: {
+        id: senderInfo.id
+      },
+      createdAt: getCurrentTimestamp(),
+      version: 1,
+      reactions: {},
+      status: "sending"
+    };
+    chatStore.addEntryOptimistic(entry);
+    try {
+      const envelope = {
+        v: 1,
+        kind: "entry",
+        roomId: this.room.name,
+        entryId,
+        ts: entry.createdAt,
+        sender: senderInfo,
+        payload: {
+          content
+        }
+      };
+      await this.room.localParticipant.sendText(JSON.stringify(envelope), {
+        topic: "chat:v1"
+      });
+      chatStore.markEntrySent(entryId);
+    } catch (error) {
+      chatStore.markEntryFailed(entryId);
+      useRtcStore.getState().addError({
+        code: "CHAT_SEND_FAILED",
+        message: error instanceof Error ? error.message : "Failed to send message",
+        timestamp: Date.now(),
+        context: { entryId }
+      });
+    }
+  }
+  async edit(entryId, newContent) {
+    if (!this.isRoomReady()) {
+      useRtcStore.getState().addError({
+        code: "CHAT_ROOM_NOT_READY",
+        message: "Cannot edit message: room not connected",
+        timestamp: Date.now()
+      });
+      return;
+    }
+    const validation = validateContent(newContent);
+    if (!validation.valid) {
+      useRtcStore.getState().addError({
+        code: "CHAT_INVALID_CONTENT",
+        message: validation.error || "Invalid content",
+        timestamp: Date.now()
+      });
+      return;
+    }
+    const chatStore = useChatStore.getState();
+    const entry = chatStore.byId[entryId];
+    if (!entry) {
+      useRtcStore.getState().addError({
+        code: "CHAT_ENTRY_NOT_FOUND",
+        message: "Entry not found",
+        timestamp: Date.now(),
+        context: { entryId }
+      });
+      return;
+    }
+    const senderInfo = this.getSenderInfo();
+    if (entry.sender.id !== senderInfo.id) {
+      useRtcStore.getState().addError({
+        code: "CHAT_UNAUTHORIZED",
+        message: "You can only edit your own messages",
+        timestamp: Date.now(),
+        context: { entryId }
+      });
+      return;
+    }
+    const newVersion = entry.version + 1;
+    chatStore.applyEdit(entryId, newContent, newVersion);
+    try {
+      const envelope = {
+        v: 1,
+        kind: "edit",
+        roomId: this.room.name,
+        entryId,
+        ts: getCurrentTimestamp(),
+        sender: senderInfo,
+        payload: {
+          newContent,
+          version: newVersion
+        }
+      };
+      await this.room.localParticipant.sendText(JSON.stringify(envelope), {
+        topic: "chat:v1"
+      });
+    } catch (error) {
+      useRtcStore.getState().addError({
+        code: "CHAT_EDIT_FAILED",
+        message: error instanceof Error ? error.message : "Failed to edit message",
+        timestamp: Date.now(),
+        context: { entryId }
+      });
+    }
+  }
+  async remove(entryId) {
+    if (!this.isRoomReady()) {
+      useRtcStore.getState().addError({
+        code: "CHAT_ROOM_NOT_READY",
+        message: "Cannot remove message: room not connected",
+        timestamp: Date.now()
+      });
+      return;
+    }
+    const chatStore = useChatStore.getState();
+    const entry = chatStore.byId[entryId];
+    if (!entry) {
+      useRtcStore.getState().addError({
+        code: "CHAT_ENTRY_NOT_FOUND",
+        message: "Entry not found",
+        timestamp: Date.now(),
+        context: { entryId }
+      });
+      return;
+    }
+    const senderInfo = this.getSenderInfo();
+    if (entry.sender.id !== senderInfo.id) {
+      useRtcStore.getState().addError({
+        code: "CHAT_UNAUTHORIZED",
+        message: "You can only remove your own messages",
+        timestamp: Date.now(),
+        context: { entryId }
+      });
+      return;
+    }
+    chatStore.applyRemove(entryId);
+    try {
+      const envelope = {
+        v: 1,
+        kind: "remove",
+        roomId: this.room.name,
+        entryId,
+        ts: getCurrentTimestamp(),
+        sender: senderInfo
+      };
+      await this.room.localParticipant.sendText(JSON.stringify(envelope), {
+        topic: "chat:v1"
+      });
+    } catch (error) {
+      useRtcStore.getState().addError({
+        code: "CHAT_REMOVE_FAILED",
+        message: error instanceof Error ? error.message : "Failed to remove message",
+        timestamp: Date.now(),
+        context: { entryId }
+      });
+    }
+  }
+  async react(entryId, emoji) {
+    if (!this.isRoomReady()) {
+      useRtcStore.getState().addError({
+        code: "CHAT_ROOM_NOT_READY",
+        message: "Cannot add reaction: room not connected",
+        timestamp: Date.now()
+      });
+      return;
+    }
+    const chatStore = useChatStore.getState();
+    const entry = chatStore.byId[entryId];
+    if (!entry) {
+      return;
+    }
+    const senderInfo = this.getSenderInfo();
+    if (senderInfo.info) {
+      chatStore.patch((state) => {
+        state.participantCache[senderInfo.id] = senderInfo.info;
+      });
+    }
+    chatStore.applyReaction(entryId, emoji, senderInfo.id, "add");
+    try {
+      const envelope = {
+        v: 1,
+        kind: "reaction",
+        roomId: this.room.name,
+        entryId,
+        ts: getCurrentTimestamp(),
+        sender: senderInfo,
+        payload: {
+          emoji,
+          op: "add"
+        }
+      };
+      await this.room.localParticipant.sendText(JSON.stringify(envelope), {
+        topic: "chat:v1"
+      });
+    } catch (error) {
+      useRtcStore.getState().addError({
+        code: "CHAT_REACTION_FAILED",
+        message: error instanceof Error ? error.message : "Failed to add reaction",
+        timestamp: Date.now(),
+        context: { entryId, emoji }
+      });
+    }
+  }
+  async unreact(entryId, emoji) {
+    if (!this.isRoomReady()) {
+      useRtcStore.getState().addError({
+        code: "CHAT_ROOM_NOT_READY",
+        message: "Cannot remove reaction: room not connected",
+        timestamp: Date.now()
+      });
+      return;
+    }
+    const chatStore = useChatStore.getState();
+    const entry = chatStore.byId[entryId];
+    if (!entry) {
+      return;
+    }
+    const senderInfo = this.getSenderInfo();
+    if (senderInfo.info) {
+      chatStore.patch((state) => {
+        state.participantCache[senderInfo.id] = senderInfo.info;
+      });
+    }
+    chatStore.applyReaction(entryId, emoji, senderInfo.id, "remove");
+    try {
+      const envelope = {
+        v: 1,
+        kind: "reaction",
+        roomId: this.room.name,
+        entryId,
+        ts: getCurrentTimestamp(),
+        sender: senderInfo,
+        payload: {
+          emoji,
+          op: "remove"
+        }
+      };
+      await this.room.localParticipant.sendText(JSON.stringify(envelope), {
+        topic: "chat:v1"
+      });
+    } catch (error) {
+      useRtcStore.getState().addError({
+        code: "CHAT_REACTION_FAILED",
+        message: error instanceof Error ? error.message : "Failed to remove reaction",
+        timestamp: Date.now(),
+        context: { entryId, emoji }
+      });
+    }
+  }
+  handleIncomingMessage(text) {
+    try {
+      const parsed = JSON.parse(text);
+      if (!isValidEnvelope(parsed)) {
+        logger.warn("Invalid envelope received", parsed);
+        return;
+      }
+      useChatStore.getState().applyIncoming(parsed);
+    } catch (error) {
+      logger.error("Error parsing incoming message", error);
+    }
+  }
+  getSenderInfo() {
+    const localParticipant = this.room.localParticipant;
+    const sender = {
+      id: localParticipant.identity
+    };
+    if (localParticipant.metadata) {
+      try {
+        sender.info = JSON.parse(localParticipant.metadata);
+      } catch {
+      }
+    }
+    return sender;
+  }
+};
+function useChat() {
+  const service = useFeatureService("chat");
+  const byId = useChatStore((state) => state.byId);
+  const order = useChatStore((state) => state.order);
+  const participantCache = useChatStore((state) => state.participantCache);
+  const entries = react.useMemo(() => {
+    return order.map((id) => byId[id]).filter((entry) => entry !== void 0).sort(compareEntries);
+  }, [byId, order]);
+  const getParticipantInfo = react.useCallback(
+    (id) => {
+      return participantCache[id] || null;
+    },
+    [participantCache]
+  );
+  const send = react.useCallback(
+    async (content) => service.send(content),
+    [service]
+  );
+  const edit = react.useCallback(
+    async (id, content) => service.edit(id, content),
+    [service]
+  );
+  const remove = react.useCallback(
+    async (id) => service.remove(id),
+    [service]
+  );
+  const react$1 = react.useCallback(
+    async (id, emoji) => service.react(id, emoji),
+    [service]
+  );
+  const unreact = react.useCallback(
+    async (id, emoji) => service.unreact(id, emoji),
+    [service]
+  );
+  const isOwnEntry = react.useCallback(
+    (entry) => entry.sender.id === service.getLocalParticipantId(),
+    [service]
+  );
+  return {
+    entries,
+    isReady: true,
+    getParticipantInfo,
+    isOwnEntry,
+    send,
+    edit,
+    remove,
+    react: react$1,
+    unreact
+  };
+}
+
+// src/channel/registry.ts
+var FEATURES = {
+  chat: {
+    name: "chat",
+    createService: (room) => new ChatService(room),
+    cleanupStore: () => useChatStore.getState().clearChat()
+  }
+};
+var DEFAULT_FEATURES = ["chat"];
+var logger2 = createLogger("channels:provider");
+function DataChannelProvider({
+  room,
+  features = DEFAULT_FEATURES,
+  children
+}) {
+  const services = react.useRef(/* @__PURE__ */ new Map());
+  const [isReady, setIsReady] = react.useState(false);
+  react.useEffect(() => {
+    if (!room) {
+      logger2.warn("DataChannelProvider mounted without room");
+      return;
+    }
+    logger2.debug("Initializing features", { features });
+    for (const featureName of features) {
+      const feature = FEATURES[featureName];
+      if (!feature) {
+        logger2.warn(`Feature "${featureName}" not found in registry`);
+        continue;
+      }
+      try {
+        logger2.debug(`Initializing feature: ${featureName}`);
+        const service = feature.createService(room);
+        service.subscribe();
+        services.current.set(featureName, service);
+        logger2.info(`Feature "${featureName}" initialized`);
+      } catch (error) {
+        logger2.error(`Failed to initialize feature "${featureName}"`, error);
+      }
+    }
+    setIsReady(true);
+    logger2.info("All features initialized");
+    return () => {
+      logger2.debug("Cleaning up features");
+      services.current.forEach((service, name) => {
+        try {
+          logger2.debug(`Unsubscribing feature: ${name}`);
+          service.unsubscribe();
+        } catch (error) {
+          logger2.error(`Failed to unsubscribe feature "${name}"`, error);
+        }
+      });
+      for (const featureName of features) {
+        const feature = FEATURES[featureName];
+        if (feature?.cleanupStore) {
+          try {
+            logger2.debug(`Cleaning store for feature: ${featureName}`);
+            feature.cleanupStore();
+          } catch (error) {
+            logger2.error(`Failed to cleanup store for "${featureName}"`, error);
+          }
+        }
+      }
+      services.current.clear();
+      setIsReady(false);
+      logger2.info("Features cleanup complete");
+    };
+  }, [room, features]);
+  const contextValue = react.useMemo(
+    () => ({
+      services: services.current,
+      isReady
+    }),
+    [isReady]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(DataChannelContext.Provider, { value: contextValue, children });
+}
+
+exports.ChatService = ChatService;
+exports.DataChannelProvider = DataChannelProvider;
+exports.compareEntries = compareEntries;
+exports.generateEntryId = generateEntryId;
+exports.getCurrentTimestamp = getCurrentTimestamp;
+exports.isValidEnvelope = isValidEnvelope;
+exports.useChat = useChat;
+exports.useChatStore = useChatStore;
+exports.useDataChannelContext = useDataChannelContext;
+exports.useFeatureService = useFeatureService;
+exports.validateContent = validateContent;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map