@snakechat/commskit-node 0.0.0-stage → 0.1.1

package/dist/chunk-U4Z5INIW.js

@@ -0,0 +1,1192 @@
+import {
+  LocalDiskStorage,
+  UploadRejected,
+  deleteMedia,
+  detectMediaType
+} from "./chunk-XQ6FLRX7.js";
+import {
+  HttpError,
+  dbBool,
+  dbNow,
+  dbTimestamp,
+  ddlTypes,
+  detectDialect,
+  firstQuery,
+  ok,
+  validationError
+} from "./chunk-GR4PMGCS.js";
+import {
+  RateLimit,
+  retryAfterSeconds
+} from "./chunk-BBFVG7QU.js";
+import {
+  LRU,
+  codePointLength,
+  iso,
+  nowIso,
+  parseDbDate,
+  pyBool,
+  pyStr,
+  truncateCodePoints
+} from "./chunk-KLKRK6OG.js";
+import {
+  logger
+} from "./chunk-5BJ2SNM5.js";
+
+// src/chat/dto.ts
+function messageDto(m, viewerId, replyTo = null, overrides = {}) {
+  const senderType = m.message_type === "system" ? "system" : m.sender_id === viewerId ? "user" : "other";
+  return {
+    id: m.id,
+    chat_id: m.chat_id,
+    sender_id: m.sender_id,
+    sender_type: senderType,
+    content: m.content,
+    message_type: m.message_type,
+    timestamp: iso(m.created_at),
+    file_url: m.file_url,
+    file_name: m.file_name,
+    file_size: m.file_size,
+    file_type: m.file_type,
+    thumbnail_url: m.thumbnail_url,
+    duration: m.duration ? Math.trunc(m.duration) : m.duration,
+    is_read: Boolean(m.is_read),
+    is_delivered: Boolean(m.is_delivered),
+    call_id: m.call_id,
+    reply_to: replyTo ? { ...replyTo } : null,
+    ...overrides
+  };
+}
+
+// src/chat/service.ts
+import { sql } from "kysely";
+var DELETED_TYPE = "deleted";
+var SYSTEM_TYPE = "system";
+var RESERVED_TYPES = /* @__PURE__ */ new Set([DELETED_TYPE, SYSTEM_TYPE]);
+var otherOf = (chat, userId) => chat.user1_id === userId ? chat.user2_id : chat.user1_id;
+var ChatActionError = class extends Error {
+  constructor(error, code, status = 400, extra = {}) {
+    super(error);
+    this.error = error;
+    this.code = code;
+    this.status = status;
+    this.extra = extra;
+    this.name = "ChatActionError";
+  }
+  error;
+  code;
+  status;
+  extra;
+  frame() {
+    const payload = { type: "error", error: this.error };
+    if (this.code) payload.code = this.code;
+    return { ...payload, ...this.extra };
+  }
+};
+var lastMessageSummary = (m) => ({
+  content: m.content,
+  sender_id: m.sender_id,
+  timestamp: iso(m.created_at),
+  message_type: m.message_type,
+  file_url: m.file_url,
+  file_size: m.file_size,
+  file_type: m.file_type,
+  file_name: m.file_name,
+  // Additive vs. the legacy server: lets the conversation list show ticks.
+  is_read: Boolean(m.is_read),
+  is_delivered: Boolean(m.is_delivered)
+});
+var toMessageRow = (r) => ({
+  id: Number(r.id),
+  chat_id: Number(r.chat_id),
+  sender_id: String(r.sender_id),
+  content: r.content ?? null,
+  message_type: r.message_type ?? null,
+  file_url: r.file_url ?? null,
+  file_name: r.file_name ?? null,
+  file_size: r.file_size === null || r.file_size === void 0 ? null : Number(r.file_size),
+  file_type: r.file_type ?? null,
+  thumbnail_url: r.thumbnail_url ?? null,
+  duration: r.duration === null || r.duration === void 0 ? null : Number(r.duration),
+  is_read: Boolean(r.is_read),
+  is_delivered: Boolean(r.is_delivered),
+  call_id: r.call_id ?? null,
+  reply_to_id: r.reply_to_id === null || r.reply_to_id === void 0 ? null : Number(r.reply_to_id),
+  created_at: r.created_at ?? null
+});
+var toChatRow = (r) => ({
+  id: Number(r.id),
+  user1_id: String(r.user1_id),
+  user2_id: String(r.user2_id),
+  created_at: r.created_at ?? null,
+  updated_at: r.updated_at ?? null
+});
+function visibleTo(userId) {
+  return sql`(messages.id > coalesce((select c.up_to_message_id from comms_chat_cleared c where c.user_id = ${userId} and c.chat_id = messages.chat_id), 0)
+    and not exists (select 1 from comms_message_hidden h where h.user_id = ${userId} and h.message_id = messages.id))`;
+}
+var notDeleted = sql`(messages.message_type is null or messages.message_type != ${DELETED_TYPE})`;
+var notRead = sql`coalesce(messages.is_read, false) = false`;
+var notDelivered = sql`coalesce(messages.is_delivered, false) = false`;
+var ChatService = class {
+  constructor(db, dialect) {
+    this.db = db;
+    this.dialect = dialect ?? detectDialect(db);
+  }
+  db;
+  dialect;
+  ts() {
+    return dbTimestamp(this.dialect);
+  }
+  // ---------------------------------------------------------------- chats
+  async getChatBetween(userA, userB) {
+    const [u1, u2] = [userA, userB].sort();
+    const row = await this.db.selectFrom("chats").selectAll().where("user1_id", "=", u1).where("user2_id", "=", u2).executeTakeFirst();
+    return row ? toChatRow(row) : null;
+  }
+  /** Idempotent per pair; survives a concurrent create (unique constraint). */
+  async getOrCreateChat(userA, userB) {
+    const existing = await this.getChatBetween(userA, userB);
+    if (existing) return existing;
+    const [u1, u2] = [userA, userB].sort();
+    try {
+      const now = this.ts();
+      await this.db.insertInto("chats").values({ user1_id: u1, user2_id: u2, created_at: now, updated_at: now }).execute();
+    } catch {
+    }
+    const found = await this.getChatBetween(userA, userB);
+    if (!found) throw new Error("Could not create chat");
+    return found;
+  }
+  /** Chat only if `userId` is a participant. */
+  async getChatForUser(chatId, userId) {
+    const row = await this.db.selectFrom("chats").selectAll().where("id", "=", chatId).where((eb) => eb.or([eb("user1_id", "=", userId), eb("user2_id", "=", userId)])).executeTakeFirst();
+    return row ? toChatRow(row) : null;
+  }
+  async partnerIds(userId) {
+    const rows = await this.db.selectFrom("chats").select(["user1_id", "user2_id"]).where((eb) => eb.or([eb("user1_id", "=", userId), eb("user2_id", "=", userId)])).execute();
+    return rows.map((r) => String(r.user1_id === userId ? r.user2_id : r.user1_id));
+  }
+  /** Chat summaries, newest first. "Last message per chat" via MAX(id) (ids grow with time). */
+  async getConversations(userId) {
+    const chats = (await this.db.selectFrom("chats").selectAll().where((eb) => eb.or([eb("user1_id", "=", userId), eb("user2_id", "=", userId)])).execute()).map(toChatRow);
+    if (!chats.length) return [];
+    const chatIds = chats.map((c) => c.id);
+    const lastRows = await this.db.selectFrom("messages").select(["chat_id", (eb) => eb.fn.max("id").as("last_id")]).where("chat_id", "in", chatIds).where(visibleTo(userId)).groupBy("chat_id").execute();
+    const lastIds = lastRows.map((r) => Number(r.last_id));
+    const lastById = /* @__PURE__ */ new Map();
+    if (lastIds.length) {
+      for (const m of await this.db.selectFrom("messages").selectAll().where("id", "in", lastIds).execute()) {
+        const row = toMessageRow(m);
+        lastById.set(row.chat_id, row);
+      }
+    }
+    const unreadRows = await this.db.selectFrom("messages").select(["chat_id", (eb) => eb.fn.countAll().as("n")]).where("chat_id", "in", chatIds).where("sender_id", "!=", userId).where(notRead).where(notDeleted).where(visibleTo(userId)).groupBy("chat_id").execute();
+    const unread = new Map(unreadRows.map((r) => [Number(r.chat_id), Number(r.n)]));
+    const convs = chats.map((c) => ({
+      chat_id: c.id,
+      other_user_id: otherOf(c, userId),
+      updated_at: iso(c.updated_at),
+      last_message: lastById.has(c.id) ? lastMessageSummary(lastById.get(c.id)) : null,
+      unread_count: unread.get(c.id) ?? 0
+    }));
+    convs.sort((a, b) => {
+      const ua = a.updated_at ?? "";
+      const ub = b.updated_at ?? "";
+      return ua === ub ? b.chat_id - a.chat_id : ua < ub ? 1 : -1;
+    });
+    return convs;
+  }
+  // ------------------------------------------------------------- messages
+  /** Stores a message and bumps the chat's `updated_at` (one transaction). */
+  async sendMessage(chatId, senderId, content, messageType = "text", opts = {}) {
+    const replyTo = await this.validReplyTarget(chatId, opts.replyToId);
+    const now = this.ts();
+    const media = opts.media;
+    const row = await this.db.transaction().execute(async (trx) => {
+      const inserted = await trx.insertInto("messages").values({
+        chat_id: chatId,
+        sender_id: senderId,
+        content,
+        message_type: messageType,
+        reply_to_id: replyTo,
+        is_read: dbBool(this.dialect, false),
+        is_delivered: dbBool(this.dialect, false),
+        is_call: dbBool(this.dialect, Boolean(opts.callId)),
+        call_id: opts.callId || null,
+        file_url: media?.file_url ?? null,
+        file_name: media?.file_name ?? null,
+        file_size: media?.file_size ?? null,
+        file_type: media?.file_type ?? null,
+        thumbnail_url: media?.thumbnail_url ?? null,
+        duration: media?.duration ?? null,
+        created_at: now
+      }).returningAll().executeTakeFirstOrThrow();
+      await trx.updateTable("chats").set({ updated_at: now }).where("id", "=", chatId).execute();
+      return inserted;
+    });
+    return toMessageRow(row);
+  }
+  /** Only messages from the same chat can be quoted. */
+  async validReplyTarget(chatId, replyToId) {
+    if (replyToId === null || replyToId === void 0 || typeof replyToId === "boolean") return null;
+    const id = typeof replyToId === "number" ? Math.trunc(replyToId) : /^\s*-?\d+\s*$/.test(String(replyToId)) ? Number(replyToId) : NaN;
+    if (!Number.isFinite(id)) return null;
+    const r = await this.db.selectFrom("messages").select("id").where("id", "=", id).where("chat_id", "=", chatId).executeTakeFirst();
+    return r ? Number(r.id) : null;
+  }
+  async getReplyPreviews(messageIds) {
+    const ids = [...new Set(messageIds.filter((i) => i !== null && i !== void 0))];
+    const out = /* @__PURE__ */ new Map();
+    if (!ids.length) return out;
+    const rows = await this.db.selectFrom("messages").select(["id", "sender_id", "content", "message_type", "file_name"]).where("id", "in", ids).execute();
+    for (const r of rows) {
+      out.set(Number(r.id), {
+        id: Number(r.id),
+        sender_id: r.sender_id,
+        content: r.content,
+        message_type: r.message_type,
+        file_name: r.file_name
+      });
+    }
+    return out;
+  }
+  /** Newest first. With `viewerId`, that user's hidden / cleared messages are left out. */
+  async getMessagesPage(chatId, limit = 50, offset = 0, viewerId) {
+    let q = this.db.selectFrom("messages").selectAll().where("chat_id", "=", chatId);
+    if (viewerId) q = q.where(visibleTo(viewerId));
+    const rows = await q.orderBy("created_at", "desc").orderBy("id", "desc").limit(limit).offset(offset).execute();
+    return rows.map(toMessageRow);
+  }
+  async getLastMessage(chatId, viewerId) {
+    return (await this.getMessagesPage(chatId, 1, 0, viewerId))[0] ?? null;
+  }
+  async getMessage(messageId) {
+    const row = await this.db.selectFrom("messages").selectAll().where("id", "=", messageId).executeTakeFirst();
+    return row ? toMessageRow(row) : null;
+  }
+  /** Read receipts are per chat: everything the other person sent becomes read + delivered. */
+  async markMessagesAsRead(chatId, userId) {
+    await this.db.updateTable("messages").set({ is_read: dbBool(this.dialect, true), is_delivered: dbBool(this.dialect, true) }).where("chat_id", "=", chatId).where("sender_id", "!=", userId).where(notRead).execute();
+  }
+  async markDelivered(messageIds) {
+    if (!messageIds.length) return;
+    await this.db.updateTable("messages").set({ is_delivered: dbBool(this.dialect, true) }).where("id", "in", messageIds).execute();
+  }
+  /** Mark everything sent to `userId` delivered; returns [chat_id, sender_id, message_id] (system messages excluded). */
+  async markDeliveredForRecipient(userId) {
+    const rows = await this.db.selectFrom("messages").select(["chat_id", "sender_id", "id", "message_type"]).where(
+      "chat_id",
+      "in",
+      (eb) => eb.selectFrom("chats").select("id").where((e2) => e2.or([e2("user1_id", "=", userId), e2("user2_id", "=", userId)]))
+    ).where("sender_id", "!=", userId).where(notDelivered).execute();
+    if (rows.length) await this.markDelivered(rows.map((r) => Number(r.id)));
+    return rows.filter((r) => r.message_type !== SYSTEM_TYPE).map((r) => [Number(r.chat_id), String(r.sender_id), Number(r.id)]);
+  }
+  async getUnreadCount(userId) {
+    const r = await this.db.selectFrom("messages").innerJoin("chats", "messages.chat_id", "chats.id").select((eb) => eb.fn.count("messages.id").as("n")).where((eb) => eb.or([eb("chats.user1_id", "=", userId), eb("chats.user2_id", "=", userId)])).where("messages.sender_id", "!=", userId).where(notRead).where(notDeleted).where(visibleTo(userId)).executeTakeFirst();
+    return Number(r?.n ?? 0);
+  }
+  // ------------------------------------------------- delete / unsend / clear
+  /** Delete for me (idempotent). Does not check access; callers do. */
+  async hideMessage(userId, messageId) {
+    const existing = await this.db.selectFrom("comms_message_hidden").select("id").where("user_id", "=", userId).where("message_id", "=", messageId).executeTakeFirst();
+    if (existing) return;
+    try {
+      await this.db.insertInto("comms_message_hidden").values({ user_id: userId, message_id: messageId, created_at: this.ts() }).execute();
+    } catch {
+    }
+  }
+  /**
+   * Rewrite the row as `deleted` for everyone; returns the new row and the media URLs to delete.
+   * `windowSeconds` > 0: throws `window_expired` for older messages.
+   */
+  async unsendMessage(messageId, windowSeconds) {
+    const message = await this.getMessage(messageId);
+    if (!message) throw new ChatActionError("Message not found", "not_found", 404);
+    const created = parseDbDate(message.created_at);
+    if (windowSeconds > 0 && created) {
+      const age = (dbNow().getTime() - created.getTime()) / 1e3;
+      if (age > windowSeconds) {
+        throw new ChatActionError("This message can no longer be deleted for everyone", "window_expired", 403);
+      }
+    }
+    const urls = [message.file_url, message.thumbnail_url].filter((u) => !!u);
+    await this.db.updateTable("messages").set({
+      message_type: DELETED_TYPE,
+      content: null,
+      file_url: null,
+      file_name: null,
+      file_size: null,
+      file_type: null,
+      thumbnail_url: null,
+      duration: null
+    }).where("id", "=", messageId).execute();
+    const row = await this.getMessage(messageId);
+    return [row, urls];
+  }
+  /** Hide every message of the chat, up to now, for `userId` only. Returns `cleared_at`. */
+  async clearChat(userId, chatId) {
+    const maxRow = await this.db.selectFrom("messages").select((eb) => eb.fn.max("id").as("m")).where("chat_id", "=", chatId).executeTakeFirst();
+    const upTo = Number(maxRow?.m ?? 0);
+    const now = dbNow();
+    const stamp = dbTimestamp(this.dialect, now);
+    const row = await this.db.selectFrom("comms_chat_cleared").selectAll().where("user_id", "=", userId).where("chat_id", "=", chatId).executeTakeFirst();
+    if (!row) {
+      await this.db.insertInto("comms_chat_cleared").values({ user_id: userId, chat_id: chatId, cleared_at: stamp, up_to_message_id: upTo }).execute();
+    } else {
+      await this.db.updateTable("comms_chat_cleared").set({ cleared_at: stamp, up_to_message_id: Math.max(Number(row.up_to_message_id ?? 0), upTo) }).where("id", "=", row.id).execute();
+    }
+    await this.db.deleteFrom("comms_message_hidden").where("user_id", "=", userId).where("message_id", "in", (eb) => eb.selectFrom("messages").select("id").where("chat_id", "=", chatId).where("id", "<=", upTo)).execute();
+    return now;
+  }
+  // ----------------------------------------------------------- moderation
+  /**
+   * Newest first: up to `before` older messages, the message itself, up to `after` newer ones.
+   * Without a `messageId` from this chat: the latest `before + after + 1` messages. Ignores hides / clears.
+   */
+  async messagesAround(chatId, messageId, before = 20, after = 20) {
+    before = Math.max(0, before);
+    after = Math.max(0, after);
+    let anchor = null;
+    if (messageId !== null) {
+      const r = await this.db.selectFrom("messages").select("id").where("id", "=", messageId).where("chat_id", "=", chatId).executeTakeFirst();
+      anchor = r ? Number(r.id) : null;
+    }
+    if (anchor === null) return this.getMessagesPage(chatId, before + after + 1);
+    const older = await this.db.selectFrom("messages").selectAll().where("chat_id", "=", chatId).where("id", "<=", anchor).orderBy("id", "desc").limit(before + 1).execute();
+    const newer = after ? await this.db.selectFrom("messages").selectAll().where("chat_id", "=", chatId).where("id", ">", anchor).orderBy("id", "asc").limit(after).execute() : [];
+    return [...newer.reverse().map(toMessageRow), ...older.map(toMessageRow)];
+  }
+  // -------------------------------------------------------------- deletion
+  /**
+   * Delete every chat `userId` is in, with all its messages (a 1:1 chat has one shared copy, so the
+   * partner loses that conversation too), hides and clears. Returns counts and the media URLs to delete.
+   */
+  async deleteUserData(userId) {
+    const chatIds = (await this.db.selectFrom("chats").select("id").where((eb) => eb.or([eb("user1_id", "=", userId), eb("user2_id", "=", userId)])).execute()).map((r) => Number(r.id));
+    const counts = { chats: chatIds.length, messages: 0 };
+    const urls = [];
+    await this.db.transaction().execute(async (trx) => {
+      if (chatIds.length) {
+        for (const r of await trx.selectFrom("messages").select(["file_url", "thumbnail_url"]).where("chat_id", "in", chatIds).execute()) {
+          for (const u of [r.file_url, r.thumbnail_url]) if (u) urls.push(u);
+        }
+        const messageIds = (eb) => eb.selectFrom("messages").select("id").where("chat_id", "in", chatIds);
+        await trx.deleteFrom("comms_message_hidden").where("message_id", "in", messageIds).execute();
+        await trx.deleteFrom("comms_chat_cleared").where("chat_id", "in", chatIds).execute();
+        await trx.updateTable("messages").set({ reply_to_id: null }).where("chat_id", "in", chatIds).execute();
+        const res = await trx.deleteFrom("messages").where("chat_id", "in", chatIds).executeTakeFirst();
+        counts.messages = Number(res.numDeletedRows ?? 0);
+        await trx.deleteFrom("chats").where("id", "in", chatIds).execute();
+      }
+      await trx.deleteFrom("comms_message_hidden").where("user_id", "=", userId).execute();
+      await trx.deleteFrom("comms_chat_cleared").where("user_id", "=", userId).execute();
+    });
+    return [counts, urls];
+  }
+  // ---------------------------------------------------------- call entries
+  /** Set a call entry's text; returns its message id (null when none). Used by the call/chat link. */
+  async rewriteCallMessage(callId, content) {
+    const r = await this.db.selectFrom("messages").select("id").where("call_id", "=", callId).executeTakeFirst();
+    if (!r) return null;
+    await this.db.updateTable("messages").set({ content }).where("id", "=", r.id).execute();
+    return Number(r.id);
+  }
+};
+
+// src/chat/handlers.ts
+var ATTACHMENT_PREVIEW = "\u{1F4CE} Attachment";
+var errorFrame = (error, extra = {}) => ({ type: "error", error, ...extra });
+function pyInt(value) {
+  if (typeof value === "number" && Number.isFinite(value)) return Math.trunc(value);
+  if (typeof value === "boolean") return value ? 1 : 0;
+  if (typeof value === "string" && /^\s*[+-]?\d+\s*$/.test(value)) return Number(value);
+  throw new Error(`invalid literal for int() with base 10: ${JSON.stringify(value)}`);
+}
+function intOrNull(value) {
+  if (value === null || value === void 0 || value === "" || typeof value === "boolean") return null;
+  try {
+    return pyInt(value);
+  } catch {
+    return null;
+  }
+}
+var errMsg = (e) => e instanceof Error ? e.message : String(e);
+var ChatHandlers = class {
+  constructor(feature) {
+    this.feature = feature;
+    this.hub = feature.hub;
+  }
+  feature;
+  hub;
+  pairChatIds = new LRU(2e4);
+  get config() {
+    return this.feature.config;
+  }
+  // Read on every use: integrations (e.g. moderation) may wrap feature.policy after install.
+  get policy() {
+    return this.feature.policy;
+  }
+  service(db) {
+    return new ChatService(db, this.hub.dialect);
+  }
+  register() {
+    const on = (t, fn) => this.hub.on(t, fn.bind(this));
+    on("req_users", this.reqUsers);
+    on("get_messages", this.getMessages);
+    on("send_message", this.sendMessage);
+    on("mark_read", this.markRead);
+    on("typing", this.typing);
+    on("media_upload", this.mediaUpload);
+    on("delete_message", this.deleteMessage);
+    on("clear_chat", this.clearChat);
+  }
+  forgetUser(userId) {
+    this.pairChatIds.discardWhere((pair) => pair.split("\0").includes(userId));
+  }
+  reply(userId, payload) {
+    return this.hub.send(userId, payload);
+  }
+  async failed(userId, message, err, error) {
+    logger.error(`${message?.type ?? "chat handler"} failed`, err);
+    await this.hub.reportHandlerError(userId, message, err);
+    await this.reply(userId, errorFrame(error));
+  }
+  /** Seconds to wait (0 = allowed). Takes a token when allowed. */
+  async rateLimited(userId, action, limit) {
+    if (!limit) return 0;
+    return this.hub.rateLimiter.hit(`${action}:${userId}`, limit);
+  }
+  // ---------------------------------------------------------------- lists
+  async reqUsers(userId, message, db) {
+    try {
+      const convs = (await this.service(db).getConversations(userId)).filter((c) => c.other_user_id !== userId);
+      const otherIds = convs.map((c) => c.other_user_id);
+      const profiles = await this.hub.profiles(otherIds);
+      const online = otherIds.length ? await this.hub.connections.getOnlineUsers(otherIds) : /* @__PURE__ */ new Set();
+      const blocks = otherIds.length ? await this.policy.blockStatus(db, userId, otherIds) : {};
+      const users = convs.map((conv) => {
+        const other = conv.other_user_id;
+        const profile = profiles[other];
+        const last = conv.last_message;
+        const [isBlocked, blockedByOther] = blocks[other] ?? [false, false];
+        return {
+          user_id: other,
+          username: profile?.name ? profile.name : other,
+          avatar: profile ? profile.avatar ?? null : null,
+          status: online.has(other) ? "online" : "offline",
+          updated_at: last ? last.timestamp : null,
+          unread_count: conv.unread_count,
+          last_message: last,
+          chat_id: conv.chat_id,
+          is_blocked: Boolean(isBlocked),
+          blocked_by_other: Boolean(blockedByOther)
+        };
+      });
+      users.sort((a, b) => {
+        const ka = `${a.updated_at ?? ""}\0${a.user_id}`;
+        const kb = `${b.updated_at ?? ""}\0${b.user_id}`;
+        return ka < kb ? 1 : ka > kb ? -1 : 0;
+      });
+      await this.reply(userId, { type: "res_users", users });
+    } catch (err) {
+      logger.error("req_users failed", err);
+      await this.hub.reportHandlerError(userId, message, err);
+      await this.reply(userId, { type: "req_users_error", error: `Failed to retrieve users: ${errMsg(err)}` });
+    }
+  }
+  async getMessages(userId, message, db) {
+    try {
+      const service = this.service(db);
+      const cfg = this.config;
+      const limit = Math.max(1, Math.min(pyInt(message.limit ?? cfg.defaultPageSize), cfg.maxPageSize));
+      const offset = Math.max(0, pyInt(message.offset ?? 0));
+      let chat;
+      let otherId;
+      if (pyBool(message.chat_id)) {
+        chat = await service.getChatForUser(pyInt(message.chat_id), userId);
+        if (!chat) {
+          await this.reply(userId, errorFrame("Chat not found"));
+          return;
+        }
+        otherId = otherOf(chat, userId);
+      } else {
+        if (!pyBool(message.candidate_user_id)) {
+          await this.reply(userId, errorFrame("Missing required fields: chat_id or candidate_user_id"));
+          return;
+        }
+        otherId = pyStr(message.candidate_user_id);
+        chat = await service.getChatBetween(userId, otherId);
+      }
+      let rows = chat ? await service.getMessagesPage(chat.id, limit + 1, offset, userId) : [];
+      const hasMore = rows.length > limit;
+      rows = rows.slice(0, limit);
+      const last = rows.length && offset === 0 ? rows[0] : chat ? await service.getLastMessage(chat.id, userId) : null;
+      const profile = await this.hub.profile(otherId);
+      const blocks = await this.policy.blockStatus(db, userId, [otherId]);
+      const [isBlocked, blockedByOther] = blocks[otherId] ?? [false, false];
+      const info = {
+        user_id: otherId,
+        username: profile?.name ? profile.name : otherId,
+        avatar: profile ? profile.avatar ?? null : null,
+        status: await this.hub.connections.isOnline(otherId) ? "online" : "offline",
+        last_seen: last ? iso(last.created_at) : null,
+        ...await this.policy.extraConversationInfo(db, userId, otherId),
+        is_blocked: Boolean(isBlocked),
+        blocked_by_other: Boolean(blockedByOther)
+      };
+      const previews = await service.getReplyPreviews(rows.map((m) => m.reply_to_id));
+      const messages = rows.map((m) => messageDto(m, userId, m.reply_to_id ? previews.get(m.reply_to_id) : null));
+      await this.reply(userId, { type: "res_messages", messages, offset, has_more: hasMore, info });
+    } catch (err) {
+      await this.failed(userId, message, err, `Failed to retrieve messages: ${errMsg(err)}`);
+    }
+  }
+  // -------------------------------------------------------------- sending
+  /**
+   * Store + deliver a message (WS `send_message`, `POST /chats/send`, `sendMessageAs`).
+   * Returns the MessageDto as the sender sees it. Throws `ChatActionError` when refused.
+   */
+  async sendText(db, sender, recipient, content, opts = {}) {
+    const checkPolicy = opts.checkPolicy ?? true;
+    const rateLimit = opts.rateLimit ?? true;
+    let messageType = opts.messageType ?? "text";
+    if (sender === recipient) throw new ChatActionError("Cannot send a message to yourself.", void 0, 400);
+    const text = typeof content === "string" ? content : pyStr(content);
+    const maxLen = this.config.maxTextLength;
+    if (maxLen && codePointLength(text) > maxLen) {
+      throw new ChatActionError(`Message is too long (max ${maxLen} characters).`, "too_long", 422, { max: maxLen });
+    }
+    if (rateLimit) {
+      const wait = await this.rateLimited(sender, "chat.message", this.config.messageRate);
+      if (wait) {
+        const seconds = retryAfterSeconds(wait);
+        throw new ChatActionError(`Too many messages. Try again in ${seconds} s.`, "rate_limited", 429, { retry_after: seconds });
+      }
+    }
+    if (checkPolicy && !await this.policy.canMessage(db, sender, recipient)) {
+      throw new ChatActionError(this.policy.refusalMessage, void 0, 403);
+    }
+    if (RESERVED_TYPES.has(messageType)) messageType = "text";
+    const service = this.service(db);
+    const chat = await service.getOrCreateChat(sender, recipient);
+    const row = await service.sendMessage(chat.id, sender, text, messageType, { replyToId: opts.replyToId });
+    const replyTo = row.reply_to_id ? (await service.getReplyPreviews([row.reply_to_id])).get(row.reply_to_id) : null;
+    const preview = messageType === "text" ? truncateCodePoints(text, this.config.pushPreviewChars) : ATTACHMENT_PREVIEW;
+    return this.deliver(db, row, recipient, replyTo, text, text, preview);
+  }
+  async sendMessage(userId, message, db) {
+    try {
+      const recipient = message.candidate_user_id;
+      const content = message.content;
+      if (!pyBool(recipient) || !pyBool(content)) {
+        await this.reply(userId, errorFrame("Missing required fields: candidate_user_id, content"));
+        return;
+      }
+      await this.sendText(db, userId, pyStr(recipient), content, {
+        messageType: pyBool(message.message_type) ? pyStr(message.message_type) : "text",
+        replyToId: message.reply_to_id
+      });
+    } catch (err) {
+      if (err instanceof ChatActionError) await this.reply(userId, err.frame());
+      else await this.failed(userId, message, err, `Failed to send message: ${errMsg(err)}`);
+    }
+  }
+  /** new_message -> recipient, mark delivered, offline push, message_sent -> sender. */
+  async deliver(db, row, recipient, replyTo, recipientContent, senderContent, preview) {
+    const sender = row.sender_id;
+    const delivered = await this.hub.send(recipient, {
+      type: "new_message",
+      message: messageDto(row, recipient, replyTo, { content: recipientContent, is_read: false, is_delivered: true })
+    });
+    if (delivered) await this.service(db).markDelivered([row.id]);
+    await this.notifyOffline(recipient, sender, row.chat_id, preview);
+    const sent = messageDto(row, sender, replyTo, { content: senderContent, is_read: false, is_delivered: delivered });
+    await this.hub.send(sender, { type: "message_sent", message: sent });
+    await this.hub.events.emit("chat.message_sent", sent);
+    return sent;
+  }
+  /** Push when the recipient has no foreground socket anywhere. */
+  async notifyOffline(recipient, sender, chatId, preview, title, extra) {
+    if (await this.hub.connections.isOnline(recipient)) return;
+    const t = title ?? await this.hub.displayName(sender, "New message");
+    const data = {
+      ...extra ?? {},
+      type: "chat",
+      cid: `messaging:${sender}`,
+      // legacy routing key used by installed apps
+      chat_id: chatId,
+      sender_id: sender
+    };
+    this.hub.spawn(this.hub.push(recipient, t, preview, data, this.config.pushChannel));
+  }
+  async mediaUpload(userId, message, db) {
+    const recipientRaw = message.target_user_id;
+    const fileName = message.file_name;
+    const fileData = message.file_data;
+    if (!pyBool(recipientRaw) || !pyBool(fileName) || !pyBool(fileData)) {
+      await this.reply(userId, errorFrame("Missing required fields: target_user_id, file_name, file_data"));
+      return;
+    }
+    const recipient = pyStr(recipientRaw);
+    const maxBytes = this.config.maxUploadBytes;
+    const tooLarge = errorFrame(`File too large. Maximum allowed size is ${Math.floor(maxBytes / (1024 * 1024))} MB.`);
+    try {
+      if (userId === recipient) {
+        await this.reply(userId, errorFrame("Cannot send a message to yourself."));
+        return;
+      }
+      if (!await this.policy.canMessage(db, userId, recipient)) {
+        await this.reply(userId, errorFrame(this.policy.refusalMessage));
+        return;
+      }
+      if (typeof fileData !== "string") {
+        await this.reply(userId, errorFrame("file_data must be a base64 string"));
+        return;
+      }
+      if (fileData.length > Math.floor(maxBytes * 4 / 3) + 4) {
+        await this.reply(userId, tooLarge);
+        return;
+      }
+      const wait = await this.rateLimited(userId, "chat.upload", this.config.uploadRate);
+      if (wait) {
+        const seconds = retryAfterSeconds(wait);
+        await this.reply(userId, errorFrame(`Too many uploads. Try again in ${seconds} s.`, { code: "rate_limited", retry_after: seconds }));
+        return;
+      }
+      if (!/^[A-Za-z0-9+/\s]*={0,2}\s*$/.test(fileData) || fileData.replace(/\s/g, "").length % 4 === 1) {
+        await this.reply(userId, errorFrame("Invalid base64 file_data"));
+        return;
+      }
+      const content = Buffer.from(fileData, "base64");
+      if (content.length > maxBytes) {
+        await this.reply(userId, tooLarge);
+        return;
+      }
+      const mediaType = detectMediaType(pyStr(fileName), message.media_type);
+      if (mediaType === null) {
+        await this.reply(userId, errorFrame(`Unsupported file type: ${pyStr(fileName)}`));
+        return;
+      }
+      const service = this.service(db);
+      const chat = await service.getOrCreateChat(userId, recipient);
+      let media;
+      try {
+        media = await this.feature.storage.upload(chat.id, pyStr(fileName), content, mediaType);
+      } catch (err) {
+        if (err instanceof UploadRejected) {
+          await this.reply(userId, errorFrame(err.message));
+          return;
+        }
+        throw err;
+      }
+      if (pyBool(message.file_type) && !media.file_type) media.file_type = pyStr(message.file_type);
+      const text = `[${media.media_type.toUpperCase()}] ${pyStr(fileName)}`;
+      const row = await service.sendMessage(chat.id, userId, text, media.media_type, { media, replyToId: message.reply_to_id });
+      const replyTo = row.reply_to_id ? (await service.getReplyPreviews([row.reply_to_id])).get(row.reply_to_id) : null;
+      await this.reply(userId, {
+        type: "media_upload_success",
+        message: messageDto(row, userId, replyTo, { content: null, is_read: false, is_delivered: true })
+      });
+      await this.deliver(db, row, recipient, replyTo, text, null, ATTACHMENT_PREVIEW);
+    } catch (err) {
+      await this.failed(userId, message, err, `Server error: ${errMsg(err)}`);
+    }
+  }
+  // ------------------------------------------------------ receipts/typing
+  /** `chat_id` wins; otherwise the chat with `candidate_user_id`. Null if not a participant. */
+  async resolveChat(service, userId, chatId, candidate) {
+    const cid = intOrNull(chatId);
+    if (cid !== null) return service.getChatForUser(cid, userId);
+    if (candidate !== null && candidate !== void 0 && candidate !== "" && pyStr(candidate) !== userId) {
+      return service.getChatBetween(userId, pyStr(candidate));
+    }
+    return null;
+  }
+  async markRead(userId, message, db) {
+    const { chat_id: chatId, candidate_user_id: candidate } = message;
+    if (!pyBool(chatId) && !pyBool(candidate)) {
+      await this.reply(userId, errorFrame("Missing chat_id"));
+      return;
+    }
+    const service = this.service(db);
+    const chat = await this.resolveChat(service, userId, chatId, candidate);
+    if (!chat) {
+      await this.reply(userId, errorFrame("Chat not found"));
+      return;
+    }
+    await service.markMessagesAsRead(chat.id, userId);
+    await this.notifyRead(chat.id, userId, otherOf(chat, userId));
+  }
+  async notifyRead(chatId, reader, other) {
+    await this.hub.send(reader, { type: "chat_read", chat_id: chatId });
+    await this.hub.send(other, { type: "messages_read", chat_id: chatId, read_by: reader });
+  }
+  async typing(userId, message, db) {
+    const targetRaw = message.target_user_id;
+    if (!pyBool(targetRaw) || pyStr(targetRaw) === userId) return;
+    const target = pyStr(targetRaw);
+    const isTyping = pyBool(message.is_typing ?? false);
+    if (isTyping && await this.rateLimited(userId, "chat.typing", this.config.typingRate)) return;
+    if (!await this.policy.canMessage(db, userId, target)) return;
+    const pair = [userId, target].sort().join("\0");
+    let chatId = this.pairChatIds.get(pair);
+    if (chatId === void 0) {
+      const chat = await this.service(db).getChatBetween(userId, target);
+      if (!chat) return;
+      chatId = chat.id;
+      this.pairChatIds.put(pair, chatId);
+    }
+    await this.hub.send(target, { type: "typing_status", user_id: userId, chat_id: chatId, is_typing: isTyping, timestamp: nowIso() });
+  }
+  // --------------------------------------------------------- delete / clear
+  async deleteMessage(userId, message, db) {
+    const messageId = intOrNull(message.message_id);
+    if (messageId === null) {
+      await this.reply(userId, errorFrame("Missing required fields: message_id", { code: "not_found" }));
+      return;
+    }
+    try {
+      await this.deleteFor(db, userId, messageId, pyBool(message.for_everyone ?? false));
+    } catch (err) {
+      if (err instanceof ChatActionError) await this.reply(userId, err.frame());
+      else await this.failed(userId, message, err, `Failed to delete message: ${errMsg(err)}`);
+    }
+  }
+  /** Delete for me / unsend for everyone. Sends `message_deleted`; throws `ChatActionError`. */
+  async deleteFor(db, userId, messageId, forEveryone) {
+    const service = this.service(db);
+    const row = await service.getMessage(messageId);
+    const chat = row ? await service.getChatForUser(row.chat_id, userId) : null;
+    if (!row || !chat) throw new ChatActionError("Message not found", "not_found", 404);
+    const payload = { type: "message_deleted", chat_id: row.chat_id, message_id: row.id, for_everyone: forEveryone };
+    if (!forEveryone) {
+      await service.hideMessage(userId, row.id);
+      await this.hub.send(userId, payload);
+      await this.hub.events.emit("chat.message_deleted", { ...payload, user_id: userId });
+      return payload;
+    }
+    const windowSeconds = Math.trunc(this.config.unsendWindowSeconds);
+    if (windowSeconds < 0) throw new ChatActionError("Deleting for everyone is disabled", "not_allowed", 403);
+    if (row.sender_id !== userId) throw new ChatActionError("Only the sender can delete a message for everyone", "not_allowed", 403);
+    if (row.call_id || row.message_type === SYSTEM_TYPE) {
+      throw new ChatActionError("This message can't be deleted for everyone", "not_allowed", 403);
+    }
+    if (row.message_type !== DELETED_TYPE) {
+      const [, urls] = await service.unsendMessage(row.id, windowSeconds);
+      if (urls.length) this.hub.spawn(deleteMedia(this.feature.storage, ...urls));
+    }
+    await this.hub.send(userId, payload);
+    await this.hub.send(otherOf(chat, userId), payload);
+    await this.hub.events.emit("chat.message_deleted", { ...payload, user_id: userId });
+    return payload;
+  }
+  async clearChat(userId, message, db) {
+    const { chat_id: chatId, candidate_user_id: candidate } = message;
+    try {
+      if (!pyBool(chatId) && !pyBool(candidate)) {
+        throw new ChatActionError("Missing required fields: chat_id or candidate_user_id", "not_found", 404);
+      }
+      await this.clearFor(db, userId, chatId, candidate);
+    } catch (err) {
+      if (err instanceof ChatActionError) await this.reply(userId, err.frame());
+      else await this.failed(userId, message, err, `Failed to clear chat: ${errMsg(err)}`);
+    }
+  }
+  async clearFor(db, userId, chatId, candidate) {
+    const service = this.service(db);
+    const chat = await this.resolveChat(service, userId, chatId, candidate);
+    if (!chat) throw new ChatActionError("Chat not found", "not_found", 404);
+    const clearedAt = await service.clearChat(userId, chat.id);
+    const payload = { type: "chat_cleared", chat_id: chat.id, cleared_at: iso(clearedAt) };
+    await this.hub.send(userId, payload);
+    return payload;
+  }
+  // -------------------------------------------------------------- connect
+  /** Flush delivery receipts for messages that arrived while the user was offline. */
+  async onConnect(userId, _ws) {
+    const rows = await this.service(this.hub.db).markDeliveredForRecipient(userId);
+    const grouped = /* @__PURE__ */ new Map();
+    for (const [chatId, senderId, messageId] of rows) {
+      const key = `${chatId}\0${senderId}`;
+      if (!grouped.has(key)) grouped.set(key, { chatId, senderId, ids: [] });
+      grouped.get(key).ids.push(messageId);
+    }
+    for (const { chatId, senderId, ids } of grouped.values()) {
+      await this.hub.send(senderId, {
+        type: "delivery_status",
+        chat_id: chatId,
+        message_ids: ids.sort((a, b) => a - b),
+        status: "delivered",
+        timestamp: nowIso()
+      });
+    }
+  }
+};
+
+// src/chat/policy.ts
+var AllowAllChatPolicy = class {
+  refusalMessage = "Cannot send message. User is blocked.";
+  async canMessage() {
+    return true;
+  }
+  async blockStatus() {
+    return {};
+  }
+  async extraConversationInfo() {
+    return { chat_consent_given: true };
+  }
+};
+
+// src/chat/router.ts
+function bodyObject(ctx) {
+  const b = ctx.body;
+  if (b === null || typeof b !== "object" || Array.isArray(b)) {
+    throw new HttpError(422, [{ type: "missing", loc: ["body"], msg: "Field required", input: null }]);
+  }
+  return b;
+}
+function intParam(where, name, raw, def, min, max) {
+  if (raw === void 0) {
+    if (def === void 0) throw validationError(where, name, "missing", "Field required");
+    return def;
+  }
+  if (!/^\s*[+-]?\d+\s*$/.test(raw)) {
+    throw validationError(where, name, "int_parsing", "Input should be a valid integer, unable to parse string as an integer", raw);
+  }
+  const n = Number(raw);
+  if (min !== void 0 && n < min) {
+    throw validationError(where, name, "greater_than_equal", `Input should be greater than or equal to ${min}`, raw);
+  }
+  if (max !== void 0 && n > max) {
+    throw validationError(where, name, "less_than_equal", `Input should be less than or equal to ${max}`, raw);
+  }
+  return n;
+}
+function buildChatRoutes(feature) {
+  const hub = feature.hub;
+  const svc = () => feature.handlers.service(hub.db);
+  const ensureSelf = (pathUserId, authUserId) => {
+    if (pathUserId !== authUserId) throw new HttpError(403, "Not allowed");
+  };
+  const actionError = (exc) => {
+    const { type: _type, ...body } = exc.frame();
+    const headers = "retry_after" in exc.extra ? { "Retry-After": String(exc.extra.retry_after) } : void 0;
+    return { status: exc.status, headers, body: { detail: body, ...body } };
+  };
+  const routes = [
+    {
+      method: "POST",
+      path: "/chats/start",
+      async handler(ctx) {
+        const candidate = firstQuery(ctx.query, "candidate_id");
+        if (candidate === void 0) throw validationError("query", "candidate_id", "missing", "Field required");
+        const userId = ctx.userId;
+        if (candidate === userId) throw new HttpError(400, "Cannot start a chat with yourself");
+        const chat = await svc().getOrCreateChat(userId, candidate);
+        return ok({
+          chat_id: chat.id,
+          user1_id: chat.user1_id,
+          user2_id: chat.user2_id,
+          created_at: iso(chat.created_at),
+          updated_at: iso(chat.updated_at)
+        });
+      }
+    }
+  ];
+  if (feature.devices && !("devices" in hub.features)) {
+    const devices = feature.devices;
+    routes.push(
+      { method: "POST", path: "/chats/expo/push/token", handler: async (ctx) => ok(await devices.register(ctx.userId, bodyObject(ctx))) },
+      { method: "POST", path: "/chats/expo/push/token/remove", handler: async (ctx) => ok(await devices.remove(ctx.userId, bodyObject(ctx))) }
+    );
+  }
+  routes.push(
+    {
+      // Same rules and events as WS send_message (policy, limits, push); returns the sender's MessageDto.
+      method: "POST",
+      path: "/chats/send",
+      async handler(ctx) {
+        const payload = bodyObject(ctx);
+        const recipient = payload.candidate_user_id;
+        const content = payload.content;
+        if (!recipient || !content) throw new HttpError(422, "Missing required fields: candidate_user_id, content");
+        try {
+          return ok(await feature.handlers.sendText(hub.db, ctx.userId, String(recipient), content, { replyToId: payload.reply_to_id }));
+        } catch (err) {
+          if (err instanceof ChatActionError) return actionError(err);
+          throw err;
+        }
+      }
+    },
+    {
+      // {chat_id?} or {candidate_user_id?} (chat_id wins)
+      method: "POST",
+      path: "/chats/read",
+      async handler(ctx) {
+        const payload = bodyObject(ctx);
+        const service = svc();
+        const chat = await feature.handlers.resolveChat(service, ctx.userId, payload.chat_id, payload.candidate_user_id);
+        if (!chat) throw new HttpError(404, "Chat not found");
+        await service.markMessagesAsRead(chat.id, ctx.userId);
+        await feature.handlers.notifyRead(chat.id, ctx.userId, otherOf(chat, ctx.userId));
+        return ok({ message: "Messages marked as read" });
+      }
+    },
+    {
+      method: "GET",
+      path: "/chats/:userId",
+      async handler(ctx) {
+        const userId = ctx.params.userId;
+        ensureSelf(userId, ctx.userId);
+        const convs = await svc().getConversations(userId);
+        const profiles = await hub.profiles(convs.map((c) => c.other_user_id));
+        return ok(
+          convs.map((conv) => {
+            const other = conv.other_user_id;
+            const profile = profiles[other];
+            return {
+              id: conv.chat_id,
+              other_user: { id: other, username: profile?.name ? profile.name : other, avatar: profile ? profile.avatar ?? null : null },
+              last_message: conv.last_message,
+              unread_count: conv.unread_count,
+              updated_at: conv.updated_at
+            };
+          })
+        );
+      }
+    },
+    {
+      method: "GET",
+      path: "/chats/:chatId/messages",
+      async handler(ctx) {
+        const chatId = intParam("path", "chatId", ctx.params.chatId);
+        const limit = intParam("query", "limit", firstQuery(ctx.query, "limit"), 50, 1, 100);
+        const offset = intParam("query", "offset", firstQuery(ctx.query, "offset"), 0, 0);
+        const userId = ctx.userId;
+        const service = svc();
+        if (!await service.getChatForUser(chatId, userId)) throw new HttpError(404, "Chat not found");
+        const rows = await service.getMessagesPage(chatId, limit, offset, userId);
+        const previews = await service.getReplyPreviews(rows.map((m) => m.reply_to_id));
+        return ok(rows.map((m) => messageDto(m, userId, m.reply_to_id ? previews.get(m.reply_to_id) : null)));
+      }
+    },
+    {
+      method: "POST",
+      path: "/chats/:chatId/read",
+      async handler(ctx) {
+        const chatId = intParam("path", "chatId", ctx.params.chatId);
+        const userId = ctx.userId;
+        const service = svc();
+        const chat = await service.getChatForUser(chatId, userId);
+        if (!chat) throw new HttpError(404, "Chat not found");
+        await service.markMessagesAsRead(chatId, userId);
+        await feature.handlers.notifyRead(chatId, userId, otherOf(chat, userId));
+        return ok({ message: "Messages marked as read" });
+      }
+    },
+    {
+      method: "GET",
+      path: "/chats/:userId/unread-count",
+      async handler(ctx) {
+        ensureSelf(ctx.params.userId, ctx.userId);
+        return ok({ unread_count: await svc().getUnreadCount(ctx.params.userId) });
+      }
+    },
+    {
+      method: "GET",
+      path: "/chats/:userId/online-status",
+      async handler(ctx) {
+        const userId = ctx.params.userId;
+        if (userId !== ctx.userId && !await svc().getChatBetween(ctx.userId, userId)) throw new HttpError(403, "Not allowed");
+        return ok({ user_id: userId, is_online: await hub.connections.isOnline(userId) });
+      }
+    }
+  );
+  return routes;
+}
+
+// src/chat/feature.ts
+var defaultChatConfig = () => ({
+  maxUploadBytes: 10 * 1024 * 1024,
+  defaultPageSize: 10,
+  maxPageSize: 100,
+  pushPreviewChars: 120,
+  pushChannel: "messages",
+  maxTextLength: 4e3,
+  messageRate: new RateLimit(20, 10),
+  uploadRate: new RateLimit(5, 60),
+  typingRate: new RateLimit(5, 5),
+  unsendWindowSeconds: 3600,
+  systemSenderId: null,
+  systemPushTitle: null
+});
+var ChatFeature = class {
+  name = "chat";
+  policy;
+  storage;
+  devices;
+  config;
+  handlers;
+  _hub = null;
+  constructor(opts = {}) {
+    this.policy = opts.policy ?? new AllowAllChatPolicy();
+    this.storage = opts.storage ?? new LocalDiskStorage();
+    this.devices = opts.devices;
+    this.config = { ...defaultChatConfig(), ...opts.config ?? {} };
+  }
+  get hub() {
+    if (!this._hub) throw new Error("ChatFeature is not installed; call hub.install(feature) first");
+    return this._hub;
+  }
+  install(hub) {
+    hub.registerFeature(this.name, this);
+    this._hub = hub;
+    this.handlers = new ChatHandlers(this);
+    this.handlers.register();
+    hub.onConnect((uid, ws) => this.handlers.onConnect(uid, ws));
+    hub.connections.setPartnersLookup((uid) => this.partnerIds(uid));
+    hub.includeRoutes(buildChatRoutes(this));
+    return this;
+  }
+  /** Conversation partners (receivers of this user's `user_status`). */
+  async partnerIds(userId) {
+    return this.handlers.service(this.hub.db).partnerIds(userId);
+  }
+  // ------------------------------------------------------- server-side API
+  /**
+   * Send a text message as `senderId` from trusted server code (bots, admin tools, tests). Same storage,
+   * events and push as WS `send_message`; no rate limit. The policy is only checked with `enforcePolicy`.
+   * Returns the MessageDto as the sender sees it; throws `ChatActionError` (self-message, too long, policy).
+   */
+  async sendMessageAs(senderId, toUserId, content, opts = {}) {
+    return this.handlers.sendText(this.hub.db, String(senderId), String(toUserId), content, {
+      replyToId: opts.replyToId,
+      checkPolicy: opts.enforcePolicy ?? false,
+      rateLimit: false
+    });
+  }
+  /**
+   * A `message_type: "system"` message shown to `toUserId` only (e.g. "You matched with Asha"). It goes into
+   * the chat between `toUserId` and `aboutUserId` (created if needed), stored with `sender_id = aboutUserId`
+   * and hidden for `aboutUserId`. Without `aboutUserId`, `config.systemSenderId` is the chat partner
+   * (throws if neither is set). `data` is added to the live frame (`message.data`) and to the push data; it is
+   * not stored. Returns the MessageDto as `toUserId` sees it.
+   */
+  async sendSystemMessage(toUserId, content, opts = {}) {
+    const to = String(toUserId);
+    const about = opts.aboutUserId;
+    const hasAbout = about !== null && about !== void 0 && about !== "";
+    const sender = hasAbout ? String(about) : this.config.systemSenderId;
+    if (!sender) throw new Error("sendSystemMessage needs aboutUserId (or ChatConfig.systemSenderId)");
+    if (sender === to) throw new Error("aboutUserId must differ from toUserId");
+    const text = String(content);
+    const hub = this.hub;
+    const service = new ChatService(hub.db, hub.dialect);
+    const chat = await service.getOrCreateChat(to, sender);
+    const row = await service.sendMessage(chat.id, sender, text, SYSTEM_TYPE);
+    if (hasAbout) await service.hideMessage(sender, row.id);
+    const dto = messageDto(row, to, null, { is_read: false, is_delivered: true });
+    if (opts.data && Object.keys(opts.data).length) dto.data = { ...opts.data };
+    const delivered = await hub.send(to, { type: "new_message", message: dto });
+    if (delivered) await service.markDelivered([row.id]);
+    if (opts.push ?? true) {
+      let title = this.config.systemPushTitle;
+      if (title === null) title = hasAbout ? await hub.displayName(sender, "Notification") : "Notification";
+      await this.handlers.notifyOffline(
+        to,
+        sender,
+        row.chat_id,
+        Array.from(text).slice(0, this.config.pushPreviewChars).join(""),
+        title,
+        { ...opts.data ?? {}, system: true }
+      );
+    }
+    dto.is_delivered = delivered;
+    await hub.events.emit("chat.system_message_sent", { ...dto });
+    return dto;
+  }
+  /**
+   * Account deletion: every chat `userId` is in, all its messages (the partner's view goes too: a 1:1 chat has
+   * one copy), hides / clears, and the stored media (through `MediaStorage.delete`). Returns counts.
+   */
+  async deleteUserData(userId) {
+    const uid = String(userId);
+    const [counts, urls] = await new ChatService(this.hub.db, this.hub.dialect).deleteUserData(uid);
+    const media = await deleteMedia(this.storage, ...urls);
+    this.handlers.forgetUser(uid);
+    return { ...counts, media };
+  }
+};
+
+// src/chat/models.ts
+function chatDdl(dialect) {
+  const t = ddlTypes(dialect);
+  return [
+    `CREATE TABLE IF NOT EXISTS chats (
+  id ${t.pk},
+  user1_id VARCHAR(50) NOT NULL,
+  user2_id VARCHAR(50) NOT NULL,
+  created_at ${t.tsDefaultNow},
+  updated_at ${t.ts},
+  CONSTRAINT check_user_order CHECK (user1_id < user2_id),
+  CONSTRAINT unique_chat_users UNIQUE (user1_id, user2_id)
+)`,
+    `CREATE TABLE IF NOT EXISTS messages (
+  id ${t.pk},
+  chat_id INTEGER NOT NULL REFERENCES chats (id) ON DELETE CASCADE,
+  sender_id VARCHAR(50) NOT NULL,
+  content TEXT,
+  message_type VARCHAR(20),
+  file_url VARCHAR(500),
+  file_name VARCHAR(255),
+  file_size ${t.big},
+  file_type VARCHAR(50),
+  thumbnail_url VARCHAR(500),
+  duration INTEGER,
+  is_read ${t.bool},
+  is_delivered ${t.bool},
+  is_call ${t.bool},
+  call_id VARCHAR(100),
+  reply_to_id INTEGER REFERENCES messages (id) ON DELETE SET NULL,
+  created_at ${t.tsDefaultNow},
+  updated_at ${t.ts},
+  UNIQUE (call_id)
+)`,
+    `CREATE TABLE IF NOT EXISTS comms_message_hidden (
+  id ${t.pk},
+  user_id VARCHAR(50) NOT NULL,
+  message_id INTEGER NOT NULL REFERENCES messages (id) ON DELETE CASCADE,
+  created_at ${t.tsDefaultNow},
+  CONSTRAINT uq_comms_message_hidden UNIQUE (user_id, message_id)
+)`,
+    `CREATE TABLE IF NOT EXISTS comms_chat_cleared (
+  id ${t.pk},
+  user_id VARCHAR(50) NOT NULL,
+  chat_id INTEGER NOT NULL REFERENCES chats (id) ON DELETE CASCADE,
+  cleared_at ${t.ts} NOT NULL,
+  up_to_message_id INTEGER NOT NULL,
+  CONSTRAINT uq_comms_chat_cleared UNIQUE (user_id, chat_id)
+)`,
+    "CREATE INDEX IF NOT EXISTS ix_chats_id ON chats (id)",
+    "CREATE INDEX IF NOT EXISTS ix_messages_id ON messages (id)",
+    "CREATE INDEX IF NOT EXISTS ix_comms_message_hidden_user_id ON comms_message_hidden (user_id)",
+    "CREATE INDEX IF NOT EXISTS ix_comms_message_hidden_message_id ON comms_message_hidden (message_id)",
+    "CREATE INDEX IF NOT EXISTS ix_comms_chat_cleared_user_id ON comms_chat_cleared (user_id)"
+  ];
+}
+
+export {
+  messageDto,
+  DELETED_TYPE,
+  SYSTEM_TYPE,
+  RESERVED_TYPES,
+  ChatActionError,
+  ChatService,
+  AllowAllChatPolicy,
+  defaultChatConfig,
+  ChatFeature,
+  chatDdl
+};
+//# sourceMappingURL=chunk-U4Z5INIW.js.map