@snakechat/commskit-node 0.0.0-stage → 0.1.0

package/dist/chunk-KL4WRZKZ.js

@@ -0,0 +1,799 @@
+import {
+  HttpError,
+  dbBool,
+  dbNow,
+  dbTimestamp,
+  detectDialect,
+  ok
+} from "./chunk-GR4PMGCS.js";
+import {
+  RateLimit,
+  retryAfterSeconds
+} from "./chunk-BBFVG7QU.js";
+import {
+  LRU,
+  nowIso,
+  parseDbDate,
+  pyBool,
+  pyStr
+} from "./chunk-KLKRK6OG.js";
+import {
+  logger
+} from "./chunk-5BJ2SNM5.js";
+
+// src/call/config.ts
+var defaultCallConfig = () => ({
+  ringTimeout: 45,
+  ringingDisconnectGrace: 20,
+  answeredDisconnectGrace: 90,
+  maxCallHours: 4,
+  ringWindowSlack: 15,
+  ringtoneChannel: "call_ringtone",
+  missedChannel: "messages",
+  turnSecret: null,
+  turnUris: [],
+  turnTtl: 3600,
+  initiateRate: new RateLimit(5, 60)
+});
+
+// src/call/payloads.ts
+function callPayload(event, info, extra = {}) {
+  return {
+    type: event,
+    call_id: info.callId,
+    chat_id: info.chatId,
+    caller_id: info.callerId,
+    receiver_id: info.receiverId,
+    call_type: info.callType,
+    webrtc_session_id: info.callId,
+    timestamp: nowIso(),
+    ...extra
+  };
+}
+var callerView = (info) => ({
+  caller_id: info.receiverId,
+  caller_name: info.receiverId
+});
+function busyPayload(callerId, receiverId, callType) {
+  return {
+    type: "call_rejected",
+    call_id: null,
+    status: "busy",
+    reason: "busy",
+    caller_id: callerId,
+    receiver_id: receiverId,
+    call_type: callType,
+    timestamp: nowIso()
+  };
+}
+var callError = (error, extra = {}) => ({
+  type: "error",
+  error,
+  ...extra,
+  context: "call"
+});
+
+// src/call/service.ts
+import { randomUUID } from "crypto";
+var ACTIVE_CALL_STATUSES = ["ringing", "answered"];
+var CallInfo = class _CallInfo {
+  constructor(callId, chatId, callerId, receiverId, isVideoCall, status, duration = 0, endReason = null) {
+    this.callId = callId;
+    this.chatId = chatId;
+    this.callerId = callerId;
+    this.receiverId = receiverId;
+    this.isVideoCall = isVideoCall;
+    this.status = status;
+    this.duration = duration;
+    this.endReason = endReason;
+  }
+  callId;
+  chatId;
+  callerId;
+  receiverId;
+  isVideoCall;
+  status;
+  duration;
+  endReason;
+  /** Filled by a chat bridge during finalize: the call's chat entry. */
+  messageId = null;
+  logText = null;
+  static fromRow(row) {
+    return new _CallInfo(
+      row.call_id,
+      row.chat_id === null || row.chat_id === void 0 ? null : Number(row.chat_id),
+      row.caller_id,
+      row.receiver_id,
+      Boolean(row.is_video_call),
+      row.call_status,
+      row.duration ?? 0,
+      row.end_reason ?? null
+    );
+  }
+  get callType() {
+    return this.isVideoCall ? "video" : "audio";
+  }
+  otherParty(userId) {
+    if (userId === this.callerId) return this.receiverId;
+    if (userId === this.receiverId) return this.callerId;
+    return null;
+  }
+  clone(patch = {}) {
+    return Object.assign(Object.create(_CallInfo.prototype), this, patch);
+  }
+};
+function callLogText(status, isVideoCall, duration, _endReason = null) {
+  const kind = isVideoCall ? "Video call" : "Voice call";
+  if (status === "missed") return `Missed ${kind.toLowerCase()}`;
+  if (status === "rejected") return `Declined ${kind.toLowerCase()}`;
+  const total = Math.max(0, Math.trunc(duration));
+  const hours = Math.floor(total / 3600);
+  const mins = Math.floor(total % 3600 / 60);
+  const secs = total % 60;
+  const p = (n) => String(n).padStart(2, "0");
+  return `${kind} \xB7 ${hours ? `${hours}:${p(mins)}:${p(secs)}` : `${p(mins)}:${p(secs)}`}`;
+}
+var CallService = class {
+  constructor(db, config, bridge = null, dialect) {
+    this.db = db;
+    this.bridge = bridge;
+    this.config = config ?? defaultCallConfig();
+    this.dialect = dialect ?? detectDialect(db);
+  }
+  db;
+  bridge;
+  dialect;
+  config;
+  ts(d = dbNow()) {
+    return dbTimestamp(this.dialect, d);
+  }
+  async createCall(chatId, callerId, receiverId, isVideoCall = false) {
+    const callId = randomUUID();
+    await this.db.insertInto("calls").values({
+      call_id: callId,
+      chat_id: chatId,
+      caller_id: callerId,
+      receiver_id: receiverId,
+      call_status: "ringing",
+      is_video_call: dbBool(this.dialect, isVideoCall),
+      started_at: this.ts()
+    }).execute();
+    return new CallInfo(callId, chatId, callerId, receiverId, isVideoCall, "ringing");
+  }
+  async getCallById(callId) {
+    return this.db.selectFrom("calls").selectAll().where("call_id", "=", callId).executeTakeFirst();
+  }
+  async getCallInfo(callId) {
+    const row = await this.getCallById(callId);
+    return row ? CallInfo.fromRow(row) : null;
+  }
+  async saveOfferSdp(callId, offerSdp) {
+    await this.db.updateTable("calls").set({ offer_sdp: offerSdp }).where("call_id", "=", callId).execute();
+  }
+  async getOfferSdp(callId) {
+    const r = await this.db.selectFrom("calls").select("offer_sdp").where("call_id", "=", callId).executeTakeFirst();
+    return r?.offer_sdp ?? null;
+  }
+  liveCallsQuery(userId) {
+    const now = dbNow();
+    const cfg = this.config;
+    const ringCutoff = this.ts(new Date(now.getTime() - (cfg.ringTimeout + cfg.ringWindowSlack) * 1e3));
+    const answeredCutoff = this.ts(new Date(now.getTime() - cfg.maxCallHours * 3600 * 1e3));
+    return this.db.selectFrom("calls").selectAll().where(
+      (eb) => eb.and([
+        eb.or([eb("caller_id", "=", userId), eb("receiver_id", "=", userId)]),
+        eb.or([
+          eb.and([eb("call_status", "=", "ringing"), eb("started_at", ">=", ringCutoff)]),
+          eb.and([eb("call_status", "=", "answered"), eb("answered_at", ">=", answeredCutoff)])
+        ])
+      ])
+    ).orderBy("started_at", "desc").orderBy("id", "desc");
+  }
+  async getActiveCallForUser(userId) {
+    const row = await this.liveCallsQuery(userId).limit(1).executeTakeFirst();
+    return row ? CallInfo.fromRow(row) : null;
+  }
+  async getActiveCallsForUsers(userId) {
+    return (await this.liveCallsQuery(userId).execute()).map((r) => CallInfo.fromRow(r));
+  }
+  /** ringing -> answered. Only the receiver can answer, and only once. */
+  async markAnswered(callId, receiverId) {
+    const res = await this.db.updateTable("calls").set({ call_status: "answered", answered_at: this.ts() }).where("call_id", "=", callId).where("receiver_id", "=", receiverId).where("call_status", "=", "ringing").executeTakeFirst();
+    if (Number(res.numUpdatedRows) !== 1) return null;
+    return this.getCallInfo(callId);
+  }
+  /** Move a live call to a terminal status. null if another path already did. */
+  async finalizeCall(callId, status, endReason, onlyFrom = ACTIVE_CALL_STATUSES) {
+    const call = await this.getCallById(callId);
+    if (!call || !onlyFrom.includes(call.call_status)) return null;
+    const fromStatus = call.call_status;
+    const snapshot = CallInfo.fromRow(call);
+    const now = dbNow();
+    let duration = 0;
+    const answeredAt = parseDbDate(call.answered_at);
+    if (fromStatus === "answered" && answeredAt) duration = Math.max(0, Math.trunc((now.getTime() - answeredAt.getTime()) / 1e3));
+    const values = { call_status: status, end_reason: endReason, ended_at: this.ts(now), duration };
+    if (status === "missed") values.missed_at = this.ts(now);
+    const info = snapshot.clone({ status, duration, endReason });
+    const bridge = this.bridge;
+    const done = await this.db.transaction().execute(async (trx) => {
+      const res = await trx.updateTable("calls").set(values).where("call_id", "=", callId).where("call_status", "=", fromStatus).executeTakeFirst();
+      if (Number(res.numUpdatedRows) !== 1) return false;
+      if (bridge) await bridge.onCallFinalizing(trx, info);
+      return true;
+    });
+    return done ? info : null;
+  }
+};
+
+// src/call/handlers.ts
+var CallHandlers = class {
+  constructor(feature) {
+    this.feature = feature;
+  }
+  feature;
+  get hub() {
+    return this.feature.hub;
+  }
+  get lifecycle() {
+    return this.feature.lifecycle;
+  }
+  register() {
+    const on = this.hub.on.bind(this.hub);
+    on("call_initiate", this.guard((u, m, d) => this.callInitiate(u, m, d), "Failed to initiate call"));
+    on("answer_call", this.guard((u, m, d) => this.answerCall(u, m, d), "Failed to answer call"));
+    on("reject_call", this.guard((u, m, d) => this.endCall(u, m, d), "Failed to reject call"));
+    on("end_call", this.guard((u, m, d) => this.endCall(u, m, d), "Failed to end call"));
+    on("sdp_offer", this.guard((u, m, d) => this.relaySdp(u, m, d, "sdp_offer"), null));
+    on("sdp_answer", this.guard((u, m, d) => this.relaySdp(u, m, d, "sdp_answer"), null));
+    on("ice_candidate", this.guard((u, m, d) => this.iceCandidate(u, m, d), null));
+    on("start_recording", async () => void 0);
+  }
+  /** Crash -> call-tagged error (label) or logged only (signalling relays). */
+  guard(fn, label) {
+    return async (userId, message, db) => {
+      try {
+        await fn(userId, message, db);
+      } catch (err) {
+        logger.error(`${message.type} handler failed`, err);
+        await this.hub.reportHandlerError(userId, message, err);
+        if (label) await this.error(userId, `${label}: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    };
+  }
+  async error(userId, error, extra = {}) {
+    await this.hub.send(userId, callError(error, extra));
+  }
+  // ------------------------------------------------------------ initiate
+  async callInitiate(userId, message, db) {
+    const lifecycle = this.lifecycle;
+    const connections = this.hub.connections;
+    const rawReceiver = message.receiver_id;
+    const callType = message.call_type === "video" ? "video" : "audio";
+    if (!pyBool(rawReceiver)) {
+      await this.error(userId, "Missing required fields: receiver_id");
+      return;
+    }
+    const receiverId = pyStr(rawReceiver);
+    if (receiverId === userId) {
+      await this.error(userId, "You cannot call yourself.");
+      return;
+    }
+    const limit = this.feature.config.initiateRate;
+    const wait = limit ? await this.hub.rateLimiter.hit(`call.initiate:${userId}`, limit) : 0;
+    if (wait) {
+      const seconds = retryAfterSeconds(wait);
+      await this.error(userId, `Too many calls. Try again in ${seconds} s.`, { code: "rate_limited", retry_after: seconds });
+      return;
+    }
+    const service = lifecycle.service(db);
+    const ownCall = await service.getActiveCallForUser(userId);
+    if (ownCall && ownCall.status === "ringing") {
+      await this.error(userId, "You are already in a call.");
+      return;
+    }
+    if (ownCall) {
+      await lifecycle.finishCall(db, ownCall, userId);
+    }
+    let receiverCall = await service.getActiveCallForUser(receiverId);
+    if (receiverCall && !(await connections.isConnected(receiverCall.callerId) || await connections.isConnected(receiverCall.receiverId))) {
+      const stale = await service.finalizeCall(
+        receiverCall.callId,
+        receiverCall.status === "answered" ? "ended" : "missed",
+        "stale",
+        [receiverCall.status]
+      );
+      if (stale) await lifecycle.finalized(stale);
+      receiverCall = await service.getActiveCallForUser(receiverId);
+    }
+    if (receiverCall) {
+      await this.hub.send(userId, busyPayload(userId, receiverId, callType));
+      return;
+    }
+    const decision = await this.feature.policy.authorize(db, userId, receiverId, message);
+    if (!decision.allowed) {
+      const error = { ...decision.error ?? { error: "Call not allowed." } };
+      if (!("error" in error)) error.error = "Call not allowed.";
+      await this.hub.send(userId, { type: "error", ...error, context: "call" });
+      return;
+    }
+    const bridge = this.feature.chatBridge;
+    const chatId = bridge ? await bridge.resolveChatId(db, userId, receiverId, message.chat_id) : null;
+    const info = await service.createCall(chatId, userId, receiverId, callType === "video");
+    lifecycle.scheduleRingTimeout(info.callId);
+    if (bridge) await bridge.onCallCreated(db, info);
+    lifecycle.remember(info);
+    await this.hub.send(userId, callPayload("call_initiated", info, { status: "calling", ...callerView(info) }));
+    const incoming = await lifecycle.incomingPayload(info);
+    const delivered = await this.hub.send(receiverId, incoming);
+    if (delivered) {
+      await this.hub.send(userId, callPayload("call_ringing", info, { status: "ringing", ...callerView(info) }));
+    } else {
+      this.hub.spawn(lifecycle.pushIncoming(info, incoming.caller_name, incoming.caller_avatar));
+    }
+    logger.info(`Call ${info.callId} initiated ${userId} -> ${receiverId}`);
+  }
+  // -------------------------------------------------------------- answer
+  async answerCall(userId, message, db) {
+    if (!pyBool(message.call_id)) {
+      await this.error(userId, "Missing required fields: call_id");
+      return;
+    }
+    const callId = pyStr(message.call_id);
+    const lifecycle = this.lifecycle;
+    const info = await lifecycle.service(db).markAnswered(callId, userId);
+    if (!info) {
+      const call = await lifecycle.loadCallFor(db, callId, userId);
+      if (!call) {
+        await this.error(userId, "Call not found", { call_id: callId });
+        return;
+      }
+      if (call.status === "answered") return;
+      await this.hub.send(
+        userId,
+        callPayload("call_ended", call, { status: "call_ended", end_reason: call.status, duration_seconds: call.duration })
+      );
+      return;
+    }
+    lifecycle.remember(info);
+    const payload = callPayload("call_answered", info, { status: "answered", answerer_id: userId });
+    await this.hub.send(info.callerId, payload);
+    await this.hub.send(userId, payload);
+  }
+  // ------------------------------------------------------- reject / end
+  async endCall(userId, message, db) {
+    if (!pyBool(message.call_id)) {
+      await this.error(userId, "Missing required fields: call_id");
+      return;
+    }
+    const call = await this.lifecycle.loadCallFor(db, pyStr(message.call_id), userId);
+    if (!call) {
+      await this.error(userId, "Call not found", { call_id: message.call_id });
+      return;
+    }
+    await this.lifecycle.finishCall(db, call, userId);
+  }
+  // ---------------------------------------------------------- signalling
+  async relaySdp(userId, message, db, event) {
+    if (!pyBool(message.call_id) || !pyBool(message.sdp)) {
+      await this.error(userId, "Missing required fields: sdp, call_id");
+      return;
+    }
+    const callId = pyStr(message.call_id);
+    const sdp = message.sdp;
+    const call = await this.lifecycle.loadCallFor(db, callId, userId);
+    if (!call || !ACTIVE_CALL_STATUSES.includes(call.status)) {
+      await this.error(userId, "No active call found.", { call_id: callId });
+      return;
+    }
+    if (event === "sdp_offer" && userId === call.callerId) {
+      await this.lifecycle.service(db).saveOfferSdp(callId, JSON.stringify(sdp));
+    }
+    const other = call.otherParty(userId);
+    if (other) await this.hub.send(other, { type: event, call_id: callId, from_user_id: userId, sdp, timestamp: nowIso() });
+  }
+  async iceCandidate(userId, message, db) {
+    if (!pyBool(message.call_id) || !pyBool(message.candidate)) return;
+    const callId = pyStr(message.call_id);
+    let parties = this.lifecycle.parties.get(callId);
+    if (!parties) {
+      const call = await this.lifecycle.loadCallFor(db, callId, userId);
+      if (!call) return;
+      parties = [call.callerId, call.receiverId];
+    }
+    const [callerId, receiverId] = parties;
+    if (!parties.includes(userId)) return;
+    await this.hub.send(userId === callerId ? receiverId : callerId, {
+      type: "ice_candidate",
+      call_id: callId,
+      from_user_id: userId,
+      candidate: message.candidate,
+      timestamp: nowIso()
+    });
+  }
+};
+
+// src/call/lifecycle.ts
+function endStatus(call, fromUser) {
+  if (call.status === "answered") return ["ended", "hangup"];
+  if (fromUser === call.callerId) return ["missed", "caller_cancelled"];
+  return ["rejected", "declined"];
+}
+var CallLifecycle = class {
+  constructor(feature) {
+    this.feature = feature;
+  }
+  feature;
+  /** callId -> [callerId, receiverId]: participants never change, so this per-worker cache keeps ICE off the DB. */
+  parties = new LRU(5e3);
+  timers = /* @__PURE__ */ new Set();
+  stopped = false;
+  get hub() {
+    return this.feature.hub;
+  }
+  get config() {
+    return this.feature.config;
+  }
+  service(db) {
+    return new CallService(db, this.config, this.feature.chatBridge, this.hub.dialect);
+  }
+  remember(info) {
+    this.parties.put(info.callId, [info.callerId, info.receiverId]);
+  }
+  /** Emit `call.finalized` (the chat integration sends `call_log` from it). */
+  async finalized(info) {
+    await this.hub.events.emit("call.finalized", info);
+  }
+  /** The call, only if `userId` is a participant. */
+  async loadCallFor(db, callId, userId) {
+    const call = await this.service(db).getCallInfo(String(callId));
+    if (!call || call.otherParty(userId) === null) return null;
+    this.remember(call);
+    return call;
+  }
+  // ----------------------------------------------------------- finishing
+  /** Hangup / reject / cancel by `fromUser`; outcome decided from call state. */
+  async finishCall(db, callIn, fromUser) {
+    const service = this.service(db);
+    let call = callIn;
+    let info = null;
+    let reason = "";
+    for (let i = 0; i < 2; i++) {
+      if (!ACTIVE_CALL_STATUSES.includes(call.status)) break;
+      let status;
+      [status, reason] = endStatus(call, fromUser);
+      info = await service.finalizeCall(call.callId, status, reason, [call.status]);
+      if (info) break;
+      call = await service.getCallInfo(call.callId) ?? call;
+    }
+    if (!info) {
+      await this.hub.send(
+        fromUser,
+        callPayload("call_ended", call, {
+          status: "call_ended",
+          end_reason: call.status,
+          ended_by: fromUser,
+          duration_seconds: call.duration,
+          caller_name: call.callerId
+        })
+      );
+      return;
+    }
+    const rejected = info.status === "rejected";
+    const payload = callPayload(rejected ? "call_rejected" : "call_ended", info, {
+      status: rejected ? "call_rejected" : "call_ended",
+      end_reason: reason,
+      duration_seconds: info.duration,
+      caller_name: info.callerId,
+      ...rejected ? { rejector_id: fromUser } : { ended_by: fromUser }
+    });
+    const other = info.otherParty(fromUser);
+    if (other) await this.hub.send(other, payload);
+    await this.hub.send(fromUser, payload);
+    await this.finalized(info);
+    if (info.status === "missed" && fromUser === info.callerId) {
+      this.hub.spawn(this.pushMissedCall(info));
+    }
+  }
+  /**
+   * End every live call between two users with `endReason` (e.g. "blocked"). Answered calls become `ended`,
+   * ringing ones `missed`. Both parties get `call_ended`; `call.finalized` is emitted.
+   */
+  async endCallsBetween(userA, userB, endReason, endedBy = null) {
+    const ended = [];
+    const service = this.service(this.hub.db);
+    for (const call of await service.getActiveCallsForUsers(userA)) {
+      if (call.otherParty(userA) !== userB) continue;
+      const toStatus = call.status === "answered" ? "ended" : "missed";
+      const info = await service.finalizeCall(call.callId, toStatus, endReason, [call.status]);
+      if (info) ended.push(info);
+    }
+    for (const info of ended) {
+      const payload = callPayload("call_ended", info, {
+        status: "call_ended",
+        end_reason: endReason,
+        ended_by: endedBy ?? userA,
+        duration_seconds: info.duration,
+        caller_name: info.callerId
+      });
+      await this.hub.send(info.callerId, payload);
+      await this.hub.send(info.receiverId, payload);
+      await this.finalized(info);
+      if (info.status === "missed") this.hub.spawn(this.pushMissedCall(info));
+    }
+    return ended;
+  }
+  async rejectFromNotification(db, callId, userId) {
+    const call = await this.loadCallFor(db, callId, userId);
+    if (!call) return false;
+    await this.finishCall(db, call, userId);
+    return true;
+  }
+  // -------------------------------------------------------------- timers
+  later(seconds, fn) {
+    if (this.stopped) return;
+    const t = setTimeout(() => {
+      this.timers.delete(t);
+      this.hub.spawn(fn());
+    }, seconds * 1e3);
+    t.unref?.();
+    this.timers.add(t);
+  }
+  /** Cancel every pending ring-timeout / disconnect-grace timer (hub shutdown). */
+  cancelAll() {
+    this.stopped = true;
+    for (const t of this.timers) clearTimeout(t);
+    this.timers.clear();
+  }
+  scheduleRingTimeout(callId) {
+    this.later(this.config.ringTimeout, () => this.expireUnanswered(callId));
+  }
+  /** Ring timeout: ringing -> missed (no_answer). */
+  async expireUnanswered(callId) {
+    try {
+      const info = await this.service(this.hub.db).finalizeCall(callId, "missed", "no_answer", ["ringing"]);
+      if (!info) return;
+      const payload = callPayload("call_missed", info, { status: "missed", end_reason: "no_answer" });
+      await this.hub.send(info.callerId, payload);
+      await this.hub.send(info.receiverId, payload);
+      await this.finalized(info);
+      await this.pushMissedCall(info);
+    } catch (err) {
+      logger.error(`Ring timeout handling failed for ${callId}`, err);
+    }
+  }
+  async endUserCalls(userId, fromStatus, toStatus) {
+    const ended = [];
+    const service = this.service(this.hub.db);
+    for (const call of await service.getActiveCallsForUsers(userId)) {
+      if (call.status !== fromStatus) continue;
+      const info = await service.finalizeCall(call.callId, toStatus, "disconnected", [fromStatus]);
+      if (info) ended.push(info);
+    }
+    for (const info of ended) {
+      const other = info.otherParty(userId);
+      if (other) {
+        await this.hub.send(
+          other,
+          callPayload("call_ended", info, {
+            status: "call_ended",
+            ended_by: userId,
+            end_reason: "disconnected",
+            duration_seconds: info.duration
+          })
+        );
+      }
+      await this.finalized(info);
+    }
+  }
+  /** Offline hook: after a grace period end calls the user is still in (answered ones get longer). */
+  endCallsAfterDisconnect(userId) {
+    const cfg = this.config;
+    this.later(cfg.ringingDisconnectGrace, async () => {
+      try {
+        if (await this.hub.connections.isConnected(userId)) return;
+        await this.endUserCalls(userId, "ringing", "missed");
+        this.later(Math.max(0, cfg.answeredDisconnectGrace - cfg.ringingDisconnectGrace), async () => {
+          try {
+            if (await this.hub.connections.isConnected(userId)) return;
+            await this.endUserCalls(userId, "answered", "ended");
+          } catch (err) {
+            logger.error(`Ending calls for disconnected ${userId} failed`, err);
+          }
+        });
+      } catch (err) {
+        logger.error(`Ending calls for disconnected ${userId} failed`, err);
+      }
+    });
+  }
+  // ------------------------------------------------------------- connect
+  /** Re-ring a call still waiting for this user, on the new socket only, with the stored offer SDP. */
+  async onConnect(userId, ws) {
+    const service = this.service(this.hub.db);
+    const call = await service.getActiveCallForUser(userId);
+    if (!call || call.status !== "ringing" || call.receiverId !== userId) return;
+    const offerSdp = await service.getOfferSdp(call.callId);
+    this.remember(call);
+    const payload = await this.incomingPayload(call);
+    if (offerSdp) {
+      try {
+        payload.sdp = JSON.parse(offerSdp);
+      } catch {
+      }
+    }
+    await this.hub.connections.sendToSocket(ws, payload);
+  }
+  async incomingPayload(info) {
+    const profile = await this.hub.profile(info.callerId);
+    return callPayload("incoming_call", info, {
+      caller_name: profile?.name ? profile.name : "Someone",
+      caller_avatar: profile ? profile.avatar ?? null : null
+    });
+  }
+  // --------------------------------------------------------------- push
+  async pushIncoming(info, callerName, callerAvatar) {
+    await this.hub.push(
+      info.receiverId,
+      callerName,
+      `Incoming ${info.callType} call`,
+      {
+        type: "incoming_call",
+        call_id: info.callId,
+        chat_id: info.chatId,
+        caller_id: info.callerId,
+        caller_name: callerName,
+        caller_avatar: callerAvatar,
+        call_type: info.callType
+      },
+      this.config.ringtoneChannel,
+      Math.trunc(this.config.ringTimeout)
+    );
+  }
+  /** Receiver's app is not in the foreground: leave a missed-call notification (also stops a ringing one). */
+  async pushMissedCall(info) {
+    if (await this.hub.connections.isOnline(info.receiverId)) return;
+    const callerName = await this.hub.displayName(info.callerId);
+    await this.hub.push(
+      info.receiverId,
+      callerName,
+      `Missed ${info.callType} call`,
+      { type: "missed_call", call_id: info.callId, chat_id: info.chatId, caller_id: info.callerId, call_type: info.callType },
+      this.config.missedChannel
+    );
+  }
+};
+
+// src/call/policy.ts
+var allow = () => ({ allowed: true });
+var deny = (error, fields = {}) => ({
+  allowed: false,
+  error: { error, ...fields }
+});
+var AllowAllCallPolicy = class {
+  authorize() {
+    return allow();
+  }
+};
+
+// src/call/turn.ts
+import { createHmac } from "crypto";
+function turnCredentials(secret, uris, ttl = 3600, userId = null, now = null) {
+  const expiry = Math.trunc(now ?? Date.now() / 1e3) + ttl;
+  const username = userId ? `${expiry}:${userId}` : String(expiry);
+  return {
+    username,
+    password: createHmac("sha1", secret).update(username).digest("base64"),
+    ttl,
+    uris: [...uris]
+  };
+}
+
+// src/call/router.ts
+function buildCallRoutes(feature) {
+  const hub = feature.hub;
+  return [
+    {
+      method: "POST",
+      path: "/call/turn-credentials",
+      handler() {
+        const cfg = feature.config;
+        if (!cfg.turnSecret) throw new HttpError(503, "TURN is not configured");
+        return ok(turnCredentials(cfg.turnSecret, cfg.turnUris, cfg.turnTtl));
+      }
+    },
+    {
+      // Decline from the call notification while the app has no socket.
+      method: "POST",
+      path: "/call/:callId/reject",
+      async handler(ctx) {
+        const found = await feature.lifecycle.rejectFromNotification(hub.db, ctx.params.callId, ctx.userId);
+        if (!found) return { status: 404, body: { status: false, message: "Call not found" } };
+        return ok({ status: true });
+      }
+    }
+  ];
+}
+
+// src/call/feature.ts
+var CallFeature = class {
+  name = "call";
+  policy;
+  config;
+  chatBridge = null;
+  lifecycle;
+  handlers;
+  _hub = null;
+  constructor(opts = {}) {
+    this.policy = opts.policy ?? new AllowAllCallPolicy();
+    this.config = { ...defaultCallConfig(), ...opts.config ?? {} };
+  }
+  get hub() {
+    if (!this._hub) throw new Error("CallFeature is not installed; call hub.install(feature) first");
+    return this._hub;
+  }
+  install(hub) {
+    hub.registerFeature(this.name, this);
+    this._hub = hub;
+    this.lifecycle = new CallLifecycle(this);
+    this.handlers = new CallHandlers(this);
+    this.handlers.register();
+    hub.onConnect((uid, ws) => this.lifecycle.onConnect(uid, ws));
+    hub.onDisconnect((uid) => this.lifecycle.endCallsAfterDisconnect(uid));
+    hub.includeRoutes(buildCallRoutes(this));
+    const shutdown = hub.shutdown.bind(hub);
+    hub.shutdown = async () => {
+      this.lifecycle.cancelAll();
+      await shutdown();
+    };
+    return this;
+  }
+  /** End every live call between two users (e.g. on block). Both get `call_ended`; `call.finalized` is emitted. */
+  endCallsBetween(userA, userB, endReason, endedBy = null) {
+    return this.lifecycle.endCallsBetween(userA, userB, endReason, endedBy);
+  }
+  /**
+   * Account deletion: remove every calls row where the user is caller or receiver. Live calls are not
+   * signalled; disconnect the user first (or end their calls) if needed.
+   */
+  async deleteUserData(userId) {
+    const uid = String(userId);
+    const res = await this.hub.db.deleteFrom("calls").where((eb) => eb.or([eb("caller_id", "=", uid), eb("receiver_id", "=", uid)])).executeTakeFirst();
+    return { calls: Number(res.numDeletedRows) };
+  }
+};
+
+// src/call/uuid.ts
+import { createHash } from "crypto";
+var NAMESPACE_URL = "6ba7b811-9dad-11d1-80b4-00c04fd430c8";
+function uuidv5(name, namespace = NAMESPACE_URL) {
+  const ns = Buffer.from(namespace.replace(/-/g, ""), "hex");
+  const h = createHash("sha1").update(ns).update(Buffer.from(name, "utf8")).digest().subarray(0, 16);
+  h[6] = h[6] & 15 | 80;
+  h[8] = h[8] & 63 | 128;
+  const x = h.toString("hex");
+  return `${x.slice(0, 8)}-${x.slice(8, 12)}-${x.slice(12, 16)}-${x.slice(16, 20)}-${x.slice(20)}`;
+}
+var callkitUuid = (callId) => uuidv5(`commskit:call:${callId}`);
+
+export {
+  defaultCallConfig,
+  callPayload,
+  callerView,
+  busyPayload,
+  callError,
+  ACTIVE_CALL_STATUSES,
+  CallInfo,
+  callLogText,
+  CallService,
+  CallHandlers,
+  endStatus,
+  CallLifecycle,
+  allow,
+  deny,
+  AllowAllCallPolicy,
+  turnCredentials,
+  CallFeature,
+  uuidv5,
+  callkitUuid
+};
+//# sourceMappingURL=chunk-KL4WRZKZ.js.map