@lastshotlabs/bunshot 0.0.25 → 0.0.28

package/dist/lib/upload.js

@@ -1,87 +0,0 @@
-import { HttpError } from "./HttpError";
-import { extname } from "node:path";
-let _adapter = null;
-let _config = {};
-export const setStorageAdapter = (adapter) => { _adapter = adapter; };
-export const getStorageAdapter = () => _adapter;
-export const setUploadConfig = (config) => { _config = config; };
-export const getUploadConfig = () => _config;
-export const generateUploadKey = (file, ctx, opts) => {
-    const merged = { ..._config, ...opts };
-    if (merged.generateKey)
-        return merged.generateKey(file, ctx);
-    const ext = extname(file.name);
-    const uuid = crypto.randomUUID();
-    const prefix = merged.keyPrefix ?? "uploads/";
-    const tenantPrefix = merged.tenantScopedKeys && ctx.tenantId ? `${ctx.tenantId}/` : "";
-    return `${prefix}${tenantPrefix}${uuid}${ext}`;
-};
-const mimeMatches = (mimeType, pattern) => {
-    if (pattern.endsWith("/*")) {
-        return mimeType.startsWith(pattern.slice(0, -1));
-    }
-    return mimeType === pattern;
-};
-export const validateFile = (file, opts) => {
-    const maxFileSize = opts.maxFileSize ?? _config.maxFileSize ?? 10 * 1024 * 1024;
-    if (file.size > maxFileSize) {
-        return `File "${file.name}" exceeds maximum size of ${maxFileSize} bytes`;
-    }
-    const allowedMimeTypes = opts.allowedMimeTypes ?? _config.allowedMimeTypes;
-    if (allowedMimeTypes && allowedMimeTypes.length > 0) {
-        const allowed = allowedMimeTypes.some((pattern) => mimeMatches(file.type, pattern));
-        if (!allowed) {
-            return `File "${file.name}" has disallowed MIME type "${file.type}"`;
-        }
-    }
-    return null;
-};
-export const processUpload = async (file, opts) => {
-    const adapter = _adapter;
-    if (!adapter)
-        throw new HttpError(500, "No storage adapter configured");
-    const validationError = validateFile(file, opts);
-    if (validationError)
-        throw new HttpError(400, validationError);
-    const key = generateUploadKey(file, opts.ctx ?? {}, opts);
-    const { url } = await adapter.put(key, file, {
-        mimeType: file.type,
-        size: file.size,
-        bucket: opts.bucket,
-    });
-    return {
-        key,
-        originalName: file.name,
-        mimeType: file.type,
-        size: file.size,
-        ...(url !== undefined ? { url } : {}),
-    };
-};
-export const parseUpload = async (c, opts) => {
-    const merged = { ..._config, ...opts };
-    const fields = merged.field
-        ? (Array.isArray(merged.field) ? merged.field : [merged.field])
-        : ["file"];
-    const maxFiles = merged.maxFiles ?? 10;
-    const body = await c.req.parseBody({ all: true });
-    const results = [];
-    const userId = c.get("authUserId") ?? undefined;
-    const tenantId = c.get("tenantId") ?? undefined;
-    const bucket = c.get("uploadBucket");
-    for (const field of fields) {
-        const raw = body[field];
-        if (!raw)
-            continue;
-        const files = Array.isArray(raw) ? raw : [raw];
-        for (const f of files) {
-            if (!(f instanceof File))
-                continue;
-            if (results.length >= maxFiles) {
-                throw new HttpError(400, `Too many files. Maximum is ${maxFiles}`);
-            }
-            const result = await processUpload(f, { ...merged, ctx: { userId, tenantId }, bucket: bucket ?? undefined });
-            results.push(result);
-        }
-    }
-    return results;
-};

package/dist/lib/ws.d.ts

@@ -1,22 +0,0 @@
-import type { Server, ServerWebSocket } from "bun";
-type WithRooms = {
-    rooms: Set<string>;
-};
-type WithSocketId = {
-    id: string;
-} & WithRooms;
-export declare const setWsServer: (server: Server<any>) => void;
-export declare const setPresenceEnabled: (enabled: boolean) => void;
-export declare const publish: (topic: string, data: unknown) => void;
-/** All rooms that currently have at least one subscriber */
-export declare const getRooms: () => string[];
-/** Socket IDs subscribed to a given room */
-export declare const getRoomSubscribers: (room: string) => string[];
-type RoomGuard<T extends WithRooms> = (ws: ServerWebSocket<T>, room: string) => boolean | Promise<boolean>;
-export declare const handleRoomActions: <T extends WithSocketId>(ws: ServerWebSocket<T>, message: string | Buffer, onSubscribe?: RoomGuard<T>) => Promise<boolean>;
-export declare const subscribe: <T extends WithSocketId>(ws: ServerWebSocket<T>, room: string) => void;
-export declare const unsubscribe: <T extends WithSocketId>(ws: ServerWebSocket<T>, room: string) => void;
-export declare const getSubscriptions: <T extends WithRooms>(ws: ServerWebSocket<T>) => string[];
-/** Called on socket close to prune the registry. Internal use only. */
-export declare const cleanupSocket: (socketId: string, rooms: Set<string>) => void;
-export {};

package/dist/lib/ws.js

@@ -1,89 +0,0 @@
-import { addPresence, removePresence, cleanupPresence } from "./wsPresence";
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-let _server = null;
-let _presenceEnabled = false;
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export const setWsServer = (server) => { _server = server; };
-export const setPresenceEnabled = (enabled) => { _presenceEnabled = enabled; };
-export const publish = (topic, data) => {
-    _server?.publish(topic, JSON.stringify(data));
-};
-/** room → Set of socket IDs */
-const _roomRegistry = new Map();
-/** All rooms that currently have at least one subscriber */
-export const getRooms = () => [..._roomRegistry.keys()];
-/** Socket IDs subscribed to a given room */
-export const getRoomSubscribers = (room) => [...(_roomRegistry.get(room) ?? [])];
-const MAX_ROOM_ACTION_SIZE = 4096; // 4 KB — room actions are small JSON payloads
-export const handleRoomActions = async (ws, message, onSubscribe) => {
-    try {
-        const raw = typeof message === "string" ? message : Buffer.from(message).toString();
-        if (raw.length > MAX_ROOM_ACTION_SIZE)
-            return false; // not a room action
-        const data = JSON.parse(raw);
-        if (data.action === "subscribe" && typeof data.room === "string") {
-            if (onSubscribe && !(await onSubscribe(ws, data.room))) {
-                ws.send(JSON.stringify({ event: "subscribe_denied", room: data.room }));
-            }
-            else {
-                subscribe(ws, data.room);
-                ws.send(JSON.stringify({ event: "subscribed", room: data.room }));
-            }
-            return true;
-        }
-        if (data.action === "unsubscribe" && typeof data.room === "string") {
-            unsubscribe(ws, data.room);
-            ws.send(JSON.stringify({ event: "unsubscribed", room: data.room }));
-            return true;
-        }
-    }
-    catch { /* not JSON */ }
-    return false;
-};
-export const subscribe = (ws, room) => {
-    ws.subscribe(room);
-    ws.data.rooms.add(room);
-    if (!_roomRegistry.has(room))
-        _roomRegistry.set(room, new Set());
-    _roomRegistry.get(room).add(ws.data.id);
-    if (_presenceEnabled) {
-        const result = addPresence(ws.data.id, room);
-        if (result?.isNewUser) {
-            publish(room, { event: "presence_join", room, userId: result.userId });
-        }
-    }
-};
-export const unsubscribe = (ws, room) => {
-    ws.unsubscribe(room);
-    ws.data.rooms.delete(room);
-    const ids = _roomRegistry.get(room);
-    if (ids) {
-        ids.delete(ws.data.id);
-        if (ids.size === 0)
-            _roomRegistry.delete(room);
-    }
-    if (_presenceEnabled) {
-        const result = removePresence(ws.data.id, room);
-        if (result?.isLastSocket) {
-            publish(room, { event: "presence_leave", room, userId: result.userId });
-        }
-    }
-};
-export const getSubscriptions = (ws) => [...ws.data.rooms];
-/** Called on socket close to prune the registry. Internal use only. */
-export const cleanupSocket = (socketId, rooms) => {
-    if (_presenceEnabled) {
-        const departed = cleanupPresence(socketId, rooms);
-        for (const { room, userId } of departed) {
-            publish(room, { event: "presence_leave", room, userId });
-        }
-    }
-    for (const room of rooms) {
-        const ids = _roomRegistry.get(room);
-        if (ids) {
-            ids.delete(socketId);
-            if (ids.size === 0)
-                _roomRegistry.delete(room);
-        }
-    }
-};

package/dist/lib/wsHeartbeat.d.ts

@@ -1,12 +0,0 @@
-import type { ServerWebSocket } from "bun";
-export interface HeartbeatConfig {
-    intervalMs?: number;
-    timeoutMs?: number;
-}
-export declare const registerSocket: (ws: ServerWebSocket<any>, id: string) => void;
-export declare const deregisterSocket: (id: string) => void;
-export declare const handlePong: (id: string) => void;
-export declare const startHeartbeat: (config?: HeartbeatConfig | boolean) => void;
-export declare const stopHeartbeat: () => void;
-/** Reset all heartbeat state. Useful for test isolation. */
-export declare const clearHeartbeatState: () => void;

package/dist/lib/wsHeartbeat.js

@@ -1,57 +0,0 @@
-// ---------------------------------------------------------------------------
-// State
-// ---------------------------------------------------------------------------
-/** All live sockets — socketId → ServerWebSocket */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-const _activeSockets = new Map();
-/** socketId → last pong timestamp (epoch ms) */
-const _lastPong = new Map();
-let _pingInterval = null;
-const DEFAULT_INTERVAL_MS = 30_000;
-const DEFAULT_TIMEOUT_MS = 10_000;
-// ---------------------------------------------------------------------------
-// Public API
-// ---------------------------------------------------------------------------
-export const registerSocket = (ws, id) => {
-    _activeSockets.set(id, ws);
-    _lastPong.set(id, Date.now());
-};
-export const deregisterSocket = (id) => {
-    _activeSockets.delete(id);
-    _lastPong.delete(id);
-};
-export const handlePong = (id) => {
-    _lastPong.set(id, Date.now());
-};
-export const startHeartbeat = (config) => {
-    if (_pingInterval)
-        return; // already running
-    const opts = typeof config === "object" ? config : {};
-    const intervalMs = opts.intervalMs ?? DEFAULT_INTERVAL_MS;
-    const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-    _pingInterval = setInterval(() => {
-        const now = Date.now();
-        for (const [id, ws] of _activeSockets) {
-            const lastPong = _lastPong.get(id) ?? 0;
-            if (now - lastPong > timeoutMs) {
-                ws.close(1001, "Heartbeat timeout");
-                // deregisterSocket will be called by the close handler
-            }
-            else {
-                ws.ping();
-            }
-        }
-    }, intervalMs);
-};
-export const stopHeartbeat = () => {
-    if (_pingInterval) {
-        clearInterval(_pingInterval);
-        _pingInterval = null;
-    }
-};
-/** Reset all heartbeat state. Useful for test isolation. */
-export const clearHeartbeatState = () => {
-    stopHeartbeat();
-    _activeSockets.clear();
-    _lastPong.clear();
-};

package/dist/lib/wsMessages.d.ts

@@ -1,40 +0,0 @@
-export interface StoredMessage {
-    id: string;
-    room: string;
-    senderId: string | null;
-    payload: unknown;
-    createdAt: number;
-}
-export type WsMessageStore = "redis" | "mongo" | "sqlite" | "memory";
-export interface WsMessageDefaults {
-    maxCount?: number;
-    ttlSeconds?: number;
-}
-export interface RoomPersistenceConfig {
-    persist: boolean;
-    maxCount?: number;
-    ttlSeconds?: number;
-}
-export declare const setWsMessageStore: (store: WsMessageStore) => void;
-export declare const setWsMessageDefaults: (defaults: WsMessageDefaults) => void;
-/** Opt a room into message persistence. */
-export declare const configureRoom: (room: string, options: RoomPersistenceConfig) => void;
-/**
- * Persist a message to a room. Returns null if room is not configured for persistence.
- * On store errors, logs a warning and returns null (non-blocking).
- */
-export declare const persistMessage: (room: string, data: {
-    senderId?: string | null;
-    payload: unknown;
-}) => Promise<StoredMessage | null>;
-/**
- * Get message history for a room.
- * Cursor-based pagination using message `id` as cursor.
- */
-export declare const getMessageHistory: (room: string, opts?: {
-    limit?: number;
-    before?: string;
-    after?: string;
-}) => Promise<StoredMessage[]>;
-/** Reset memory store. Useful for test isolation. */
-export declare const clearWsMessageMemoryStore: () => void;

package/dist/lib/wsMessages.js

@@ -1,330 +0,0 @@
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-// ---------------------------------------------------------------------------
-// State
-// ---------------------------------------------------------------------------
-const DEFAULT_MAX_COUNT = 100;
-const DEFAULT_TTL_SECONDS = 86_400; // 24 hours
-let _store = "memory";
-let _defaults = { maxCount: DEFAULT_MAX_COUNT, ttlSeconds: DEFAULT_TTL_SECONDS };
-const _roomConfigs = new Map();
-// Memory store
-const _memoryMessages = new Map();
-// SQLite trim counters — tracks inserts since last trim per room.
-// Resets on server restart; rooms may temporarily exceed maxCount by up to trimInterval rows.
-// This is a soft cap by design to avoid a DELETE on every INSERT under high throughput.
-const _sqliteTrimCounters = new Map();
-// ---------------------------------------------------------------------------
-// Configuration
-// ---------------------------------------------------------------------------
-export const setWsMessageStore = (store) => { _store = store; };
-export const setWsMessageDefaults = (defaults) => {
-    _defaults = {
-        maxCount: defaults.maxCount ?? DEFAULT_MAX_COUNT,
-        ttlSeconds: defaults.ttlSeconds ?? DEFAULT_TTL_SECONDS,
-    };
-};
-/** Opt a room into message persistence. */
-export const configureRoom = (room, options) => {
-    if (!options.persist) {
-        _roomConfigs.delete(room);
-        return;
-    }
-    _roomConfigs.set(room, {
-        maxCount: options.maxCount ?? _defaults.maxCount,
-        ttlSeconds: options.ttlSeconds ?? _defaults.ttlSeconds,
-    });
-};
-// ---------------------------------------------------------------------------
-// Public API
-// ---------------------------------------------------------------------------
-/**
- * Persist a message to a room. Returns null if room is not configured for persistence.
- * On store errors, logs a warning and returns null (non-blocking).
- */
-export const persistMessage = async (room, data) => {
-    const config = _roomConfigs.get(room);
-    if (!config)
-        return null;
-    const message = {
-        id: crypto.randomUUID(),
-        room,
-        senderId: data.senderId ?? null,
-        payload: data.payload,
-        createdAt: Date.now(),
-    };
-    try {
-        switch (_store) {
-            case "memory":
-                return memoryPersist(message, config);
-            case "redis":
-                return await redisPersist(message, config);
-            case "mongo":
-                return await mongoPersist(message, config);
-            case "sqlite":
-                return sqlitePersist(message, config);
-        }
-    }
-    catch (err) {
-        console.warn(`[wsMessages] failed to persist message to ${room}:`, err);
-        return null;
-    }
-};
-/**
- * Get message history for a room.
- * Cursor-based pagination using message `id` as cursor.
- */
-export const getMessageHistory = async (room, opts) => {
-    const limit = opts?.limit ?? 50;
-    switch (_store) {
-        case "memory":
-            return memoryGetHistory(room, limit, opts?.before, opts?.after);
-        case "redis":
-            return await redisGetHistory(room, limit, opts?.before, opts?.after);
-        case "mongo":
-            return await mongoGetHistory(room, limit, opts?.before, opts?.after);
-        case "sqlite":
-            return sqliteGetHistory(room, limit, opts?.before, opts?.after);
-    }
-};
-/** Reset memory store. Useful for test isolation. */
-export const clearWsMessageMemoryStore = () => {
-    _memoryMessages.clear();
-    _roomConfigs.clear();
-    _sqliteTrimCounters.clear();
-};
-// ---------------------------------------------------------------------------
-// Memory backend
-// ---------------------------------------------------------------------------
-function memoryPersist(msg, config) {
-    if (!_memoryMessages.has(msg.room))
-        _memoryMessages.set(msg.room, []);
-    const msgs = _memoryMessages.get(msg.room);
-    msgs.push(msg);
-    // Trim to maxCount
-    if (msgs.length > config.maxCount) {
-        msgs.splice(0, msgs.length - config.maxCount);
-    }
-    return msg;
-}
-function memoryGetHistory(room, limit, before, after) {
-    const msgs = _memoryMessages.get(room) ?? [];
-    const now = Date.now();
-    const config = _roomConfigs.get(room);
-    const ttlMs = (config?.ttlSeconds ?? _defaults.ttlSeconds) * 1000;
-    // Filter expired
-    let filtered = msgs.filter((m) => now - m.createdAt < ttlMs);
-    if (before) {
-        const cursorIdx = filtered.findIndex((m) => m.id === before);
-        if (cursorIdx > 0)
-            filtered = filtered.slice(0, cursorIdx);
-    }
-    else if (after) {
-        const cursorIdx = filtered.findIndex((m) => m.id === after);
-        if (cursorIdx >= 0)
-            filtered = filtered.slice(cursorIdx + 1);
-    }
-    // Return last N messages (most recent)
-    return filtered.slice(-limit);
-}
-// ---------------------------------------------------------------------------
-// Redis backend
-// ---------------------------------------------------------------------------
-async function redisPersist(msg, config) {
-    const { getRedis } = await import("./redis");
-    const redis = getRedis();
-    const key = `wsmsg:${msg.room}`;
-    const serialized = JSON.stringify(msg);
-    await redis.lpush(key, serialized);
-    await redis.ltrim(key, 0, config.maxCount - 1);
-    await redis.expire(key, config.ttlSeconds);
-    return msg;
-}
-async function redisGetHistory(room, limit, before, after) {
-    const { getRedis } = await import("./redis");
-    const redis = getRedis();
-    const key = `wsmsg:${room}`;
-    // Redis list is newest-first (LPUSH)
-    const raw = await redis.lrange(key, 0, -1);
-    let msgs = raw.map((s) => JSON.parse(s)).reverse(); // oldest-first
-    if (before) {
-        const idx = msgs.findIndex((m) => m.id === before);
-        if (idx > 0)
-            msgs = msgs.slice(0, idx);
-    }
-    else if (after) {
-        const idx = msgs.findIndex((m) => m.id === after);
-        if (idx >= 0)
-            msgs = msgs.slice(idx + 1);
-    }
-    return msgs.slice(-limit);
-}
-// ---------------------------------------------------------------------------
-// MongoDB backend
-// ---------------------------------------------------------------------------
-let _mongoModel = null;
-async function getWsMessageModel() {
-    if (_mongoModel)
-        return _mongoModel;
-    const { authConnection } = await import("./mongo");
-    const { default: mongoose } = await import("mongoose");
-    const schema = new mongoose.Schema({
-        _id: { type: String, default: () => crypto.randomUUID() },
-        room: { type: String, required: true, index: true },
-        senderId: { type: String, default: null },
-        payload: { type: mongoose.Schema.Types.Mixed },
-        createdAt: { type: Number, required: true, index: true },
-    }, { collection: "ws_messages" });
-    schema.index({ room: 1, createdAt: 1, _id: 1 });
-    // TTL index — Mongo's TTL monitor runs ~every 60s, so messages may briefly
-    // outlive their TTL. Acceptable for chat history.
-    schema.index({ createdAt: 1 }, { expireAfterSeconds: DEFAULT_TTL_SECONDS });
-    _mongoModel = authConnection.model("WsMessage", schema);
-    return _mongoModel;
-}
-async function mongoPersist(msg, config) {
-    const Model = await getWsMessageModel();
-    await Model.create({
-        _id: msg.id,
-        room: msg.room,
-        senderId: msg.senderId,
-        payload: msg.payload,
-        createdAt: msg.createdAt,
-    });
-    // Trim to maxCount
-    const count = await Model.countDocuments({ room: msg.room });
-    if (count > config.maxCount) {
-        const oldest = await Model.find({ room: msg.room })
-            .sort({ createdAt: 1, _id: 1 })
-            .limit(count - config.maxCount)
-            .select("_id");
-        if (oldest.length > 0) {
-            await Model.deleteMany({ _id: { $in: oldest.map((d) => d._id) } });
-        }
-    }
-    return msg;
-}
-async function mongoGetHistory(room, limit, before, after) {
-    const Model = await getWsMessageModel();
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const filter = { room };
-    if (before) {
-        const cursor = await Model.findById(before).lean();
-        if (cursor) {
-            filter.$or = [
-                { createdAt: { $lt: cursor.createdAt } },
-                { createdAt: cursor.createdAt, _id: { $lt: before } },
-            ];
-        }
-    }
-    else if (after) {
-        const cursor = await Model.findById(after).lean();
-        if (cursor) {
-            filter.$or = [
-                { createdAt: { $gt: cursor.createdAt } },
-                { createdAt: cursor.createdAt, _id: { $gt: after } },
-            ];
-        }
-    }
-    const docs = await Model.find(filter)
-        .sort({ createdAt: -1, _id: -1 })
-        .limit(limit)
-        .lean();
-    return docs.reverse().map((d) => ({
-        id: d._id,
-        room: d.room,
-        senderId: d.senderId,
-        payload: d.payload,
-        createdAt: d.createdAt,
-    }));
-}
-// ---------------------------------------------------------------------------
-// SQLite backend
-// ---------------------------------------------------------------------------
-function getSqliteDb() {
-    // Re-use the sqlite DB set via setSqliteDb
-    // eslint-disable-next-line @typescript-eslint/no-var-requires
-    const { getSqliteDatabase } = require("../adapters/sqliteAuth");
-    return getSqliteDatabase();
-}
-let _sqliteInitialized = false;
-function ensureSqliteTable() {
-    if (_sqliteInitialized)
-        return;
-    const db = getSqliteDb();
-    db.run(`
-    CREATE TABLE IF NOT EXISTS ws_messages (
-      id TEXT PRIMARY KEY,
-      room TEXT NOT NULL,
-      sender_id TEXT,
-      payload TEXT,
-      created_at INTEGER NOT NULL
-    )
-  `);
-    db.run(`CREATE INDEX IF NOT EXISTS idx_ws_messages_room_created ON ws_messages (room, created_at, id)`);
-    _sqliteInitialized = true;
-}
-function sqlitePersist(msg, config) {
-    ensureSqliteTable();
-    const db = getSqliteDb();
-    db.run(`INSERT INTO ws_messages (id, room, sender_id, payload, created_at) VALUES (?, ?, ?, ?, ?)`, [msg.id, msg.room, msg.senderId, JSON.stringify(msg.payload), msg.createdAt]);
-    // Modulo-based trimming to avoid DELETE on every INSERT.
-    const counter = (_sqliteTrimCounters.get(msg.room) ?? 0) + 1;
-    const trimInterval = Math.max(10, Math.floor(config.maxCount * 0.1));
-    _sqliteTrimCounters.set(msg.room, counter);
-    if (counter >= trimInterval) {
-        _sqliteTrimCounters.set(msg.room, 0);
-        // Delete oldest beyond maxCount
-        db.run(`DELETE FROM ws_messages WHERE room = ? AND id NOT IN (
-        SELECT id FROM ws_messages WHERE room = ? ORDER BY created_at DESC, id DESC LIMIT ?
-      )`, [msg.room, msg.room, config.maxCount]);
-        // TTL cleanup
-        const ttlMs = config.ttlSeconds * 1000;
-        db.run(`DELETE FROM ws_messages WHERE room = ? AND created_at < ?`, [msg.room, Date.now() - ttlMs]);
-    }
-    return msg;
-}
-function sqliteGetHistory(room, limit, before, after) {
-    ensureSqliteTable();
-    const db = getSqliteDb();
-    let sql;
-    let params;
-    if (before) {
-        sql = `
-      SELECT * FROM ws_messages
-      WHERE room = ? AND (created_at, id) < (
-        (SELECT created_at FROM ws_messages WHERE id = ?),
-        ?
-      )
-      ORDER BY created_at DESC, id DESC LIMIT ?
-    `;
-        params = [room, before, before, limit];
-    }
-    else if (after) {
-        sql = `
-      SELECT * FROM ws_messages
-      WHERE room = ? AND (created_at, id) > (
-        (SELECT created_at FROM ws_messages WHERE id = ?),
-        ?
-      )
-      ORDER BY created_at ASC, id ASC LIMIT ?
-    `;
-        params = [room, after, after, limit];
-    }
-    else {
-        sql = `SELECT * FROM ws_messages WHERE room = ? ORDER BY created_at DESC, id DESC LIMIT ?`;
-        params = [room, limit];
-    }
-    const rows = db.query(sql).all(...params);
-    // Normalize to oldest-first
-    if (!after)
-        rows.reverse();
-    return rows.map((r) => ({
-        id: r.id,
-        room: r.room,
-        senderId: r.sender_id,
-        payload: JSON.parse(r.payload),
-        createdAt: r.created_at,
-    }));
-}

package/dist/lib/wsPresence.d.ts

@@ -1,25 +0,0 @@
-/** Track an authenticated socket. Skips if userId is null/undefined. */
-export declare const trackSocket: (socketId: string, userId: string | null) => void;
-/** Untrack a socket on disconnect. */
-export declare const untrackSocket: (socketId: string) => void;
-/** Called when a socket subscribes to a room. Returns join info or null if unauthenticated. */
-export declare const addPresence: (socketId: string, room: string) => {
-    userId: string;
-    isNewUser: boolean;
-} | null;
-/** Called when a socket unsubscribes from a room. Returns leave info or null if unauthenticated. */
-export declare const removePresence: (socketId: string, room: string) => {
-    userId: string;
-    isLastSocket: boolean;
-} | null;
-/** Called on disconnect — cleans up all rooms for a socket. Returns rooms where user fully departed. */
-export declare const cleanupPresence: (socketId: string, rooms: Set<string>) => Array<{
-    room: string;
-    userId: string;
-}>;
-/** Deduplicated userIds present in a room. */
-export declare const getRoomPresence: (room: string) => string[];
-/** Rooms where a user is present. */
-export declare const getUserPresence: (userId: string) => string[];
-/** Reset all presence state. Useful for test isolation. */
-export declare const clearPresenceStore: () => void;