@snakechat/commskit-node 0.0.0-stage → 0.1.1

package/dist/fastify.d.ts

@@ -0,0 +1,22 @@
+import { FastifyPluginAsync } from 'fastify';
+import { C as CommsHub } from './hub-CPrWmIvB.js';
+import 'node:http';
+import 'node:stream';
+import 'ws';
+import './adapters-8ztjEYtz.js';
+import './connections-CGEPiZPF.js';
+import 'kysely';
+
+/**
+ * Fastify adapter: `app.register(commskitPlugin, { hub })` registers the hub's REST routes and the
+ * `/ws/:token` upgrade on Fastify's http server. `fastify` is an optional peer dependency.
+ */
+
+interface CommskitFastifyOptions {
+    hub: CommsHub;
+    /** Close sockets when Fastify closes (default true). */
+    shutdownOnClose?: boolean;
+}
+declare const commskitPlugin: FastifyPluginAsync<CommskitFastifyOptions>;
+
+export { type CommskitFastifyOptions, commskitPlugin, commskitPlugin as default };

package/dist/fastify.js

@@ -0,0 +1,42 @@
+// src/fastify/index.ts
+var commskitPlugin = async (app, opts) => {
+  const { hub } = opts;
+  if (app.hasContentTypeParser("application/json")) app.removeContentTypeParser("application/json");
+  app.addContentTypeParser("application/json", { parseAs: "string", bodyLimit: 20 * 1024 * 1024 }, (_req, body, done) => {
+    const text = typeof body === "string" ? body : body.toString("utf8");
+    if (!text) return done(null, void 0);
+    try {
+      done(null, JSON.parse(text));
+    } catch (err) {
+      err.statusCode = 400;
+      done(err, void 0);
+    }
+  });
+  for (const route of hub.restRoutes()) {
+    app.route({
+      method: route.method,
+      url: route.path,
+      async handler(request, reply) {
+        const result = await route.handler({
+          method: request.method,
+          path: route.path,
+          params: request.params ?? {},
+          query: request.query ?? {},
+          headers: request.headers,
+          body: request.body ?? void 0,
+          userId: null
+        });
+        for (const [k, v] of Object.entries(result.headers ?? {})) void reply.header(k, v);
+        return reply.status(result.status).send(result.body);
+      }
+    });
+  }
+  hub.attach(app.server);
+  if (opts.shutdownOnClose !== false) app.addHook("onClose", async () => hub.shutdown());
+};
+var fastify_default = commskitPlugin;
+export {
+  commskitPlugin,
+  fastify_default as default
+};
+//# sourceMappingURL=fastify.js.map

package/dist/fastify.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/fastify/index.ts"],"sourcesContent":["/**\r\n * Fastify adapter: `app.register(commskitPlugin, { hub })` registers the hub's REST routes and the\r\n * `/ws/:token` upgrade on Fastify's http server. `fastify` is an optional peer dependency.\r\n */\r\nimport type { FastifyInstance, FastifyPluginAsync } from \"fastify\";\r\nimport type { CommsHub } from \"../core/hub.js\";\r\n\r\nexport interface CommskitFastifyOptions {\r\n  hub: CommsHub;\r\n  /** Close sockets when Fastify closes (default true). */\r\n  shutdownOnClose?: boolean;\r\n}\r\n\r\nexport const commskitPlugin: FastifyPluginAsync<CommskitFastifyOptions> = async (app: FastifyInstance, opts) => {\r\n  const { hub } = opts;\r\n  // Python/FastAPI accepts a JSON content-type with an empty body (e.g. POST /chats/start); so do we.\r\n  if (app.hasContentTypeParser(\"application/json\")) app.removeContentTypeParser(\"application/json\");\r\n  app.addContentTypeParser(\"application/json\", { parseAs: \"string\", bodyLimit: 20 * 1024 * 1024 }, (_req, body, done) => {\r\n    const text = typeof body === \"string\" ? body : body.toString(\"utf8\");\r\n    if (!text) return done(null, undefined);\r\n    try {\r\n      done(null, JSON.parse(text));\r\n    } catch (err) {\r\n      (err as { statusCode?: number }).statusCode = 400;\r\n      done(err as Error, undefined);\r\n    }\r\n  });\r\n  for (const route of hub.restRoutes()) {\r\n    app.route({\r\n      method: route.method,\r\n      url: route.path,\r\n      async handler(request, reply) {\r\n        const result = await route.handler({\r\n          method: request.method,\r\n          path: route.path,\r\n          params: (request.params ?? {}) as Record<string, string>,\r\n          query: (request.query ?? {}) as Record<string, string | string[] | undefined>,\r\n          headers: request.headers,\r\n          body: request.body ?? undefined,\r\n          userId: null,\r\n        });\r\n        for (const [k, v] of Object.entries(result.headers ?? {})) void reply.header(k, v);\r\n        return reply.status(result.status).send(result.body);\r\n      },\r\n    });\r\n  }\r\n  hub.attach(app.server);\r\n  if (opts.shutdownOnClose !== false) app.addHook(\"onClose\", async () => hub.shutdown());\r\n};\r\n\r\nexport default commskitPlugin;\r\n"],"mappings":";AAaO,IAAM,iBAA6D,OAAO,KAAsB,SAAS;AAC9G,QAAM,EAAE,IAAI,IAAI;AAEhB,MAAI,IAAI,qBAAqB,kBAAkB,EAAG,KAAI,wBAAwB,kBAAkB;AAChG,MAAI,qBAAqB,oBAAoB,EAAE,SAAS,UAAU,WAAW,KAAK,OAAO,KAAK,GAAG,CAAC,MAAM,MAAM,SAAS;AACrH,UAAM,OAAO,OAAO,SAAS,WAAW,OAAO,KAAK,SAAS,MAAM;AACnE,QAAI,CAAC,KAAM,QAAO,KAAK,MAAM,MAAS;AACtC,QAAI;AACF,WAAK,MAAM,KAAK,MAAM,IAAI,CAAC;AAAA,IAC7B,SAAS,KAAK;AACZ,MAAC,IAAgC,aAAa;AAC9C,WAAK,KAAc,MAAS;AAAA,IAC9B;AAAA,EACF,CAAC;AACD,aAAW,SAAS,IAAI,WAAW,GAAG;AACpC,QAAI,MAAM;AAAA,MACR,QAAQ,MAAM;AAAA,MACd,KAAK,MAAM;AAAA,MACX,MAAM,QAAQ,SAAS,OAAO;AAC5B,cAAM,SAAS,MAAM,MAAM,QAAQ;AAAA,UACjC,QAAQ,QAAQ;AAAA,UAChB,MAAM,MAAM;AAAA,UACZ,QAAS,QAAQ,UAAU,CAAC;AAAA,UAC5B,OAAQ,QAAQ,SAAS,CAAC;AAAA,UAC1B,SAAS,QAAQ;AAAA,UACjB,MAAM,QAAQ,QAAQ;AAAA,UACtB,QAAQ;AAAA,QACV,CAAC;AACD,mBAAW,CAAC,GAAG,CAAC,KAAK,OAAO,QAAQ,OAAO,WAAW,CAAC,CAAC,EAAG,MAAK,MAAM,OAAO,GAAG,CAAC;AACjF,eAAO,MAAM,OAAO,OAAO,MAAM,EAAE,KAAK,OAAO,IAAI;AAAA,MACrD;AAAA,IACF,CAAC;AAAA,EACH;AACA,MAAI,OAAO,IAAI,MAAM;AACrB,MAAI,KAAK,oBAAoB,MAAO,KAAI,QAAQ,WAAW,YAAY,IAAI,SAAS,CAAC;AACvF;AAEA,IAAO,kBAAQ;","names":[]}

package/dist/feature-B2bEXLZG.d.ts

@@ -0,0 +1,233 @@
+import { a as Dialect, D as Db, F as Feature, R as RestContext, C as CommsHub } from './hub-CPrWmIvB.js';
+
+/** ModerationService: block list and reports (port of commskit.moderation.service). Never runs a query inside another's transaction. */
+
+declare const REPORT_CATEGORIES: readonly ["spam", "harassment", "inappropriate", "fake_profile", "scam", "underage", "other"];
+declare const REPORT_STATUSES: readonly ["open", "resolved", "dismissed"];
+/** What `moderation.reported` listeners and `onReport` receive. */
+interface ReportInfo {
+    id: number;
+    reporter_id: string;
+    reported_id: string;
+    reason: string | null;
+    category: string | null;
+    message_id: number | null;
+    status: string;
+    created_at: Date;
+    /** The reporter also blocked the user. */
+    blocked: boolean;
+}
+/** Admin wire shape (PROTOCOL.md section 9). */
+interface ReportDict {
+    report_id: number;
+    reporter_id: string | null;
+    reported_id: string | null;
+    reason: string | null;
+    category: string | null;
+    message_id: number | null;
+    status: string;
+    created_at: string | null;
+    resolved_at: string | null;
+    resolved_by: string | null;
+    note: string | null;
+}
+declare function reportDict(r: any): ReportDict;
+declare class ModerationService {
+    private db;
+    readonly dialect: Dialect;
+    constructor(db: Db, dialect?: Dialect);
+    /** True if a new block was stored (blocking twice is a no-op). */
+    block(blockerId: string, blockedId: string): Promise<boolean>;
+    unblock(blockerId: string, blockedId: string): Promise<boolean>;
+    hasBlocked(blockerId: string, blockedId: string): Promise<boolean>;
+    /** Either direction. */
+    isBlockedBetween(userA: string, userB: string): Promise<boolean>;
+    /** `{otherId: [isBlocked, blockedByOther]}` for ids with any block. */
+    blockStatus(viewerId: string, otherIds: readonly string[]): Promise<Record<string, [boolean, boolean]>>;
+    /** `[blockedId, blockedAt]`, newest first. */
+    listBlocked(blockerId: string): Promise<Array<[string, unknown]>>;
+    createReport(reporterId: string, reportedId: string, opts?: {
+        reason?: string | null;
+        category?: string | null;
+        messageId?: number | null;
+    }): Promise<ReportInfo>;
+    getReport(reportId: number): Promise<ReportDict | null>;
+    /** Newest first; `status` filters (open | resolved | dismissed). */
+    listReports(status?: string | null, limit?: number, offset?: number): Promise<ReportDict[]>;
+    /** Set a report to resolved / dismissed (or back to open). Null if it doesn't exist; throws Error on a bad status. */
+    resolveReport(reportId: number, status: string, resolvedBy?: string | null, note?: string | null): Promise<ReportDict | null>;
+    /**
+     * Account deletion: drop every block involving `userId`; keep reports (moderation history) but replace the user's id
+     * with NULL as reporter and as reported user. Use a transaction handle (`trx`) for `db` to make it atomic.
+     */
+    deleteUserData(userId: string): Promise<{
+        blocks: number;
+        reports_anonymized: number;
+    }>;
+}
+
+/** Moderation WebSocket handlers and the shared block/report actions (also used by REST). Port of commskit.moderation.handlers. */
+
+declare const BLOCKED_TEXT = "User blocked successfully";
+declare const BLOCKED_BY_TEXT = "You have been blocked by this user";
+declare const UNBLOCKED_TEXT = "User unblocked successfully";
+declare const UNBLOCKED_BY_TEXT = "You have been unblocked by this user";
+declare const moderationError: (error: string, extra?: Record<string, unknown>) => Record<string, unknown>;
+/** Bad request (missing / self target ...). */
+declare class ModerationError extends Error {
+}
+declare function targetId(userId: string, value: unknown): string;
+/** Block / unblock / report + their frames and events. */
+declare class ModerationActions {
+    private feature;
+    constructor(feature: ModerationFeature);
+    private get hub();
+    block(db: Db, userId: string, target: string): Promise<boolean>;
+    unblock(db: Db, userId: string, target: string): Promise<boolean>;
+    report(db: Db, userId: string, target: string, opts?: {
+        reason?: unknown;
+        category?: unknown;
+        messageId?: unknown;
+        block?: boolean;
+    }): Promise<ReportInfo>;
+}
+declare class ModerationHandlers {
+    private feature;
+    constructor(feature: ModerationFeature);
+    private get hub();
+    register(): void;
+    private guard;
+    reportAndBlock(userId: string, message: Record<string, any>, db: Db): Promise<void>;
+    block(userId: string, message: Record<string, any>, db: Db): Promise<void>;
+    unblock(userId: string, message: Record<string, any>, db: Db): Promise<void>;
+}
+
+/**
+ * Chat / call policy wrappers that put the block list in front of the host's own policy (port of commskit.moderation.policy).
+ *
+ * They match the chat `ChatPolicy` and the call `CallPolicy` structurally, so this package never imports chat or call:
+ *
+ *   new ChatFeature({ policy: moderation.chatPolicy(myChatPolicy) })
+ *   new CallFeature({ policy: moderation.callPolicy(myCreditPolicy) })
+ *
+ * or let `linkModeration` (src/integration) wrap the installed features' policies. A blocked pair (either direction) is refused
+ * BEFORE the inner policy runs, so e.g. a credit-charging call policy never charges for a call that would be refused anyway.
+ */
+
+declare const CHAT_REFUSAL = "Cannot send message. User is blocked.";
+declare const CALL_REFUSAL = "Cannot call. User is blocked.";
+/** Same shape as the call feature's decision (`allowed`, `error`). */
+interface ModerationDecision {
+    allowed: boolean;
+    error?: Record<string, unknown> | null;
+}
+/** Structural view of a host chat policy. */
+interface ChatPolicyLike {
+    refusalMessage?: string;
+    canMessage(db: Db, senderId: string, recipientId: string): Promise<boolean>;
+    blockStatus(db: Db, viewerId: string, otherIds: readonly string[]): Promise<Record<string, [boolean, boolean]>>;
+    extraConversationInfo(db: Db, viewerId: string, otherId: string): Promise<Record<string, unknown>>;
+}
+/** Structural view of a host call policy. */
+interface CallPolicyLike {
+    authorize(db: Db, callerId: string, receiverId: string, message: Record<string, any>): Promise<any> | any;
+}
+declare class ModerationChatPolicy implements ChatPolicyLike {
+    inner: ChatPolicyLike | null;
+    blockedMessage: string;
+    /**
+     * The chat feature reads `refusalMessage` right after `canMessage` returned false; `lastRefusal` remembers whose refusal
+     * it was (the block list or the inner policy). Both messages are constant per policy, so concurrent frames cannot mix
+     * up different texts except when the host policy's message differs from the block text.
+     */
+    private lastRefusal;
+    constructor(inner?: ChatPolicyLike | null, blockedMessage?: string);
+    get refusalMessage(): string;
+    canMessage(db: Db, senderId: string, recipientId: string): Promise<boolean>;
+    /** Kit block list OR the inner policy's (e.g. a legacy host block table). */
+    blockStatus(db: Db, viewerId: string, otherIds: readonly string[]): Promise<Record<string, [boolean, boolean]>>;
+    extraConversationInfo(db: Db, viewerId: string, otherId: string): Promise<Record<string, unknown>>;
+}
+declare class ModerationCallPolicy implements CallPolicyLike {
+    inner: CallPolicyLike | null;
+    blockedMessage: string;
+    constructor(inner?: CallPolicyLike | null, blockedMessage?: string);
+    authorize(db: Db, callerId: string, receiverId: string, message: Record<string, any>): Promise<ModerationDecision>;
+}
+
+/** `hub.install(new ModerationFeature({...}))` (port of commskit.moderation.feature). Imports only core. */
+
+type ReportHook = (report: ReportInfo) => Promise<void> | void;
+/** `contextProvider(reporterId, reportedId, messageId, before, after)` -> MessageDto list (newest first). Set by linkModeration. */
+type ContextProvider = (reporterId: string | null, reportedId: string | null, messageId: number | null, before: number, after: number) => Promise<Array<Record<string, any>>>;
+/** Authenticates a moderator for the admin routes: return their id, or throw an `HttpError` (401 / 403). */
+type AdminDependency = (ctx: RestContext) => Promise<string | number | null | undefined> | string | number | null | undefined;
+interface ModerationFeatureOptions {
+    onReport?: ReportHook;
+    /** Send `blocked_by_user` / `unblocked_by_user` to the other user (default true, for compatibility). */
+    notifyBlockedUser?: boolean;
+    /** When set, mounts `/moderation/admin/reports...`. */
+    adminDependency?: AdminDependency;
+    contextProvider?: ContextProvider;
+}
+/**
+ * Block list + reports. Installs WS handlers `report_and_block` / `block` / `unblock` and `/moderation/...` REST routes.
+ * It does not touch chat or call by itself: wrap your policies (`chatPolicy(inner)` / `callPolicy(inner)`) or use
+ * `linkModeration(moderation, { chat, call })`, which also ends a live call between the pair on block.
+ *
+ * Events on `hub.events`: `moderation.blocked(blockerId, blockedId)`, `moderation.unblocked(blockerId, blockedId)`,
+ * `moderation.reported(ReportInfo)`, `moderation.report_resolved(report)`.
+ */
+declare class ModerationFeature implements Feature {
+    readonly name = "moderation";
+    onReport?: ReportHook;
+    notifyBlockedUser: boolean;
+    adminDependency?: AdminDependency;
+    contextProvider?: ContextProvider;
+    actions: ModerationActions;
+    handlers: ModerationHandlers;
+    /** Set by linkModeration. */
+    link: unknown;
+    private _hub;
+    constructor(opts?: ModerationFeatureOptions);
+    get hub(): CommsHub;
+    install(hub: CommsHub): this;
+    private service;
+    /** ChatPolicy: refuses a blocked pair, otherwise asks `inner` (allow-all if null). */
+    chatPolicy(inner?: ChatPolicyLike | null): ModerationChatPolicy;
+    /** CallPolicy: denies a blocked pair (`reason: "blocked"`), otherwise `inner`. */
+    callPolicy(inner?: CallPolicyLike | null): ModerationCallPolicy;
+    /** `{otherId: [isBlocked, blockedByOther]}` for `res_users` / `res_messages.info`. */
+    blockStatus(viewerId: string, otherIds: readonly string[], db?: Db): Promise<Record<string, [boolean, boolean]>>;
+    isBlockedBetween(userA: string, userB: string, db?: Db): Promise<boolean>;
+    listReports(status?: string | null, opts?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<ReportDict[]>;
+    /** `status`: resolved | dismissed (| open). Null if the report doesn't exist. */
+    resolveReport(reportId: number, status: string, opts?: {
+        resolvedBy?: string | null;
+        note?: string | null;
+    }): Promise<ReportDict | null>;
+    /**
+     * `{report, messages}`: messages around the reported message (or the latest between the pair), newest first, from
+     * `contextProvider` (empty without one, e.g. call-only apps).
+     */
+    reportContext(reportId: number, opts?: {
+        before?: number;
+        after?: number;
+    }): Promise<{
+        report: ReportDict;
+        messages: Array<Record<string, any>>;
+    } | null>;
+    /**
+     * Account deletion: blocks involving the user are deleted; reports are kept for the moderation history with the user's
+     * id set to NULL (as reporter and as reported user).
+     */
+    deleteUserData(userId: string): Promise<{
+        blocks: number;
+        reports_anonymized: number;
+    }>;
+}
+
+export { type AdminDependency as A, BLOCKED_BY_TEXT as B, CALL_REFUSAL as C, ModerationActions as M, REPORT_CATEGORIES as R, UNBLOCKED_BY_TEXT as U, BLOCKED_TEXT as a, CHAT_REFUSAL as b, type CallPolicyLike as c, type ChatPolicyLike as d, type ContextProvider as e, ModerationCallPolicy as f, ModerationChatPolicy as g, type ModerationDecision as h, ModerationError as i, ModerationFeature as j, type ModerationFeatureOptions as k, ModerationHandlers as l, ModerationService as m, REPORT_STATUSES as n, type ReportDict as o, type ReportHook as p, type ReportInfo as q, UNBLOCKED_TEXT as r, moderationError as s, reportDict as t, targetId as u };

package/dist/feature-DQUbnYE-.d.ts

@@ -0,0 +1,284 @@
+import { M as MediaInfo, b as MediaStorage, D as DeviceRegistry } from './adapters-8ztjEYtz.js';
+import { D as Db, a as Dialect, F as Feature, C as CommsHub } from './hub-CPrWmIvB.js';
+import { S as SocketLike, R as RateLimit } from './connections-CGEPiZPF.js';
+
+/** Plain copy of a `messages` row with normalised types (safe to use anywhere). */
+interface MessageRow {
+    id: number;
+    chat_id: number;
+    sender_id: string;
+    content: string | null;
+    message_type: string | null;
+    file_url: string | null;
+    file_name: string | null;
+    file_size: number | null;
+    file_type: string | null;
+    thumbnail_url: string | null;
+    duration: number | null;
+    is_read: boolean;
+    is_delivered: boolean;
+    call_id: string | null;
+    reply_to_id: number | null;
+    created_at: unknown;
+}
+interface ReplyPreview {
+    id: number;
+    sender_id: string;
+    content: string | null;
+    message_type: string | null;
+    file_name: string | null;
+}
+type MessageDto = Record<string, any>;
+/**
+ * `sender_type` is relative to `viewerId`: "user" = me, "other" = them; "system" for
+ * `message_type === "system"` (PROTOCOL.md section 9).
+ */
+declare function messageDto(m: MessageRow, viewerId: string, replyTo?: ReplyPreview | null | undefined, overrides?: Record<string, unknown>): MessageDto;
+
+/** ChatPolicy: host rules for who may message whom (blocking, consent...). */
+
+interface ChatPolicy {
+    /** Sent as `{"type":"error","error": refusalMessage}` when `canMessage` is false. */
+    refusalMessage: string;
+    /** False refuses send_message / media_upload and silently drops typing. */
+    canMessage(db: Db, senderId: string, recipientId: string): Promise<boolean>;
+    /** `{otherId: [isBlocked, blockedByOther]}`; missing ids = [false, false]. */
+    blockStatus(db: Db, viewerId: string, otherIds: readonly string[]): Promise<Record<string, [boolean, boolean]>>;
+    /** Merged into `res_messages.info` (e.g. `chat_consent_given`). */
+    extraConversationInfo(db: Db, viewerId: string, otherId: string): Promise<Record<string, unknown>>;
+}
+/** Default: everyone may message everyone, nobody is blocked. */
+declare class AllowAllChatPolicy implements ChatPolicy {
+    refusalMessage: string;
+    canMessage(): Promise<boolean>;
+    blockStatus(): Promise<Record<string, [boolean, boolean]>>;
+    extraConversationInfo(): Promise<Record<string, unknown>>;
+}
+
+/**
+ * ChatService: persistence for 1:1 chats (port of commskit.chat.service).
+ * Portable queries (PostgreSQL + SQLite); methods return plain rows (`ChatRow` / `MessageRow`).
+ */
+
+declare const DELETED_TYPE = "deleted";
+declare const SYSTEM_TYPE = "system";
+/** Message types only the server may create (a client sending one gets "text"). */
+declare const RESERVED_TYPES: ReadonlySet<string>;
+interface ChatRow {
+    id: number;
+    user1_id: string;
+    user2_id: string;
+    created_at: unknown;
+    updated_at: unknown;
+}
+interface LastMessageSummary {
+    content: string | null;
+    sender_id: string;
+    timestamp: string | null;
+    message_type: string | null;
+    file_url: string | null;
+    file_size: number | null;
+    file_type: string | null;
+    file_name: string | null;
+    is_read: boolean;
+    is_delivered: boolean;
+}
+interface Conversation {
+    chat_id: number;
+    other_user_id: string;
+    updated_at: string | null;
+    last_message: LastMessageSummary | null;
+    unread_count: number;
+}
+/**
+ * Refused chat action (PROTOCOL.md section 9). `code`: not_found | not_allowed | window_expired |
+ * rate_limited | too_long (`extra` carries `retry_after` / `max`), or undefined for policy refusals.
+ */
+declare class ChatActionError extends Error {
+    error: string;
+    code?: string | undefined;
+    status: number;
+    extra: Record<string, unknown>;
+    constructor(error: string, code?: string | undefined, status?: number, extra?: Record<string, unknown>);
+    frame(): Record<string, unknown>;
+}
+declare class ChatService {
+    private db;
+    readonly dialect: Dialect;
+    constructor(db: Db, dialect?: Dialect);
+    private ts;
+    getChatBetween(userA: string, userB: string): Promise<ChatRow | null>;
+    /** Idempotent per pair; survives a concurrent create (unique constraint). */
+    getOrCreateChat(userA: string, userB: string): Promise<ChatRow>;
+    /** Chat only if `userId` is a participant. */
+    getChatForUser(chatId: number, userId: string): Promise<ChatRow | null>;
+    partnerIds(userId: string): Promise<string[]>;
+    /** Chat summaries, newest first. "Last message per chat" via MAX(id) (ids grow with time). */
+    getConversations(userId: string): Promise<Conversation[]>;
+    /** Stores a message and bumps the chat's `updated_at` (one transaction). */
+    sendMessage(chatId: number, senderId: string, content: string | null, messageType?: string, opts?: {
+        media?: MediaInfo | null;
+        callId?: string | null;
+        replyToId?: unknown;
+    }): Promise<MessageRow>;
+    /** Only messages from the same chat can be quoted. */
+    private validReplyTarget;
+    getReplyPreviews(messageIds: Array<number | null | undefined>): Promise<Map<number, ReplyPreview>>;
+    /** Newest first. With `viewerId`, that user's hidden / cleared messages are left out. */
+    getMessagesPage(chatId: number, limit?: number, offset?: number, viewerId?: string | null): Promise<MessageRow[]>;
+    getLastMessage(chatId: number, viewerId?: string | null): Promise<MessageRow | null>;
+    getMessage(messageId: number): Promise<MessageRow | null>;
+    /** Read receipts are per chat: everything the other person sent becomes read + delivered. */
+    markMessagesAsRead(chatId: number, userId: string): Promise<void>;
+    markDelivered(messageIds: number[]): Promise<void>;
+    /** Mark everything sent to `userId` delivered; returns [chat_id, sender_id, message_id] (system messages excluded). */
+    markDeliveredForRecipient(userId: string): Promise<Array<[number, string, number]>>;
+    getUnreadCount(userId: string): Promise<number>;
+    /** Delete for me (idempotent). Does not check access; callers do. */
+    hideMessage(userId: string, messageId: number): Promise<void>;
+    /**
+     * 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.
+     */
+    unsendMessage(messageId: number, windowSeconds: number): Promise<[MessageRow, string[]]>;
+    /** Hide every message of the chat, up to now, for `userId` only. Returns `cleared_at`. */
+    clearChat(userId: string, chatId: number): Promise<Date>;
+    /**
+     * 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.
+     */
+    messagesAround(chatId: number, messageId: number | null, before?: number, after?: number): Promise<MessageRow[]>;
+    /**
+     * 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.
+     */
+    deleteUserData(userId: string): Promise<[{
+        chats: number;
+        messages: number;
+    }, string[]]>;
+    /** Set a call entry's text; returns its message id (null when none). Used by the call/chat link. */
+    rewriteCallMessage(callId: string, content: string): Promise<number | null>;
+}
+
+declare class ChatHandlers {
+    private feature;
+    private hub;
+    private pairChatIds;
+    constructor(feature: ChatFeature);
+    get config(): ChatConfig;
+    get policy(): ChatPolicy;
+    service(db: Db): ChatService;
+    register(): void;
+    forgetUser(userId: string): void;
+    private reply;
+    private failed;
+    /** Seconds to wait (0 = allowed). Takes a token when allowed. */
+    private rateLimited;
+    reqUsers(userId: string, message: Record<string, any>, db: Db): Promise<void>;
+    getMessages(userId: string, message: Record<string, any>, db: Db): Promise<void>;
+    /**
+     * Store + deliver a message (WS `send_message`, `POST /chats/send`, `sendMessageAs`).
+     * Returns the MessageDto as the sender sees it. Throws `ChatActionError` when refused.
+     */
+    sendText(db: Db, sender: string, recipient: string, content: unknown, opts?: {
+        messageType?: string;
+        replyToId?: unknown;
+        checkPolicy?: boolean;
+        rateLimit?: boolean;
+    }): Promise<MessageDto>;
+    sendMessage(userId: string, message: Record<string, any>, db: Db): Promise<void>;
+    /** new_message -> recipient, mark delivered, offline push, message_sent -> sender. */
+    private deliver;
+    /** Push when the recipient has no foreground socket anywhere. */
+    notifyOffline(recipient: string, sender: string, chatId: number, preview: string, title?: string | null, extra?: Record<string, unknown>): Promise<void>;
+    mediaUpload(userId: string, message: Record<string, any>, db: Db): Promise<void>;
+    /** `chat_id` wins; otherwise the chat with `candidate_user_id`. Null if not a participant. */
+    resolveChat(service: ChatService, userId: string, chatId: unknown, candidate: unknown): Promise<ChatRow | null>;
+    markRead(userId: string, message: Record<string, any>, db: Db): Promise<void>;
+    notifyRead(chatId: number, reader: string, other: string): Promise<void>;
+    typing(userId: string, message: Record<string, any>, db: Db): Promise<void>;
+    deleteMessage(userId: string, message: Record<string, any>, db: Db): Promise<void>;
+    /** Delete for me / unsend for everyone. Sends `message_deleted`; throws `ChatActionError`. */
+    deleteFor(db: Db, userId: string, messageId: number, forEveryone: boolean): Promise<Record<string, unknown>>;
+    clearChat(userId: string, message: Record<string, any>, db: Db): Promise<void>;
+    clearFor(db: Db, userId: string, chatId: unknown, candidate: unknown): Promise<Record<string, unknown>>;
+    /** Flush delivery receipts for messages that arrived while the user was offline. */
+    onConnect(userId: string, _ws: SocketLike): Promise<void>;
+}
+
+/** `hub.install(new ChatFeature({...}))` (port of commskit.chat.feature). */
+
+interface ChatConfig {
+    maxUploadBytes: number;
+    defaultPageSize: number;
+    maxPageSize: number;
+    pushPreviewChars: number;
+    /** Android channel created natively by the app. */
+    pushChannel: string;
+    /** PROTOCOL.md section 9 "Limits". null disables a limit; maxTextLength 0 = unlimited. */
+    maxTextLength: number;
+    messageRate: RateLimit | null;
+    uploadRate: RateLimit | null;
+    typingRate: RateLimit | null;
+    /** Unsend ("delete for everyone"): seconds after sending; 0 = no limit, -1 = disabled. */
+    unsendWindowSeconds: number;
+    /** System messages without aboutUserId go into a chat with this id (null: aboutUserId required). */
+    systemSenderId: string | null;
+    /** Push title for system messages (null: the about-user's name, else "Notification"). */
+    systemPushTitle: string | null;
+}
+declare const defaultChatConfig: () => ChatConfig;
+interface ChatFeatureOptions {
+    policy?: ChatPolicy;
+    storage?: MediaStorage;
+    /** Optional: enables the legacy push-token REST routes. */
+    devices?: DeviceRegistry;
+    config?: Partial<ChatConfig>;
+}
+/** 1:1 chat. */
+declare class ChatFeature implements Feature {
+    readonly name = "chat";
+    policy: ChatPolicy;
+    storage: MediaStorage;
+    devices?: DeviceRegistry;
+    config: ChatConfig;
+    handlers: ChatHandlers;
+    private _hub;
+    constructor(opts?: ChatFeatureOptions);
+    get hub(): CommsHub;
+    install(hub: CommsHub): this;
+    /** Conversation partners (receivers of this user's `user_status`). */
+    partnerIds(userId: string): Promise<string[]>;
+    /**
+     * 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).
+     */
+    sendMessageAs(senderId: string, toUserId: string, content: string, opts?: {
+        replyToId?: number | null;
+        enforcePolicy?: boolean;
+    }): Promise<MessageDto>;
+    /**
+     * 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.
+     */
+    sendSystemMessage(toUserId: string, content: string, opts?: {
+        aboutUserId?: string | null;
+        data?: Record<string, unknown> | null;
+        push?: boolean;
+    }): Promise<MessageDto>;
+    /**
+     * 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.
+     */
+    deleteUserData(userId: string): Promise<{
+        chats: number;
+        messages: number;
+        media: number;
+    }>;
+}
+
+export { AllowAllChatPolicy as A, ChatActionError as C, DELETED_TYPE as D, type MessageDto as M, RESERVED_TYPES as R, SYSTEM_TYPE as S, type ChatConfig as a, ChatFeature as b, type ChatFeatureOptions as c, type ChatPolicy as d, type ChatRow as e, ChatService as f, type MessageRow as g, type ReplyPreview as h, defaultChatConfig as i, messageDto as m };