@snakechat/commskit-node 0.0.0-stage → 0.1.1

package/dist/feature-DwKkuOBh.d.ts

@@ -0,0 +1,195 @@
+import { D as Db, a as Dialect, F as Feature, C as CommsHub } from './hub-CPrWmIvB.js';
+import { R as RateLimit, S as SocketLike } from './connections-CGEPiZPF.js';
+import { L as LRU } from './util-B32rIBVA.js';
+
+/** CallConfig: timings (seconds), push channels and TURN settings (port of commskit.call.config). */
+
+interface CallConfig {
+    ringTimeout: number;
+    ringingDisconnectGrace: number;
+    answeredDisconnectGrace: number;
+    maxCallHours: number;
+    ringWindowSlack: number;
+    ringtoneChannel: string;
+    missedChannel: string;
+    /** coturn REST-API credentials; the route answers 503 while turnSecret is unset. */
+    turnSecret: string | null;
+    turnUris: string[];
+    turnTtl: number;
+    /** call_initiate per caller (PROTOCOL.md section 9 "Limits"); null disables it. */
+    initiateRate: RateLimit | null;
+}
+declare const defaultCallConfig: () => CallConfig;
+
+declare const ACTIVE_CALL_STATUSES: readonly ["ringing", "answered"];
+declare class CallInfo {
+    callId: string;
+    chatId: number | null;
+    callerId: string;
+    receiverId: string;
+    isVideoCall: boolean;
+    status: string;
+    duration: number;
+    endReason: string | null;
+    /** Filled by a chat bridge during finalize: the call's chat entry. */
+    messageId: number | null;
+    logText: string | null;
+    constructor(callId: string, chatId: number | null, callerId: string, receiverId: string, isVideoCall: boolean, status: string, duration?: number, endReason?: string | null);
+    static fromRow(row: Record<string, any>): CallInfo;
+    get callType(): "video" | "audio";
+    otherParty(userId: string): string | null;
+    clone(patch?: Partial<CallInfo>): CallInfo;
+}
+/** "Voice call · 05:42", "Missed voice call", "Declined voice call" (caller-cancelled is logged as Missed). */
+declare function callLogText(status: string, isVideoCall: boolean, duration: number, _endReason?: string | null): string;
+declare class CallService {
+    private db;
+    private bridge;
+    private dialect;
+    config: CallConfig;
+    constructor(db: Db, config?: CallConfig, bridge?: CallChatBridge | null, dialect?: Dialect);
+    private ts;
+    createCall(chatId: number | null, callerId: string, receiverId: string, isVideoCall?: boolean): Promise<CallInfo>;
+    getCallById(callId: string): Promise<Record<string, any> | undefined>;
+    getCallInfo(callId: string): Promise<CallInfo | null>;
+    saveOfferSdp(callId: string, offerSdp: string): Promise<void>;
+    getOfferSdp(callId: string): Promise<string | null>;
+    private liveCallsQuery;
+    getActiveCallForUser(userId: string): Promise<CallInfo | null>;
+    getActiveCallsForUsers(userId: string): Promise<CallInfo[]>;
+    /** ringing -> answered. Only the receiver can answer, and only once. */
+    markAnswered(callId: string, receiverId: string): Promise<CallInfo | null>;
+    /** Move a live call to a terminal status. null if another path already did. */
+    finalizeCall(callId: string, status: string, endReason: string, onlyFrom?: readonly string[]): Promise<CallInfo | null>;
+}
+
+/** Hook points a chat integration plugs into (`CallFeature.chatBridge`). The call feature never imports chat. */
+
+interface CallChatBridge {
+    /** chat_id stored on the call (null = no chat). */
+    resolveChatId(db: Db, callerId: string, receiverId: string, requestedChatId: unknown): Promise<number | null>;
+    /** Call row committed; e.g. insert the "[Call Initiated]" chat entry. */
+    onCallCreated(db: Db, info: CallInfo): Promise<void>;
+    /**
+     * Inside the finalize transaction (`trx` is the transaction: never use another connection, never commit).
+     * May set `info.messageId` / `info.logText`; they are committed atomically with the terminal status.
+     */
+    onCallFinalizing(trx: Db, info: CallInfo): Promise<void>;
+}
+
+/** Call WebSocket handlers (PROTOCOL.md section 4). Port of commskit.call.handlers. */
+
+declare class CallHandlers {
+    private feature;
+    constructor(feature: CallFeature);
+    private get hub();
+    private get lifecycle();
+    register(): void;
+    /** Crash -> call-tagged error (label) or logged only (signalling relays). */
+    private guard;
+    private error;
+    callInitiate(userId: string, message: Record<string, any>, db: Db): Promise<void>;
+    answerCall(userId: string, message: Record<string, any>, db: Db): Promise<void>;
+    endCall(userId: string, message: Record<string, any>, db: Db): Promise<void>;
+    private relaySdp;
+    private iceCandidate;
+}
+
+/** Call lifecycle: finishing calls, ring timeout, disconnect grace, re-ring, pushes (port of commskit.call.lifecycle). */
+
+/** (terminal status, end_reason) for a hangup/reject by `fromUser`. */
+declare function endStatus(call: CallInfo, fromUser: string): [string, string];
+declare class CallLifecycle {
+    readonly feature: CallFeature;
+    /** callId -> [callerId, receiverId]: participants never change, so this per-worker cache keeps ICE off the DB. */
+    readonly parties: LRU<string, [string, string]>;
+    private timers;
+    private stopped;
+    constructor(feature: CallFeature);
+    private get hub();
+    private get config();
+    service(db: Db): CallService;
+    remember(info: CallInfo): void;
+    /** Emit `call.finalized` (the chat integration sends `call_log` from it). */
+    finalized(info: CallInfo): Promise<void>;
+    /** The call, only if `userId` is a participant. */
+    loadCallFor(db: Db, callId: string, userId: string): Promise<CallInfo | null>;
+    /** Hangup / reject / cancel by `fromUser`; outcome decided from call state. */
+    finishCall(db: Db, callIn: CallInfo, fromUser: string): Promise<void>;
+    /**
+     * 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.
+     */
+    endCallsBetween(userA: string, userB: string, endReason: string, endedBy?: string | null): Promise<CallInfo[]>;
+    rejectFromNotification(db: Db, callId: string, userId: string): Promise<boolean>;
+    private later;
+    /** Cancel every pending ring-timeout / disconnect-grace timer (hub shutdown). */
+    cancelAll(): void;
+    scheduleRingTimeout(callId: string): void;
+    /** Ring timeout: ringing -> missed (no_answer). */
+    expireUnanswered(callId: string): Promise<void>;
+    private endUserCalls;
+    /** Offline hook: after a grace period end calls the user is still in (answered ones get longer). */
+    endCallsAfterDisconnect(userId: string): void;
+    /** Re-ring a call still waiting for this user, on the new socket only, with the stored offer SDP. */
+    onConnect(userId: string, ws: SocketLike): Promise<void>;
+    incomingPayload(info: CallInfo): Promise<Record<string, any>>;
+    pushIncoming(info: CallInfo, callerName: string, callerAvatar: string | null): Promise<void>;
+    /** Receiver's app is not in the foreground: leave a missed-call notification (also stops a ringing one). */
+    pushMissedCall(info: CallInfo): Promise<void>;
+}
+
+/** CallPolicy: host gate for starting a call (blocking, credits...). */
+
+interface CallDecision {
+    allowed: boolean;
+    /** On deny, sent as {"type":"error", ...error, "context":"call"}; e.g. {error, status: 402, message, info}. */
+    error?: Record<string, unknown> | null;
+}
+declare const allow: () => CallDecision;
+declare const deny: (error: string, fields?: Record<string, unknown>) => CallDecision;
+interface CallPolicy {
+    /**
+     * Runs after busy detection, right before the call row is created. `message` is the raw `call_initiate`
+     * frame (host fields such as `credit_acknowledged` are available). Charging here is safe: busy receivers
+     * never reach this point.
+     */
+    authorize(db: Db, callerId: string, receiverId: string, message: Record<string, any>): Promise<CallDecision> | CallDecision;
+}
+declare class AllowAllCallPolicy implements CallPolicy {
+    authorize(): CallDecision;
+}
+
+/** `hub.install(new CallFeature({...}))` (port of commskit.call.feature). */
+
+interface CallFeatureOptions {
+    policy?: CallPolicy;
+    config?: Partial<CallConfig>;
+}
+/**
+ * P2P WebRTC call signalling. Works standalone (chat_id null, no call_log); `linkChatAndCall` (integration)
+ * sets `chatBridge`.
+ */
+declare class CallFeature implements Feature {
+    readonly name = "call";
+    policy: CallPolicy;
+    config: CallConfig;
+    chatBridge: CallChatBridge | null;
+    lifecycle: CallLifecycle;
+    handlers: CallHandlers;
+    private _hub;
+    constructor(opts?: CallFeatureOptions);
+    get hub(): CommsHub;
+    install(hub: CommsHub): this;
+    /** End every live call between two users (e.g. on block). Both get `call_ended`; `call.finalized` is emitted. */
+    endCallsBetween(userA: string, userB: string, endReason: string, endedBy?: string | null): Promise<CallInfo[]>;
+    /**
+     * 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.
+     */
+    deleteUserData(userId: string): Promise<{
+        calls: number;
+    }>;
+}
+
+export { ACTIVE_CALL_STATUSES as A, CallInfo as C, AllowAllCallPolicy as a, type CallChatBridge as b, type CallConfig as c, type CallDecision as d, CallFeature as e, type CallFeatureOptions as f, CallHandlers as g, CallLifecycle as h, type CallPolicy as i, CallService as j, allow as k, callLogText as l, defaultCallConfig as m, deny as n, endStatus as o };

package/dist/hub-CPrWmIvB.d.ts

@@ -0,0 +1,174 @@
+import { IncomingMessage, Server } from 'node:http';
+import { Duplex } from 'node:stream';
+import { WebSocketServer } from 'ws';
+import { A as AuthAdapter, d as UserDirectory, P as PushSender, e as UserProfile } from './adapters-8ztjEYtz.js';
+import { C as ConnectionManager, L as Limiter, S as SocketLike } from './connections-CGEPiZPF.js';
+import { Kysely } from 'kysely';
+
+/** Database helpers shared by all features (Kysely; sqlite for tests/demo, postgres for production). */
+
+type Dialect = "sqlite" | "postgres";
+/** The per-frame "session": the hub's Kysely instance (queries autocommit; use `db.transaction()`). */
+type Db = Kysely<any>;
+declare function detectDialect(db: Db): Dialect;
+/** A UTC timestamp value to write: "YYYY-MM-DD HH:MM:SS.ffffff" (sqlite, as SQLAlchemy stores it) or a Date (pg). */
+declare function dbTimestamp(dialect: Dialect, d?: Date): string | Date;
+/** Boolean column value: sqlite stores 0/1, postgres wants real booleans. */
+declare const dbBool: (dialect: Dialect, v: boolean) => boolean | number;
+/** Current time (the app clock; the Python kit reads the database clock). */
+declare const dbNow: () => Date;
+
+type Listener = (...args: any[]) => unknown | Promise<unknown>;
+declare class EventBus {
+    private listeners;
+    on(name: string, listener: Listener): Listener;
+    off(name: string, listener: Listener): void;
+    /** Run listeners in registration order; a failing listener is logged, not thrown. */
+    emit(name: string, ...args: unknown[]): Promise<void>;
+}
+
+interface Logger {
+    info(msg: string, ...args: unknown[]): void;
+    warn(msg: string, ...args: unknown[]): void;
+    error(msg: string, ...args: unknown[]): void;
+}
+declare const silentLogger: Logger;
+/** Replace the kit-wide logger (default: warnings and errors to the console). */
+declare function setLogger(logger: Logger): void;
+
+/** Framework-neutral REST routes (adapters: fastify, express, or the built-in node:http listener). */
+type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+interface RestContext {
+    method: string;
+    /** Route pattern with `:param` segments, e.g. `/chats/:chatId/messages`. */
+    path: string;
+    params: Record<string, string>;
+    query: Record<string, string | string[] | undefined>;
+    /** Lower-cased header names. */
+    headers: Record<string, string | string[] | undefined>;
+    /** Parsed JSON body (undefined when there is none). */
+    body: unknown;
+    /** Set by the hub for routes with `auth !== false` (Bearer token through the AuthAdapter). */
+    userId: string | null;
+}
+interface RestResult {
+    status: number;
+    headers?: Record<string, string>;
+    body: unknown;
+}
+interface RestRoute {
+    method: HttpMethod;
+    path: string;
+    /** Require `Authorization: Bearer <token>` (default true). */
+    auth?: boolean;
+    handler(ctx: RestContext): Promise<RestResult> | RestResult;
+}
+/** Thrown by handlers to answer with FastAPI's error shape `{"detail": ...}`. */
+declare class HttpError extends Error {
+    status: number;
+    detail: unknown;
+    headers?: Record<string, string> | undefined;
+    constructor(status: number, detail: unknown, headers?: Record<string, string> | undefined);
+}
+/** FastAPI-style 422 body for a bad parameter. */
+declare function validationError(where: "query" | "path" | "body", name: string, type: string, msg: string, input?: unknown): HttpError;
+declare const ok: (body: unknown, status?: number) => RestResult;
+declare function firstQuery(q: RestContext["query"], name: string): string | undefined;
+/** Match a request path against `:param` patterns. Returns the params or null. */
+declare function matchPath(pattern: string, actual: string): Record<string, string> | null;
+
+/** CommsHub: WS handler registry, lifecycle hooks, event bus, REST routes (port of commskit.core.hub). */
+
+/** Handler(userId, message, db). Errors propagate to the socket loop, which replies `Message processing failed: ...`. */
+type Handler = (userId: string, message: Record<string, any>, db: Db) => Promise<void> | void;
+type ConnectHook = (userId: string, ws: SocketLike) => Promise<void> | void;
+type DisconnectHook = (userId: string) => Promise<void> | void;
+/** roleResolver(userId) -> "user" | any other role (sync or async). Non-user roles get no presence, delivery flush or user hooks. */
+type RoleResolver = (userId: string) => string | Promise<string>;
+/** onHandlerError(userId, frame, err): frame is the parsed message, or the raw text for bad JSON. */
+type HandlerErrorHook = (userId: string, frame: unknown, err: unknown) => Promise<void> | void;
+/** A feature installs itself on a hub: registers handlers, routes, hooks and tables' services. */
+interface Feature {
+    readonly name: string;
+    install(hub: CommsHub): unknown;
+}
+interface CommsHubOptions {
+    auth: AuthAdapter;
+    /** Kysely instance (better-sqlite3 for tests/demo, pg for production). Create tables with `ensureSchema`. */
+    db: Db;
+    /** Override dialect detection. */
+    dialect?: Dialect;
+    users?: UserDirectory;
+    push?: PushSender;
+    connections?: ConnectionManager;
+    rateLimiter?: Limiter;
+    roleResolver?: RoleResolver;
+    onHandlerError?: HandlerErrorHook;
+    /** Seconds; at most one `user.came_online` per user per cooldown. */
+    cameOnlineCooldown?: number;
+    logger?: Logger;
+}
+declare class CommsHub {
+    readonly auth: AuthAdapter;
+    readonly db: Db;
+    readonly dialect: Dialect;
+    users: UserDirectory;
+    pushSender: PushSender;
+    connections: ConnectionManager;
+    rateLimiter: Limiter;
+    roleResolver?: RoleResolver;
+    onHandlerError?: HandlerErrorHook;
+    readonly events: EventBus;
+    readonly features: Record<string, unknown>;
+    private handlers;
+    private connectHooks;
+    private routes;
+    private tasks;
+    private ws;
+    constructor(opts: CommsHubOptions);
+    /** Install a feature (`hub.install(new ChatFeature({...}))`). Returns the feature. */
+    install<F extends Feature>(feature: F): F;
+    registerFeature(name: string, feature: unknown): void;
+    /** Register a WS handler for frames of `type`. Registering again replaces the previous handler. */
+    on(type: string, handler: Handler): Handler;
+    handles(type: string): boolean;
+    /** Run the handler for `message.type`. Unknown types are ignored (false). */
+    dispatch(userId: string, message: Record<string, any>): Promise<boolean>;
+    /** `hook(userId, ws)` after a socket is registered (runs before frames). Users only unless `allRoles`. */
+    onConnect(hook: ConnectHook, allRoles?: boolean): ConnectHook;
+    /** `hook(userId)` when the user's last socket on this worker closes (users only unless `allRoles`). */
+    onDisconnect(hook: DisconnectHook, allRoles?: boolean): DisconnectHook;
+    /** `roleResolver(userId)`; "user" without a resolver or when it fails. */
+    roleOf(userId: string): Promise<string>;
+    /** Call `onHandlerError`; never throws (hook failures are logged). */
+    reportHandlerError(userId: string, frame: unknown, err: unknown): Promise<void>;
+    joinRoom(userId: string, room: string): boolean;
+    leaveRoom(userId: string, room: string): void;
+    /** Send `frame` as given to every member (every worker, with a room-capable bridge). */
+    broadcastRoom(room: string, frame: unknown): Promise<number>;
+    /** Features call this from `install` to contribute routes. */
+    includeRoutes(routes: RestRoute[]): void;
+    /** `Authorization: Bearer <token>` -> user id (401 otherwise). */
+    authenticate(headers: RestContext["headers"]): Promise<string>;
+    /** All routes, ready for an adapter: auth is resolved and HttpError / crashes become `{status, body}`. */
+    restRoutes(): RestRoute[];
+    /** True when `url` is a `/ws/<token>` request. */
+    matchesWs(url: string | undefined): boolean;
+    /** Handle an HTTP upgrade for `/ws/:token` (accept first, then authenticate: 1008 on a bad token). */
+    handleUpgrade(req: IncomingMessage, socket: Duplex, head: Buffer): void;
+    /** Listen for `/ws/:token` upgrades on an http.Server (other upgrade paths are left to other listeners). */
+    attach(server: Server): void;
+    get wsServer(): WebSocketServer;
+    spawn(task: Promise<unknown> | (() => Promise<unknown>)): void;
+    /** Close sockets and wait briefly for background work. */
+    shutdown(): Promise<void>;
+    send(userId: string, payload: unknown): Promise<boolean>;
+    runConnectHooks(userId: string, ws: SocketLike, role?: string, cameOnline?: boolean): Promise<void>;
+    profiles(userIds: readonly string[]): Promise<Record<string, UserProfile>>;
+    profile(userId: string): Promise<UserProfile | undefined>;
+    displayName(userId: string, fallback?: string): Promise<string>;
+    /** Never throws: push failures are logged. */
+    push(userId: string, title: string, body: string, data: Record<string, unknown>, channel?: string, ttl?: number | null): Promise<void>;
+}
+
+export { CommsHub as C, type Db as D, EventBus as E, type Feature as F, type Handler as H, type Listener as L, type RestContext as R, type Dialect as a, type CommsHubOptions as b, type ConnectHook as c, type DisconnectHook as d, type HandlerErrorHook as e, HttpError as f, type HttpMethod as g, type Logger as h, type RestResult as i, type RestRoute as j, type RoleResolver as k, dbBool as l, dbNow as m, dbTimestamp as n, detectDialect as o, firstQuery as p, matchPath as q, ok as r, setLogger as s, silentLogger as t, validationError as v };

package/dist/index.d.ts

@@ -0,0 +1,33 @@
+export { A as AuthAdapter, a as AuthError, D as DeviceRegistry, J as JwtAuth, L as LocalDiskStorage, M as MediaInfo, b as MediaStorage, N as NoopPush, c as NullUserDirectory, P as PushSender, S as StaticUserDirectory, U as UploadRejected, d as UserDirectory, e as UserProfile, f as deleteMedia, r as resolveUserId } from './adapters-8ztjEYtz.js';
+export { MEDIA_TYPES, PONG_TYPE, detectMediaType, restListener } from './core.js';
+export { C as ConnectionManager, L as Limiter, P as PresenceBridge, R as RateLimit, a as RateLimiter, S as SocketLike, U as USER_ROLE, b as UserConnection, r as retryAfterSeconds } from './connections-CGEPiZPF.js';
+import { D as Db, a as Dialect } from './hub-CPrWmIvB.js';
+export { C as CommsHub, b as CommsHubOptions, c as ConnectHook, d as DisconnectHook, E as EventBus, F as Feature, H as Handler, e as HandlerErrorHook, f as HttpError, g as HttpMethod, L as Listener, h as Logger, R as RestContext, i as RestResult, j as RestRoute, k as RoleResolver, l as dbBool, m as dbNow, n as dbTimestamp, o as detectDialect, p as firstQuery, q as matchPath, r as ok, s as setLogger, t as silentLogger, v as validationError } from './hub-CPrWmIvB.js';
+import { D as DevicesTable } from './devices-oLIB_M19.js';
+export { d as devicesDdl } from './devices-oLIB_M19.js';
+export { f as formatIso, i as iso, n as nowIso, u as utcnow } from './util-B32rIBVA.js';
+export { A as AllowAllChatPolicy, C as ChatActionError, a as ChatConfig, b as ChatFeature, c as ChatFeatureOptions, d as ChatPolicy, e as ChatRow, f as ChatService, D as DELETED_TYPE, M as MessageDto, g as MessageRow, R as RESERVED_TYPES, h as ReplyPreview, S as SYSTEM_TYPE, i as defaultChatConfig, m as messageDto } from './feature-DQUbnYE-.js';
+import { ChatTables } from './chat.js';
+export { ChatClearedTable, ChatsTable, MessageHiddenTable, MessagesTable, chatDdl } from './chat.js';
+import { C as CallsTable } from './models-DTXEX1Q8.js';
+import { B as BlocksTable, R as ReportsTable } from './models-D1lehXIu.js';
+import 'node:http';
+import 'node:stream';
+import 'ws';
+import 'kysely';
+
+/** Kysely table map for every kit table. */
+interface KitDatabase extends ChatTables {
+    calls: CallsTable;
+    comms_devices: DevicesTable;
+    comms_blocks: BlocksTable;
+    comms_reports: ReportsTable;
+}
+/** Tables created by `ensureSchema`, in dependency order. */
+declare const KIT_TABLES: readonly ["chats", "messages", "calls", "comms_devices", "comms_blocks", "comms_reports", "comms_message_hidden", "comms_chat_cleared"];
+/** Create every kit table (idempotent; same names/columns/constraints as the Python SQLAlchemy models). */
+declare function ensureSchema(db: Db, opts?: {
+    dialect?: Dialect;
+}): Promise<void>;
+
+export { BlocksTable, CallsTable, ChatTables, Db, DevicesTable, Dialect, KIT_TABLES, type KitDatabase, ReportsTable, ensureSchema };

package/dist/index.js

@@ -0,0 +1,138 @@
+import {
+  CommsHub,
+  ConnectionManager,
+  EventBus,
+  PONG_TYPE,
+  USER_ROLE,
+  restListener
+} from "./chunk-LY2GJWN7.js";
+import {
+  AllowAllChatPolicy,
+  ChatActionError,
+  ChatFeature,
+  ChatService,
+  DELETED_TYPE,
+  RESERVED_TYPES,
+  SYSTEM_TYPE,
+  chatDdl,
+  defaultChatConfig,
+  messageDto
+} from "./chunk-U4Z5INIW.js";
+import {
+  AuthError,
+  JwtAuth,
+  LocalDiskStorage,
+  MEDIA_TYPES,
+  NoopPush,
+  NullUserDirectory,
+  StaticUserDirectory,
+  UploadRejected,
+  deleteMedia,
+  detectMediaType,
+  resolveUserId
+} from "./chunk-XQ6FLRX7.js";
+import {
+  callDdl
+} from "./chunk-XQFQN73U.js";
+import {
+  moderationDdl
+} from "./chunk-SEDRF62Q.js";
+import {
+  devicesDdl
+} from "./chunk-XOXZZYSW.js";
+import {
+  HttpError,
+  dbBool,
+  dbNow,
+  dbTimestamp,
+  detectDialect,
+  firstQuery,
+  matchPath,
+  ok,
+  validationError
+} from "./chunk-GR4PMGCS.js";
+import {
+  RateLimit,
+  RateLimiter,
+  retryAfterSeconds
+} from "./chunk-BBFVG7QU.js";
+import {
+  formatIso,
+  iso,
+  nowIso,
+  utcnow
+} from "./chunk-KLKRK6OG.js";
+import {
+  setLogger,
+  silentLogger
+} from "./chunk-5BJ2SNM5.js";
+
+// src/schema.ts
+import { sql } from "kysely";
+var KIT_TABLES = [
+  "chats",
+  "messages",
+  "calls",
+  "comms_devices",
+  "comms_blocks",
+  "comms_reports",
+  "comms_message_hidden",
+  "comms_chat_cleared"
+];
+async function ensureSchema(db, opts = {}) {
+  const dialect = opts.dialect ?? detectDialect(db);
+  for (const stmt of [...chatDdl(dialect), ...callDdl(dialect), ...devicesDdl(dialect), ...moderationDdl(dialect)]) {
+    await sql.raw(stmt).execute(db);
+  }
+}
+export {
+  AllowAllChatPolicy,
+  AuthError,
+  ChatActionError,
+  ChatFeature,
+  ChatService,
+  CommsHub,
+  ConnectionManager,
+  DELETED_TYPE,
+  EventBus,
+  HttpError,
+  JwtAuth,
+  KIT_TABLES,
+  LocalDiskStorage,
+  MEDIA_TYPES,
+  NoopPush,
+  NullUserDirectory,
+  PONG_TYPE,
+  RESERVED_TYPES,
+  RateLimit,
+  RateLimiter,
+  SYSTEM_TYPE,
+  StaticUserDirectory,
+  USER_ROLE,
+  UploadRejected,
+  chatDdl,
+  dbBool,
+  dbNow,
+  dbTimestamp,
+  defaultChatConfig,
+  deleteMedia,
+  detectDialect,
+  detectMediaType,
+  devicesDdl,
+  ensureSchema,
+  firstQuery,
+  formatIso,
+  iso,
+  matchPath,
+  messageDto,
+  nowIso,
+  ok,
+  resolveUserId,
+  restListener,
+  retryAfterSeconds,
+  setLogger,
+  silentLogger,
+  utcnow,
+  validationError
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/schema.ts"],"sourcesContent":["/** Aggregates every kit table (the only place besides `index.ts` allowed to import several features). */\nimport { sql } from \"kysely\";\nimport { callDdl } from \"./call/models.js\";\nimport type { CallsTable } from \"./call/models.js\";\nimport { chatDdl } from \"./chat/models.js\";\nimport type { ChatTables } from \"./chat/models.js\";\nimport { type Db, type Dialect, detectDialect } from \"./core/db.js\";\nimport { devicesDdl } from \"./core/devices.js\";\nimport type { DevicesTable } from \"./core/devices.js\";\nimport { moderationDdl } from \"./moderation/models.js\";\nimport type { BlocksTable, ReportsTable } from \"./moderation/models.js\";\n\n/** Kysely table map for every kit table. */\nexport interface KitDatabase extends ChatTables {\n  calls: CallsTable;\n  comms_devices: DevicesTable;\n  comms_blocks: BlocksTable;\n  comms_reports: ReportsTable;\n}\n\n/** Tables created by `ensureSchema`, in dependency order. */\nexport const KIT_TABLES = [\n  \"chats\", \"messages\", \"calls\", \"comms_devices\", \"comms_blocks\", \"comms_reports\",\n  \"comms_message_hidden\", \"comms_chat_cleared\",\n] as const;\n\n/** Create every kit table (idempotent; same names/columns/constraints as the Python SQLAlchemy models). */\nexport async function ensureSchema(db: Db, opts: { dialect?: Dialect } = {}): Promise<void> {\n  const dialect = opts.dialect ?? detectDialect(db);\n  for (const stmt of [...chatDdl(dialect), ...callDdl(dialect), ...devicesDdl(dialect), ...moderationDdl(dialect)]) {\n    await sql.raw(stmt).execute(db);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACA,SAAS,WAAW;AAoBb,IAAM,aAAa;AAAA,EACxB;AAAA,EAAS;AAAA,EAAY;AAAA,EAAS;AAAA,EAAiB;AAAA,EAAgB;AAAA,EAC/D;AAAA,EAAwB;AAC1B;AAGA,eAAsB,aAAa,IAAQ,OAA8B,CAAC,GAAkB;AAC1F,QAAM,UAAU,KAAK,WAAW,cAAc,EAAE;AAChD,aAAW,QAAQ,CAAC,GAAG,QAAQ,OAAO,GAAG,GAAG,QAAQ,OAAO,GAAG,GAAG,WAAW,OAAO,GAAG,GAAG,cAAc,OAAO,CAAC,GAAG;AAChH,UAAM,IAAI,IAAI,IAAI,EAAE,QAAQ,EAAE;AAAA,EAChC;AACF;","names":[]}

package/dist/integration.d.ts

@@ -0,0 +1,97 @@
+import { b as CallChatBridge, e as CallFeature, C as CallInfo } from './feature-DwKkuOBh.js';
+import { D as Db, C as CommsHub } from './hub-CPrWmIvB.js';
+import { b as ChatFeature } from './feature-DQUbnYE-.js';
+import { c as CallPolicyLike, d as ChatPolicyLike, j as ModerationFeature } from './feature-B2bEXLZG.js';
+import './connections-CGEPiZPF.js';
+import './util-B32rIBVA.js';
+import 'node:http';
+import 'node:stream';
+import 'ws';
+import './adapters-8ztjEYtz.js';
+import 'kysely';
+
+/** Chat + call wiring: calls live in the chat as call-log entries. The only file importing both features. */
+
+declare const CALL_PLACEHOLDER = "[Call Initiated]";
+/** Implements `CallChatBridge` on top of the chat tables. */
+declare class ChatCallBridge implements CallChatBridge {
+    readonly chat: ChatFeature;
+    readonly call: CallFeature;
+    constructor(chat: ChatFeature, call: CallFeature);
+    resolveChatId(db: Db, callerId: string, receiverId: string, _requestedChatId: unknown): Promise<number | null>;
+    onCallCreated(db: Db, info: CallInfo): Promise<void>;
+    onCallFinalizing(trx: Db, info: CallInfo): Promise<void>;
+    /** `call.finalized` listener: both parties' chat entry now reads e.g. "Voice call · 05:42". */
+    sendCallLog(info: CallInfo): Promise<void>;
+}
+/** Both features must already be installed on the same hub. */
+declare function linkChatAndCall(chat: ChatFeature, call: CallFeature): ChatCallBridge;
+
+/**
+ * Moderation wiring (port of commskit.integration.moderation): the block list in front of the chat / call policies, and
+ * live calls between a pair end when one blocks the other.
+ *
+ * `src/moderation` never imports chat or call; it emits `moderation.blocked` on the hub's event bus and exposes policy
+ * wrappers. This module connects the two sides. It only uses structural types for chat and call (so it compiles without the
+ * call module), and loads the chat module lazily, only when a chat feature is linked.
+ */
+
+declare const BLOCKED_END_REASON = "blocked";
+/** The slice of `ChatFeature` the link needs. */
+interface LinkableChat {
+    readonly hub: CommsHub;
+    policy: ChatPolicyLike;
+}
+/** The slice of `CallFeature` the link needs (`CallFeature.lifecycle.endCallsBetween`). */
+interface CallLifecycleLike {
+    endCallsBetween(userA: string, userB: string, reason: string, endedBy?: string | null): Promise<unknown>;
+}
+interface LinkableCall {
+    readonly hub: CommsHub;
+    policy: CallPolicyLike;
+    readonly lifecycle: CallLifecycleLike;
+}
+declare class ModerationLink {
+    readonly moderation: ModerationFeature;
+    readonly chat: LinkableChat | null;
+    readonly call: LinkableCall | null;
+    constructor(moderation: ModerationFeature, chat?: LinkableChat | null, call?: LinkableCall | null);
+    /** `moderation.blocked` listener. */
+    endCallsOnBlock(blockerId: string, blockedId: string): Promise<void>;
+    /**
+     * `ModerationFeature.contextProvider`: MessageDtos (as the reporter sees them, newest first) around `messageId` in the
+     * pair's chat, or the latest ones. Hides / clears are ignored.
+     */
+    reportMessages(reporterId: string | null, reportedId: string | null, messageId: number | null, before: number, after: number): Promise<Array<Record<string, any>>>;
+}
+/**
+ * Install-time wiring; all given features must be installed on the same hub.
+ * - `chat.policy` becomes `moderation.chatPolicy(<previous policy>)`: a blocked pair cannot send_message / media_upload
+ *   (error) or typing (dropped), and `res_users` / `res_messages.info` carry `is_blocked` / `blocked_by_other`.
+ * - `call.policy` becomes `moderation.callPolicy(<previous policy>)`: call_initiate to/from a blocked user is denied before
+ *   the host policy runs (no credits charged).
+ * - on block, live calls between the pair end with `end_reason: "blocked"`.
+ * - with chat: `moderation.contextProvider` (unless the host set one) reads the chat tables for the admin
+ *   `/moderation/admin/reports/:id/context` route.
+ * Policies already wrapped (e.g. `new ChatFeature({ policy: moderation.chatPolicy(...) })`) are not wrapped twice.
+ */
+declare function linkModeration(moderation: ModerationFeature, features?: {
+    chat?: LinkableChat | null;
+    call?: LinkableCall | null;
+}): ModerationLink;
+
+/**
+ * Account deletion across every installed feature (port of commskit.integration.privacy). Works through `hub.features` (any
+ * feature with an async `deleteUserData(userId)`), so it imports no feature package.
+ */
+
+/**
+ * Call `deleteUserData(userId)` on every installed feature (chat, call, moderation, devices, then any others), then emit
+ * `user.deleted(userId)`. Returns `{featureName: result}`. A failing feature is logged and reported as `{error}` (or
+ * re-thrown with `raiseErrors`); the others still run.
+ */
+declare function deleteUserEverywhere(hub: CommsHub, userId: string, opts?: {
+    raiseErrors?: boolean;
+}): Promise<Record<string, unknown>>;
+
+export { BLOCKED_END_REASON, CALL_PLACEHOLDER, type CallLifecycleLike, ChatCallBridge, type LinkableCall, type LinkableChat, ModerationLink, deleteUserEverywhere, linkChatAndCall, linkModeration };