@terreno/api 0.14.0 → 0.14.2

package/dist/realtime/realtime.test.js

@@ -125,12 +125,24 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     }
     return to.concat(ar || Array.prototype.slice.call(from));
 };
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 var bun_test_1 = require("bun:test");
 var express_1 = __importDefault(require("express"));
+var mongoose_1 = __importDefault(require("mongoose"));
 var changeStreamWatcher_1 = require("./changeStreamWatcher");
 var queryMatcher_1 = require("./queryMatcher");
 var queryStore_1 = require("./queryStore");
@@ -2140,6 +2152,1779 @@ var createMockSocket = function (decodedToken) {
 // ─────────────────────────────────────────────────────────────────────────────
 // redactCredentials — Redis URL logging
 // ─────────────────────────────────────────────────────────────────────────────
+// ─────────────────────────────────────────────────────────────────────────────
+// startChangeStreamWatcher / stopChangeStreamWatcher — MongoDB change stream
+// ─────────────────────────────────────────────────────────────────────────────
+(0, bun_test_1.describe)("startChangeStreamWatcher", function () {
+    var originalDb;
+    (0, bun_test_1.beforeEach)(function () {
+        originalDb = mongoose_1.default.connection.db;
+        (0, registry_1.clearRealtimeRegistry)();
+    });
+    (0, bun_test_1.afterEach)(function () { return __awaiter(void 0, void 0, void 0, function () {
+        var stop;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    mongoose_1.default.connection.db = originalDb;
+                    (0, registry_1.clearRealtimeRegistry)();
+                    return [4 /*yield*/, Promise.resolve().then(function () { return __importStar(require("./changeStreamWatcher")); })];
+                case 1:
+                    stop = (_a.sent()).stopChangeStreamWatcher;
+                    return [4 /*yield*/, stop()];
+                case 2:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    var createMockChangeStream = function () {
+        var listeners = new Map();
+        return {
+            close: (0, bun_test_1.mock)(function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                return [2 /*return*/];
+            }); }); }),
+            listeners: listeners,
+            on: function (event, handler) {
+                listeners.set(event, handler);
+                return this;
+            },
+            trigger: function (event) {
+                var args = [];
+                for (var _i = 1; _i < arguments.length; _i++) {
+                    args[_i - 1] = arguments[_i];
+                }
+                var handler = listeners.get(event);
+                if (handler) {
+                    handler.apply(void 0, __spreadArray([], __read(args), false));
+                }
+            },
+        };
+    };
+    var createMockIo = function () {
+        var rooms = new Map();
+        var sockets = new Map();
+        return {
+            sockets: {
+                adapter: { rooms: rooms },
+                sockets: sockets,
+            },
+            to: function (_room) { return ({
+                emit: function (_event, _data) { },
+            }); },
+        };
+    };
+    (0, bun_test_1.it)("initializes and registers change/error/close/end listeners", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var mockStream, mockDb, startChangeStreamWatcher, io;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    mockStream = createMockChangeStream();
+                    mockDb = {
+                        watch: (0, bun_test_1.mock)(function () { return mockStream; }),
+                    };
+                    mongoose_1.default.connection.db = mockDb;
+                    return [4 /*yield*/, Promise.resolve().then(function () { return __importStar(require("./changeStreamWatcher")); })];
+                case 1:
+                    startChangeStreamWatcher = (_a.sent()).startChangeStreamWatcher;
+                    io = createMockIo();
+                    startChangeStreamWatcher(io, {}, true);
+                    (0, bun_test_1.expect)(mockDb.watch).toHaveBeenCalled();
+                    (0, bun_test_1.expect)(mockStream.listeners.has("change")).toBe(true);
+                    (0, bun_test_1.expect)(mockStream.listeners.has("error")).toBe(true);
+                    (0, bun_test_1.expect)(mockStream.listeners.has("close")).toBe(true);
+                    (0, bun_test_1.expect)(mockStream.listeners.has("end")).toBe(true);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("throws when mongoose connection db is unavailable", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var startChangeStreamWatcher, io;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    mongoose_1.default.connection.db = undefined;
+                    return [4 /*yield*/, Promise.resolve().then(function () { return __importStar(require("./changeStreamWatcher")); })];
+                case 1:
+                    startChangeStreamWatcher = (_a.sent()).startChangeStreamWatcher;
+                    io = createMockIo();
+                    (0, bun_test_1.expect)(function () { return startChangeStreamWatcher(io); }).toThrow("MongoDB connection not available for change stream");
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("throws when watch returns null", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var mockDb, startChangeStreamWatcher, io;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    mockDb = {
+                        watch: (0, bun_test_1.mock)(function () { return null; }),
+                    };
+                    mongoose_1.default.connection.db = mockDb;
+                    return [4 /*yield*/, Promise.resolve().then(function () { return __importStar(require("./changeStreamWatcher")); })];
+                case 1:
+                    startChangeStreamWatcher = (_a.sent()).startChangeStreamWatcher;
+                    io = createMockIo();
+                    (0, bun_test_1.expect)(function () { return startChangeStreamWatcher(io); }).toThrow("Failed to create change stream watcher");
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("handles change events for registered models", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var mockStream, mockDb, startChangeStreamWatcher, io, changeHandler;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    mockStream = createMockChangeStream();
+                    mockDb = {
+                        watch: (0, bun_test_1.mock)(function () { return mockStream; }),
+                    };
+                    mongoose_1.default.connection.db = mockDb;
+                    (0, registry_1.registerRealtime)({
+                        collectionName: "todos",
+                        config: {
+                            methods: ["create", "update", "delete"],
+                            roomStrategy: "model",
+                        },
+                        modelName: "Todo",
+                        options: {
+                            permissions: {
+                                create: [function () { return true; }],
+                                delete: [function () { return true; }],
+                                list: [function () { return true; }],
+                                read: [function () { return true; }],
+                                update: [function () { return true; }],
+                            },
+                        },
+                        routePath: "/todos",
+                    });
+                    return [4 /*yield*/, Promise.resolve().then(function () { return __importStar(require("./changeStreamWatcher")); })];
+                case 1:
+                    startChangeStreamWatcher = (_a.sent()).startChangeStreamWatcher;
+                    io = createMockIo();
+                    startChangeStreamWatcher(io, {}, true);
+                    changeHandler = mockStream.listeners.get("change");
+                    (0, bun_test_1.expect)(changeHandler).toBeDefined();
+                    return [4 /*yield*/, changeHandler({
+                            documentKey: { _id: "doc-1" },
+                            fullDocument: { _id: "doc-1", name: "Test Todo" },
+                            ns: { coll: "todos" },
+                            operationType: "insert",
+                        })];
+                case 2:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("skips events for unregistered collections", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var mockStream, mockDb, startChangeStreamWatcher, io, changeHandler;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    mockStream = createMockChangeStream();
+                    mockDb = {
+                        watch: (0, bun_test_1.mock)(function () { return mockStream; }),
+                    };
+                    mongoose_1.default.connection.db = mockDb;
+                    return [4 /*yield*/, Promise.resolve().then(function () { return __importStar(require("./changeStreamWatcher")); })];
+                case 1:
+                    startChangeStreamWatcher = (_a.sent()).startChangeStreamWatcher;
+                    io = createMockIo();
+                    startChangeStreamWatcher(io, {}, true);
+                    changeHandler = mockStream.listeners.get("change");
+                    // Trigger for an unregistered collection — should not throw
+                    return [4 /*yield*/, changeHandler({
+                            documentKey: { _id: "doc-1" },
+                            fullDocument: { _id: "doc-1" },
+                            ns: { coll: "unknown_collection" },
+                            operationType: "insert",
+                        })];
+                case 2:
+                    // Trigger for an unregistered collection — should not throw
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("skips events when method is not enabled for the model", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var mockStream, mockDb, startChangeStreamWatcher, io, changeHandler;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    mockStream = createMockChangeStream();
+                    mockDb = {
+                        watch: (0, bun_test_1.mock)(function () { return mockStream; }),
+                    };
+                    mongoose_1.default.connection.db = mockDb;
+                    (0, registry_1.registerRealtime)({
+                        collectionName: "todos",
+                        config: {
+                            methods: ["create"], // only create enabled
+                            roomStrategy: "model",
+                        },
+                        modelName: "Todo",
+                        options: {
+                            permissions: {
+                                create: [function () { return true; }],
+                                delete: [],
+                                list: [function () { return true; }],
+                                read: [function () { return true; }],
+                                update: [],
+                            },
+                        },
+                        routePath: "/todos",
+                    });
+                    return [4 /*yield*/, Promise.resolve().then(function () { return __importStar(require("./changeStreamWatcher")); })];
+                case 1:
+                    startChangeStreamWatcher = (_a.sent()).startChangeStreamWatcher;
+                    io = createMockIo();
+                    startChangeStreamWatcher(io, {}, true);
+                    changeHandler = mockStream.listeners.get("change");
+                    // Update event should be skipped because "update" not in methods
+                    return [4 /*yield*/, changeHandler({
+                            documentKey: { _id: "doc-1" },
+                            fullDocument: { _id: "doc-1", name: "Updated" },
+                            ns: { coll: "todos" },
+                            operationType: "update",
+                            updateDescription: { updatedFields: { name: "Updated" } },
+                        })];
+                case 2:
+                    // Update event should be skipped because "update" not in methods
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("handles delete events for owner-strategy models", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var mockStream, mockDb, startChangeStreamWatcher, io, changeHandler;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    mockStream = createMockChangeStream();
+                    mockDb = {
+                        watch: (0, bun_test_1.mock)(function () { return mockStream; }),
+                    };
+                    mongoose_1.default.connection.db = mockDb;
+                    (0, registry_1.registerRealtime)({
+                        collectionName: "todos",
+                        config: {
+                            methods: ["create", "update", "delete"],
+                            roomStrategy: "owner",
+                        },
+                        modelName: "Todo",
+                        options: {
+                            permissions: {
+                                create: [function () { return true; }],
+                                delete: [function () { return true; }],
+                                list: [function () { return true; }],
+                                read: [function () { return true; }],
+                                update: [function () { return true; }],
+                            },
+                        },
+                        routePath: "/todos",
+                    });
+                    return [4 /*yield*/, Promise.resolve().then(function () { return __importStar(require("./changeStreamWatcher")); })];
+                case 1:
+                    startChangeStreamWatcher = (_a.sent()).startChangeStreamWatcher;
+                    io = createMockIo();
+                    startChangeStreamWatcher(io, {}, true);
+                    changeHandler = mockStream.listeners.get("change");
+                    // Hard delete (no fullDocument)
+                    return [4 /*yield*/, changeHandler({
+                            documentKey: { _id: "doc-1" },
+                            ns: { coll: "todos" },
+                            operationType: "delete",
+                        })];
+                case 2:
+                    // Hard delete (no fullDocument)
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("handles delete events for broadcast-strategy models", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var mockStream, mockDb, startChangeStreamWatcher, io, changeHandler;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    mockStream = createMockChangeStream();
+                    mockDb = {
+                        watch: (0, bun_test_1.mock)(function () { return mockStream; }),
+                    };
+                    mongoose_1.default.connection.db = mockDb;
+                    (0, registry_1.registerRealtime)({
+                        collectionName: "broadcasts",
+                        config: {
+                            methods: ["create", "update", "delete"],
+                            roomStrategy: "broadcast",
+                        },
+                        modelName: "Broadcast",
+                        options: {
+                            permissions: {
+                                create: [function () { return true; }],
+                                delete: [function () { return true; }],
+                                list: [function () { return true; }],
+                                read: [function () { return true; }],
+                                update: [function () { return true; }],
+                            },
+                        },
+                        routePath: "/broadcasts",
+                    });
+                    return [4 /*yield*/, Promise.resolve().then(function () { return __importStar(require("./changeStreamWatcher")); })];
+                case 1:
+                    startChangeStreamWatcher = (_a.sent()).startChangeStreamWatcher;
+                    io = createMockIo();
+                    startChangeStreamWatcher(io, {}, true);
+                    changeHandler = mockStream.listeners.get("change");
+                    // Hard delete for broadcast strategy
+                    return [4 /*yield*/, changeHandler({
+                            documentKey: { _id: "doc-1" },
+                            ns: { coll: "broadcasts" },
+                            operationType: "delete",
+                        })];
+                case 2:
+                    // Hard delete for broadcast strategy
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("includes updatedFields in event for update operations", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var mockStream, mockDb, startChangeStreamWatcher, io, changeHandler;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    mockStream = createMockChangeStream();
+                    mockDb = {
+                        watch: (0, bun_test_1.mock)(function () { return mockStream; }),
+                    };
+                    mongoose_1.default.connection.db = mockDb;
+                    (0, registry_1.registerRealtime)({
+                        collectionName: "todos",
+                        config: {
+                            methods: ["create", "update", "delete"],
+                            roomStrategy: "model",
+                        },
+                        modelName: "Todo",
+                        options: {
+                            permissions: {
+                                create: [function () { return true; }],
+                                delete: [function () { return true; }],
+                                list: [function () { return true; }],
+                                read: [function () { return true; }],
+                                update: [function () { return true; }],
+                            },
+                        },
+                        routePath: "/todos",
+                    });
+                    return [4 /*yield*/, Promise.resolve().then(function () { return __importStar(require("./changeStreamWatcher")); })];
+                case 1:
+                    startChangeStreamWatcher = (_a.sent()).startChangeStreamWatcher;
+                    io = createMockIo();
+                    startChangeStreamWatcher(io, {}, true);
+                    changeHandler = mockStream.listeners.get("change");
+                    return [4 /*yield*/, changeHandler({
+                            documentKey: { _id: "doc-1" },
+                            fullDocument: { _id: "doc-1", name: "Updated", status: "done" },
+                            ns: { coll: "todos" },
+                            operationType: "update",
+                            updateDescription: { updatedFields: { name: "Updated", status: "done" } },
+                        })];
+                case 2:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("respects ignoredCollections config", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var mockStream, mockDb, startChangeStreamWatcher, io, pipeline, matchStage;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    mockStream = createMockChangeStream();
+                    mockDb = {
+                        watch: (0, bun_test_1.mock)(function () { return mockStream; }),
+                    };
+                    mongoose_1.default.connection.db = mockDb;
+                    return [4 /*yield*/, Promise.resolve().then(function () { return __importStar(require("./changeStreamWatcher")); })];
+                case 1:
+                    startChangeStreamWatcher = (_a.sent()).startChangeStreamWatcher;
+                    io = createMockIo();
+                    startChangeStreamWatcher(io, { ignoredCollections: ["audit_logs"] }, true);
+                    pipeline = mockDb.watch.mock.calls[0][0];
+                    matchStage = pipeline[0].$match;
+                    (0, bun_test_1.expect)(matchStage["ns.coll"].$nin).toContain("audit_logs");
+                    (0, bun_test_1.expect)(matchStage["ns.coll"].$nin).toContain("socketio");
+                    (0, bun_test_1.expect)(matchStage["ns.coll"].$nin).toContain("sessions");
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("respects ignoredOperations config", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var mockStream, mockDb, startChangeStreamWatcher, io, changeHandler;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    mockStream = createMockChangeStream();
+                    mockDb = {
+                        watch: (0, bun_test_1.mock)(function () { return mockStream; }),
+                    };
+                    mongoose_1.default.connection.db = mockDb;
+                    (0, registry_1.registerRealtime)({
+                        collectionName: "todos",
+                        config: {
+                            methods: ["create", "update", "delete"],
+                            roomStrategy: "model",
+                        },
+                        modelName: "Todo",
+                        options: {
+                            permissions: {
+                                create: [function () { return true; }],
+                                delete: [function () { return true; }],
+                                list: [function () { return true; }],
+                                read: [function () { return true; }],
+                                update: [function () { return true; }],
+                            },
+                        },
+                        routePath: "/todos",
+                    });
+                    return [4 /*yield*/, Promise.resolve().then(function () { return __importStar(require("./changeStreamWatcher")); })];
+                case 1:
+                    startChangeStreamWatcher = (_a.sent()).startChangeStreamWatcher;
+                    io = createMockIo();
+                    startChangeStreamWatcher(io, { ignoredOperations: ["insert"] }, true);
+                    changeHandler = mockStream.listeners.get("change");
+                    // This insert should be skipped because "insert" is ignored
+                    return [4 /*yield*/, changeHandler({
+                            documentKey: { _id: "doc-1" },
+                            fullDocument: { _id: "doc-1" },
+                            ns: { coll: "todos" },
+                            operationType: "insert",
+                        })];
+                case 2:
+                    // This insert should be skipped because "insert" is ignored
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("skips events with no collectionName or docId", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var mockStream, mockDb, startChangeStreamWatcher, io, changeHandler;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    mockStream = createMockChangeStream();
+                    mockDb = {
+                        watch: (0, bun_test_1.mock)(function () { return mockStream; }),
+                    };
+                    mongoose_1.default.connection.db = mockDb;
+                    return [4 /*yield*/, Promise.resolve().then(function () { return __importStar(require("./changeStreamWatcher")); })];
+                case 1:
+                    startChangeStreamWatcher = (_a.sent()).startChangeStreamWatcher;
+                    io = createMockIo();
+                    startChangeStreamWatcher(io, {}, true);
+                    changeHandler = mockStream.listeners.get("change");
+                    // Missing ns.coll
+                    return [4 /*yield*/, changeHandler({
+                            documentKey: { _id: "doc-1" },
+                            ns: {},
+                            operationType: "insert",
+                        })];
+                case 2:
+                    // Missing ns.coll
+                    _a.sent();
+                    // Missing documentKey
+                    return [4 /*yield*/, changeHandler({
+                            documentKey: {},
+                            ns: { coll: "todos" },
+                            operationType: "insert",
+                        })];
+                case 3:
+                    // Missing documentKey
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("skips non-CRUD operation types", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var mockStream, mockDb, startChangeStreamWatcher, io, changeHandler;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    mockStream = createMockChangeStream();
+                    mockDb = {
+                        watch: (0, bun_test_1.mock)(function () { return mockStream; }),
+                    };
+                    mongoose_1.default.connection.db = mockDb;
+                    return [4 /*yield*/, Promise.resolve().then(function () { return __importStar(require("./changeStreamWatcher")); })];
+                case 1:
+                    startChangeStreamWatcher = (_a.sent()).startChangeStreamWatcher;
+                    io = createMockIo();
+                    startChangeStreamWatcher(io, {}, true);
+                    changeHandler = mockStream.listeners.get("change");
+                    // "drop" is not in our pipeline filter, should be skipped
+                    return [4 /*yield*/, changeHandler({
+                            operationType: "drop",
+                        })];
+                case 2:
+                    // "drop" is not in our pipeline filter, should be skipped
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("handles error/close/end events gracefully", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var mockStream, mockDb, startChangeStreamWatcher, io;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    mockStream = createMockChangeStream();
+                    mockDb = {
+                        watch: (0, bun_test_1.mock)(function () { return mockStream; }),
+                    };
+                    mongoose_1.default.connection.db = mockDb;
+                    return [4 /*yield*/, Promise.resolve().then(function () { return __importStar(require("./changeStreamWatcher")); })];
+                case 1:
+                    startChangeStreamWatcher = (_a.sent()).startChangeStreamWatcher;
+                    io = createMockIo();
+                    startChangeStreamWatcher(io, {}, true);
+                    // Trigger error, close, end — should not throw
+                    mockStream.trigger("error", new Error("test error"));
+                    mockStream.trigger("close");
+                    mockStream.trigger("end");
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("uses custom batchSize and fullDocument config", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var mockStream, mockDb, startChangeStreamWatcher, io, options;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    mockStream = createMockChangeStream();
+                    mockDb = {
+                        watch: (0, bun_test_1.mock)(function () { return mockStream; }),
+                    };
+                    mongoose_1.default.connection.db = mockDb;
+                    return [4 /*yield*/, Promise.resolve().then(function () { return __importStar(require("./changeStreamWatcher")); })];
+                case 1:
+                    startChangeStreamWatcher = (_a.sent()).startChangeStreamWatcher;
+                    io = createMockIo();
+                    startChangeStreamWatcher(io, { batchSize: 100, fullDocument: "whenAvailable" }, true);
+                    options = mockDb.watch.mock.calls[0][1];
+                    (0, bun_test_1.expect)(options.batchSize).toBe(100);
+                    (0, bun_test_1.expect)(options.fullDocument).toBe("whenAvailable");
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("catches errors thrown in the change handler", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var mockStream, mockDb, startChangeStreamWatcher, emissions, mockSocket, rooms, sockets, io, changeHandler;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    mockStream = createMockChangeStream();
+                    mockDb = {
+                        watch: (0, bun_test_1.mock)(function () { return mockStream; }),
+                    };
+                    mongoose_1.default.connection.db = mockDb;
+                    // Register with a model that will throw during permission check
+                    (0, registry_1.registerRealtime)({
+                        collectionName: "todos",
+                        config: {
+                            methods: ["create", "update", "delete"],
+                            roomStrategy: "model",
+                        },
+                        modelName: "Todo",
+                        options: {
+                            permissions: {
+                                create: [function () { return true; }],
+                                delete: [function () { return true; }],
+                                list: [function () { return true; }],
+                                read: [
+                                    function () {
+                                        throw new Error("permission check error");
+                                    },
+                                ],
+                                update: [function () { return true; }],
+                            },
+                        },
+                        routePath: "/todos",
+                    });
+                    return [4 /*yield*/, Promise.resolve().then(function () { return __importStar(require("./changeStreamWatcher")); })];
+                case 1:
+                    startChangeStreamWatcher = (_a.sent()).startChangeStreamWatcher;
+                    emissions = [];
+                    mockSocket = {
+                        decodedToken: { id: "user-1" },
+                        emit: function (_event, _data) {
+                            emissions.push({ _data: _data, _event: _event });
+                        },
+                        id: "sock-1",
+                    };
+                    rooms = new Map();
+                    rooms.set("model:todos", new Set(["sock-1"]));
+                    sockets = new Map();
+                    sockets.set("sock-1", mockSocket);
+                    io = {
+                        sockets: {
+                            adapter: { rooms: rooms },
+                            sockets: sockets,
+                        },
+                        to: function () { return ({ emit: function () { } }); },
+                    };
+                    startChangeStreamWatcher(io, {}, true);
+                    changeHandler = mockStream.listeners.get("change");
+                    // Should not throw even though permission check throws
+                    return [4 /*yield*/, changeHandler({
+                            documentKey: { _id: "doc-1" },
+                            fullDocument: { _id: "doc-1", name: "Test" },
+                            ns: { coll: "todos" },
+                            operationType: "insert",
+                        })];
+                case 2:
+                    // Should not throw even though permission check throws
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+});
+(0, bun_test_1.describe)("stopChangeStreamWatcher", function () {
+    (0, bun_test_1.it)("closes and nullifies the active watcher", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var mockStream, mockDb, originalDb, _a, startChangeStreamWatcher, stopChangeStreamWatcher, io;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    mockStream = {
+                        close: (0, bun_test_1.mock)(function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                            return [2 /*return*/];
+                        }); }); }),
+                        on: function () { },
+                    };
+                    mockDb = {
+                        watch: (0, bun_test_1.mock)(function () { return mockStream; }),
+                    };
+                    originalDb = mongoose_1.default.connection.db;
+                    mongoose_1.default.connection.db = mockDb;
+                    return [4 /*yield*/, Promise.resolve().then(function () { return __importStar(require("./changeStreamWatcher")); })];
+                case 1:
+                    _a = _b.sent(), startChangeStreamWatcher = _a.startChangeStreamWatcher, stopChangeStreamWatcher = _a.stopChangeStreamWatcher;
+                    io = {
+                        sockets: {
+                            adapter: { rooms: new Map() },
+                            sockets: new Map(),
+                        },
+                        to: function () { return ({ emit: function () { } }); },
+                    };
+                    startChangeStreamWatcher(io);
+                    return [4 /*yield*/, stopChangeStreamWatcher()];
+                case 2:
+                    _b.sent();
+                    (0, bun_test_1.expect)(mockStream.close).toHaveBeenCalled();
+                    // Calling again should be a no-op
+                    return [4 /*yield*/, stopChangeStreamWatcher()];
+                case 3:
+                    // Calling again should be a no-op
+                    _b.sent();
+                    mongoose_1.default.connection.db = originalDb;
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+});
+// ─────────────────────────────────────────────────────────────────────────────
+// RealtimeApp.onServerCreated / setupAdapter
+// ─────────────────────────────────────────────────────────────────────────────
+(0, bun_test_1.describe)("RealtimeApp.onServerCreated", function () {
+    var servers = [];
+    (0, bun_test_1.afterEach)(function () { return __awaiter(void 0, void 0, void 0, function () {
+        var servers_1, servers_1_1, s;
+        var e_1, _a;
+        return __generator(this, function (_b) {
+            try {
+                for (servers_1 = __values(servers), servers_1_1 = servers_1.next(); !servers_1_1.done; servers_1_1 = servers_1.next()) {
+                    s = servers_1_1.value;
+                    s.close();
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (servers_1_1 && !servers_1_1.done && (_a = servers_1.return)) _a.call(servers_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            servers.length = 0;
+            return [2 /*return*/];
+        });
+    }); });
+    var makeServer = function () {
+        var http = require("http");
+        var server = http.createServer();
+        servers.push(server);
+        return server;
+    };
+    (0, bun_test_1.it)("throws when TOKEN_SECRET is missing", function () {
+        var originalSecret = process.env.TOKEN_SECRET;
+        process.env.TOKEN_SECRET = "";
+        var app = new realtimeApp_1.RealtimeApp({ tokenSecret: undefined });
+        var server = makeServer();
+        (0, bun_test_1.expect)(function () { return app.onServerCreated(server); }).toThrow("TOKEN_SECRET is required");
+        process.env.TOKEN_SECRET = originalSecret;
+    });
+    (0, bun_test_1.it)("sets up Socket.io with valid config", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var app, server, originalDb, mockStream;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    app = new realtimeApp_1.RealtimeApp({
+                        adapter: "none",
+                        tokenSecret: "test-secret",
+                    });
+                    server = makeServer();
+                    originalDb = mongoose_1.default.connection.db;
+                    mockStream = { close: function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                            return [2 /*return*/];
+                        }); }); }, on: function () { return mockStream; } };
+                    mongoose_1.default.connection.db = { watch: function () { return mockStream; } };
+                    app.onServerCreated(server);
+                    (0, bun_test_1.expect)(app.getIo()).toBeDefined();
+                    return [4 /*yield*/, app.close()];
+                case 1:
+                    _a.sent();
+                    mongoose_1.default.connection.db = originalDb;
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+});
+(0, bun_test_1.describe)("RealtimeApp.setupAdapter (private, via onServerCreated config)", function () {
+    var servers = [];
+    (0, bun_test_1.afterEach)(function () { return __awaiter(void 0, void 0, void 0, function () {
+        var servers_2, servers_2_1, s;
+        var e_2, _a;
+        return __generator(this, function (_b) {
+            try {
+                for (servers_2 = __values(servers), servers_2_1 = servers_2.next(); !servers_2_1.done; servers_2_1 = servers_2.next()) {
+                    s = servers_2_1.value;
+                    s.close();
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (servers_2_1 && !servers_2_1.done && (_a = servers_2.return)) _a.call(servers_2);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+            servers.length = 0;
+            return [2 /*return*/];
+        });
+    }); });
+    var makeServer = function () {
+        var http = require("http");
+        var server = http.createServer();
+        servers.push(server);
+        return server;
+    };
+    (0, bun_test_1.it)("logs warning when redis adapter requested but no URL found", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var originalValkey, originalRedis, originalDb, mockStream, app, server;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    originalValkey = process.env.VALKEY_URL;
+                    originalRedis = process.env.REDIS_URL;
+                    originalDb = mongoose_1.default.connection.db;
+                    process.env.VALKEY_URL = "";
+                    process.env.REDIS_URL = "";
+                    mockStream = { close: function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                            return [2 /*return*/];
+                        }); }); }, on: function () { return mockStream; } };
+                    mongoose_1.default.connection.db = { watch: function () { return mockStream; } };
+                    app = new realtimeApp_1.RealtimeApp({
+                        adapter: "redis",
+                        tokenSecret: "test-secret",
+                    });
+                    server = makeServer();
+                    app.onServerCreated(server);
+                    return [4 /*yield*/, app.close()];
+                case 1:
+                    _a.sent();
+                    process.env.VALKEY_URL = originalValkey;
+                    process.env.REDIS_URL = originalRedis;
+                    mongoose_1.default.connection.db = originalDb;
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("logs info when redis adapter has a URL", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var originalValkey, originalDb, mockStream, app, server;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    originalValkey = process.env.VALKEY_URL;
+                    originalDb = mongoose_1.default.connection.db;
+                    process.env.VALKEY_URL = "redis://user:pass@localhost:6379/0";
+                    mockStream = { close: function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                            return [2 /*return*/];
+                        }); }); }, on: function () { return mockStream; } };
+                    mongoose_1.default.connection.db = { watch: function () { return mockStream; } };
+                    app = new realtimeApp_1.RealtimeApp({
+                        adapter: "redis",
+                        debug: true,
+                        tokenSecret: "test-secret",
+                    });
+                    server = makeServer();
+                    app.onServerCreated(server);
+                    return [4 /*yield*/, app.close()];
+                case 1:
+                    _a.sent();
+                    process.env.VALKEY_URL = originalValkey;
+                    mongoose_1.default.connection.db = originalDb;
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("no-op adapter mode 'none'", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var originalDb, mockStream, app, server;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    originalDb = mongoose_1.default.connection.db;
+                    mockStream = { close: function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                            return [2 /*return*/];
+                        }); }); }, on: function () { return mockStream; } };
+                    mongoose_1.default.connection.db = { watch: function () { return mockStream; } };
+                    app = new realtimeApp_1.RealtimeApp({
+                        adapter: "none",
+                        tokenSecret: "test-secret",
+                    });
+                    server = makeServer();
+                    app.onServerCreated(server);
+                    (0, bun_test_1.expect)(app.getIo()).toBeDefined();
+                    return [4 /*yield*/, app.close()];
+                case 1:
+                    _a.sent();
+                    mongoose_1.default.connection.db = originalDb;
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+});
+// ─────────────────────────────────────────────────────────────────────────────
+// ensureApiId
+// ─────────────────────────────────────────────────────────────────────────────
+(0, bun_test_1.describe)("ensureApiId", function () {
+    (0, bun_test_1.it)("returns null as-is", function () {
+        (0, bun_test_1.expect)((0, changeStreamWatcher_1.ensureApiId)(null)).toBeNull();
+    });
+    (0, bun_test_1.it)("returns undefined as-is", function () {
+        (0, bun_test_1.expect)((0, changeStreamWatcher_1.ensureApiId)(undefined)).toBeUndefined();
+    });
+    (0, bun_test_1.it)("returns arrays as-is", function () {
+        var arr = [1, 2, 3];
+        (0, bun_test_1.expect)((0, changeStreamWatcher_1.ensureApiId)(arr)).toBe(arr);
+    });
+    (0, bun_test_1.it)("returns primitive values as-is (non-object)", function () {
+        (0, bun_test_1.expect)((0, changeStreamWatcher_1.ensureApiId)("string")).toBe("string");
+    });
+    (0, bun_test_1.it)("adds id from _id when id is missing", function () {
+        (0, bun_test_1.expect)((0, changeStreamWatcher_1.ensureApiId)({ _id: "abc" })).toEqual({ _id: "abc", id: "abc" });
+    });
+    (0, bun_test_1.it)("does not overwrite existing id", function () {
+        (0, bun_test_1.expect)((0, changeStreamWatcher_1.ensureApiId)({ _id: "abc", id: "existing" })).toEqual({ _id: "abc", id: "existing" });
+    });
+    (0, bun_test_1.it)("returns object without _id unchanged", function () {
+        var obj = { name: "test" };
+        (0, bun_test_1.expect)((0, changeStreamWatcher_1.ensureApiId)(obj)).toBe(obj);
+    });
+});
+// ─────────────────────────────────────────────────────────────────────────────
+// startChangeStreamWatcher & stopChangeStreamWatcher
+// ─────────────────────────────────────────────────────────────────────────────
+(0, bun_test_1.describe)("startChangeStreamWatcher & stopChangeStreamWatcher", function () {
+    var makeMockIo = function () {
+        var emissions = [];
+        var rooms = new Map();
+        var sockets = new Map();
+        return {
+            emissions: emissions,
+            sockets: {
+                adapter: { rooms: rooms },
+                sockets: sockets,
+            },
+            to: function (_room) { return ({
+                emit: function () { },
+            }); },
+        };
+    };
+    (0, bun_test_1.afterEach)(function () { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, (0, changeStreamWatcher_1.stopChangeStreamWatcher)()];
+                case 1:
+                    _a.sent();
+                    (0, registry_1.clearRealtimeRegistry)();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("starts and stops without error when MongoDB is connected", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var io;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    io = makeMockIo();
+                    (0, bun_test_1.expect)(function () { return (0, changeStreamWatcher_1.startChangeStreamWatcher)(io, {}, false); }).not.toThrow();
+                    return [4 /*yield*/, (0, changeStreamWatcher_1.stopChangeStreamWatcher)()];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("starts with debug mode enabled", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var io;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    io = makeMockIo();
+                    (0, bun_test_1.expect)(function () { return (0, changeStreamWatcher_1.startChangeStreamWatcher)(io, {}, true); }).not.toThrow();
+                    return [4 /*yield*/, (0, changeStreamWatcher_1.stopChangeStreamWatcher)()];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("starts with custom config options", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var io;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    io = makeMockIo();
+                    (0, bun_test_1.expect)(function () {
+                        return (0, changeStreamWatcher_1.startChangeStreamWatcher)(io, {
+                            batchSize: 10,
+                            fullDocument: "whenAvailable",
+                            ignoredCollections: ["logs"],
+                            ignoredOperations: ["delete"],
+                        }, false);
+                    }).not.toThrow();
+                    return [4 /*yield*/, (0, changeStreamWatcher_1.stopChangeStreamWatcher)()];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("stopChangeStreamWatcher is safe to call when no watcher is active", function () { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, (0, bun_test_1.expect)((0, changeStreamWatcher_1.stopChangeStreamWatcher)()).resolves.toBeUndefined()];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("stopChangeStreamWatcher can be called multiple times", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var io;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    io = makeMockIo();
+                    (0, changeStreamWatcher_1.startChangeStreamWatcher)(io, {}, false);
+                    return [4 /*yield*/, (0, changeStreamWatcher_1.stopChangeStreamWatcher)()];
+                case 1:
+                    _a.sent();
+                    return [4 /*yield*/, (0, changeStreamWatcher_1.stopChangeStreamWatcher)()];
+                case 2:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+});
+// Change streams require a MongoDB replica set. CI (api-ci.yml) runs standalone MongoDB,
+// so these tests are skipped when replica sets are not available.
+var hasReplicaSet = function () { return __awaiter(void 0, void 0, void 0, function () {
+    var mongoose_2, admin, status_1, _a;
+    return __generator(this, function (_b) {
+        switch (_b.label) {
+            case 0:
+                _b.trys.push([0, 2, , 3]);
+                mongoose_2 = require("mongoose");
+                admin = mongoose_2.connection.db.admin();
+                return [4 /*yield*/, admin.command({ replSetGetStatus: 1 })];
+            case 1:
+                status_1 = _b.sent();
+                return [2 /*return*/, !!status_1.ok];
+            case 2:
+                _a = _b.sent();
+                return [2 /*return*/, false];
+            case 3: return [2 /*return*/];
+        }
+    });
+}); };
+(0, bun_test_1.describe)("startChangeStreamWatcher — change event integration", function () {
+    var mongoose = require("mongoose");
+    var replicaSetAvailable = false;
+    var realtimeTestSchema = new mongoose.Schema({
+        deleted: { default: false, type: Boolean },
+        name: { type: String },
+        ownerId: { type: String },
+    }, { collection: "realtimetests", strict: "throw" });
+    var RealtimeTestModel;
+    try {
+        RealtimeTestModel = mongoose.model("RealtimeTest");
+    }
+    catch (_a) {
+        RealtimeTestModel = mongoose.model("RealtimeTest", realtimeTestSchema);
+    }
+    var makeTrackedIo = function () {
+        var emissions = [];
+        var rooms = new Map();
+        var sockets = new Map();
+        var addSocketToRoom = function (room, decodedToken) {
+            var _a;
+            if (decodedToken === void 0) { decodedToken = { admin: true, id: "admin" }; }
+            var socketId = "socket-".concat(Math.random().toString(36).slice(2, 9));
+            if (!rooms.has(room)) {
+                rooms.set(room, new Set());
+            }
+            (_a = rooms.get(room)) === null || _a === void 0 ? void 0 : _a.add(socketId);
+            sockets.set(socketId, {
+                decodedToken: decodedToken,
+                emit: function (event, payload) {
+                    emissions.push({ event: event, payload: payload, room: room, socketId: socketId });
+                },
+                id: socketId,
+            });
+        };
+        return {
+            addSocketToRoom: addSocketToRoom,
+            emissions: emissions,
+            sockets: {
+                adapter: { rooms: rooms },
+                sockets: sockets,
+            },
+            to: function (room) { return ({
+                emit: function (event, payload) {
+                    emissions.push({ event: event, payload: payload, room: room });
+                },
+            }); },
+        };
+    };
+    (0, bun_test_1.beforeAll)(function () { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, hasReplicaSet()];
+                case 1:
+                    replicaSetAvailable = _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.beforeEach)(function () { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    (0, registry_1.clearRealtimeRegistry)();
+                    (0, queryStore_1.clearQueryStore)();
+                    return [4 /*yield*/, RealtimeTestModel.deleteMany({})];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.afterEach)(function () { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, (0, changeStreamWatcher_1.stopChangeStreamWatcher)()];
+                case 1:
+                    _a.sent();
+                    (0, registry_1.clearRealtimeRegistry)();
+                    (0, queryStore_1.clearQueryStore)();
+                    return [4 /*yield*/, RealtimeTestModel.deleteMany({})];
+                case 2:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("processes insert events from MongoDB change stream", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var io, createEmissions;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!replicaSetAvailable) {
+                        return [2 /*return*/];
+                    }
+                    (0, registry_1.registerRealtime)({
+                        collectionName: "realtimetests",
+                        config: { methods: ["create", "update", "delete"], roomStrategy: "model" },
+                        modelName: "RealtimeTest",
+                        options: {
+                            permissions: {
+                                create: [function () { return true; }],
+                                delete: [function () { return true; }],
+                                list: [function () { return true; }],
+                                read: [function () { return true; }],
+                                update: [function () { return true; }],
+                            },
+                        },
+                        routePath: "/realtimetests",
+                    });
+                    io = makeTrackedIo();
+                    io.addSocketToRoom("model:realtimetests");
+                    (0, changeStreamWatcher_1.startChangeStreamWatcher)(io, {}, true);
+                    return [4 /*yield*/, RealtimeTestModel.create({ name: "test-item", ownerId: "user-1" })];
+                case 1:
+                    _a.sent();
+                    // Wait for the change stream event to be processed
+                    return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 1500); })];
+                case 2:
+                    // Wait for the change stream event to be processed
+                    _a.sent();
+                    createEmissions = io.emissions.filter(function (e) { var _a; return e.event === "sync" && ((_a = e.payload) === null || _a === void 0 ? void 0 : _a.method) === "create"; });
+                    (0, bun_test_1.expect)(createEmissions.length).toBeGreaterThanOrEqual(1);
+                    return [4 /*yield*/, (0, changeStreamWatcher_1.stopChangeStreamWatcher)()];
+                case 3:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("processes update events from MongoDB change stream", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var doc, io, updateEmissions;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!replicaSetAvailable) {
+                        return [2 /*return*/];
+                    }
+                    (0, registry_1.registerRealtime)({
+                        collectionName: "realtimetests",
+                        config: { methods: ["create", "update", "delete"], roomStrategy: "model" },
+                        modelName: "RealtimeTest",
+                        options: {
+                            permissions: {
+                                create: [function () { return true; }],
+                                delete: [function () { return true; }],
+                                list: [function () { return true; }],
+                                read: [function () { return true; }],
+                                update: [function () { return true; }],
+                            },
+                        },
+                        routePath: "/realtimetests",
+                    });
+                    return [4 /*yield*/, RealtimeTestModel.create({ name: "item-to-update", ownerId: "user-1" })];
+                case 1:
+                    doc = _a.sent();
+                    io = makeTrackedIo();
+                    io.addSocketToRoom("model:realtimetests");
+                    (0, changeStreamWatcher_1.startChangeStreamWatcher)(io, {}, true);
+                    return [4 /*yield*/, RealtimeTestModel.updateOne({ _id: doc._id }, { $set: { name: "updated-item" } })];
+                case 2:
+                    _a.sent();
+                    return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 1500); })];
+                case 3:
+                    _a.sent();
+                    updateEmissions = io.emissions.filter(function (e) { var _a; return e.event === "sync" && ((_a = e.payload) === null || _a === void 0 ? void 0 : _a.method) === "update"; });
+                    (0, bun_test_1.expect)(updateEmissions.length).toBeGreaterThanOrEqual(1);
+                    return [4 /*yield*/, (0, changeStreamWatcher_1.stopChangeStreamWatcher)()];
+                case 4:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("processes hard delete events from MongoDB change stream", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var doc, io, deleteEmissions;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!replicaSetAvailable) {
+                        return [2 /*return*/];
+                    }
+                    (0, registry_1.registerRealtime)({
+                        collectionName: "realtimetests",
+                        config: { methods: ["create", "update", "delete"], roomStrategy: "model" },
+                        modelName: "RealtimeTest",
+                        options: {
+                            permissions: {
+                                create: [function () { return true; }],
+                                delete: [function () { return true; }],
+                                list: [function () { return true; }],
+                                read: [function () { return true; }],
+                                update: [function () { return true; }],
+                            },
+                        },
+                        routePath: "/realtimetests",
+                    });
+                    return [4 /*yield*/, RealtimeTestModel.create({ name: "item-to-delete" })];
+                case 1:
+                    doc = _a.sent();
+                    io = makeTrackedIo();
+                    io.addSocketToRoom("model:realtimetests");
+                    (0, changeStreamWatcher_1.startChangeStreamWatcher)(io, {}, true);
+                    return [4 /*yield*/, RealtimeTestModel.deleteOne({ _id: doc._id })];
+                case 2:
+                    _a.sent();
+                    return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 1500); })];
+                case 3:
+                    _a.sent();
+                    deleteEmissions = io.emissions.filter(function (e) { var _a; return e.event === "sync" && ((_a = e.payload) === null || _a === void 0 ? void 0 : _a.method) === "delete"; });
+                    (0, bun_test_1.expect)(deleteEmissions.length).toBeGreaterThanOrEqual(1);
+                    return [4 /*yield*/, (0, changeStreamWatcher_1.stopChangeStreamWatcher)()];
+                case 4:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("processes soft delete events from MongoDB change stream", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var doc, io, deleteEmissions;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!replicaSetAvailable) {
+                        return [2 /*return*/];
+                    }
+                    (0, registry_1.registerRealtime)({
+                        collectionName: "realtimetests",
+                        config: { methods: ["create", "update", "delete"], roomStrategy: "model" },
+                        modelName: "RealtimeTest",
+                        options: {
+                            permissions: {
+                                create: [function () { return true; }],
+                                delete: [function () { return true; }],
+                                list: [function () { return true; }],
+                                read: [function () { return true; }],
+                                update: [function () { return true; }],
+                            },
+                        },
+                        routePath: "/realtimetests",
+                    });
+                    return [4 /*yield*/, RealtimeTestModel.create({ name: "item-to-soft-delete" })];
+                case 1:
+                    doc = _a.sent();
+                    io = makeTrackedIo();
+                    io.addSocketToRoom("model:realtimetests");
+                    (0, changeStreamWatcher_1.startChangeStreamWatcher)(io, {}, true);
+                    return [4 /*yield*/, RealtimeTestModel.updateOne({ _id: doc._id }, { $set: { deleted: true } })];
+                case 2:
+                    _a.sent();
+                    return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 1500); })];
+                case 3:
+                    _a.sent();
+                    deleteEmissions = io.emissions.filter(function (e) { var _a; return e.event === "sync" && ((_a = e.payload) === null || _a === void 0 ? void 0 : _a.method) === "delete"; });
+                    (0, bun_test_1.expect)(deleteEmissions.length).toBeGreaterThanOrEqual(1);
+                    return [4 /*yield*/, (0, changeStreamWatcher_1.stopChangeStreamWatcher)()];
+                case 4:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("includes updatedFields and emits to document rooms", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var doc, docId, io, updateEmissions;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!replicaSetAvailable) {
+                        return [2 /*return*/];
+                    }
+                    (0, registry_1.registerRealtime)({
+                        collectionName: "realtimetests",
+                        config: { methods: ["create", "update", "delete"], roomStrategy: "model" },
+                        modelName: "RealtimeTest",
+                        options: {
+                            permissions: {
+                                create: [function () { return true; }],
+                                delete: [function () { return true; }],
+                                list: [function () { return true; }],
+                                read: [function () { return true; }],
+                                update: [function () { return true; }],
+                            },
+                        },
+                        routePath: "/realtimetests",
+                    });
+                    return [4 /*yield*/, RealtimeTestModel.create({ name: "fields-test" })];
+                case 1:
+                    doc = _a.sent();
+                    docId = doc._id.toString();
+                    io = makeTrackedIo();
+                    io.addSocketToRoom("model:realtimetests");
+                    io.addSocketToRoom("document:realtimetests:".concat(docId));
+                    (0, changeStreamWatcher_1.startChangeStreamWatcher)(io, {}, true);
+                    return [4 /*yield*/, RealtimeTestModel.updateOne({ _id: doc._id }, { $set: { name: "fields-updated" } })];
+                case 2:
+                    _a.sent();
+                    return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 1500); })];
+                case 3:
+                    _a.sent();
+                    updateEmissions = io.emissions.filter(function (e) { var _a; return e.event === "sync" && ((_a = e.payload) === null || _a === void 0 ? void 0 : _a.method) === "update"; });
+                    (0, bun_test_1.expect)(updateEmissions.length).toBeGreaterThanOrEqual(1);
+                    if (updateEmissions.length > 0) {
+                        (0, bun_test_1.expect)(updateEmissions[0].payload.updatedFields).toBeDefined();
+                        (0, bun_test_1.expect)(updateEmissions[0].payload.updatedFields).toContain("name");
+                    }
+                    return [4 /*yield*/, (0, changeStreamWatcher_1.stopChangeStreamWatcher)()];
+                case 4:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+});
+// ─────────────────────────────────────────────────────────────────────────────
+// emitToDocumentAndQueryRooms — no-entry path
+// ─────────────────────────────────────────────────────────────────────────────
+(0, bun_test_1.describe)("emitToDocumentAndQueryRooms — no registry entry", function () {
+    var makeIoSimple = function () {
+        var emissions = [];
+        return {
+            emissions: emissions,
+            sockets: {
+                adapter: { rooms: new Map() },
+                sockets: new Map(),
+            },
+            to: function (room) { return ({
+                emit: function (event, payload) {
+                    emissions.push({ event: event, payload: payload, room: room });
+                },
+            }); },
+        };
+    };
+    (0, bun_test_1.beforeEach)(function () {
+        (0, queryStore_1.clearQueryStore)();
+    });
+    (0, bun_test_1.afterEach)(function () {
+        (0, queryStore_1.clearQueryStore)();
+    });
+    (0, bun_test_1.it)("emits to document room via io.to when no entry is provided", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var io, event;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    io = makeIoSimple();
+                    event = {
+                        collection: "items",
+                        id: "doc-1",
+                        method: "update",
+                        model: "Item",
+                        timestamp: 1,
+                    };
+                    return [4 /*yield*/, (0, changeStreamWatcher_1.emitToDocumentAndQueryRooms)(io, "items", event, {}, function () { })];
+                case 1:
+                    _a.sent();
+                    (0, bun_test_1.expect)(io.emissions.some(function (e) { return e.room === "document:items:doc-1"; })).toBe(true);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("emits hard deletes to query rooms via io.to when no entry", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var queryId, io, event;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    queryId = (0, queryStore_1.computeQueryId)("items", { status: "active" });
+                    (0, queryStore_1.addQuerySubscription)("socket-a", "items", { status: "active" }, queryId);
+                    io = makeIoSimple();
+                    event = {
+                        collection: "items",
+                        id: "doc-1",
+                        method: "delete",
+                        model: "Item",
+                        timestamp: 1,
+                    };
+                    return [4 /*yield*/, (0, changeStreamWatcher_1.emitToDocumentAndQueryRooms)(io, "items", event, undefined, function () { })];
+                case 1:
+                    _a.sent();
+                    (0, bun_test_1.expect)(io.emissions.some(function (e) { return e.room === "query:".concat(queryId); })).toBe(true);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("emits soft delete to query rooms via io.to when no entry and doc matches", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var queryId, io, event;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    queryId = (0, queryStore_1.computeQueryId)("items", { status: "active" });
+                    (0, queryStore_1.addQuerySubscription)("socket-a", "items", { status: "active" }, queryId);
+                    io = makeIoSimple();
+                    event = {
+                        collection: "items",
+                        id: "doc-1",
+                        method: "delete",
+                        model: "Item",
+                        timestamp: 1,
+                    };
+                    return [4 /*yield*/, (0, changeStreamWatcher_1.emitToDocumentAndQueryRooms)(io, "items", event, { status: "active" }, function () { })];
+                case 1:
+                    _a.sent();
+                    (0, bun_test_1.expect)(io.emissions.some(function (e) { return e.room === "query:".concat(queryId); })).toBe(true);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("emits create events to query rooms via io.to when no entry and doc matches", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var queryId, io, event;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    queryId = (0, queryStore_1.computeQueryId)("items", { status: "active" });
+                    (0, queryStore_1.addQuerySubscription)("socket-a", "items", { status: "active" }, queryId);
+                    io = makeIoSimple();
+                    event = {
+                        collection: "items",
+                        id: "doc-1",
+                        method: "create",
+                        model: "Item",
+                        timestamp: 1,
+                    };
+                    return [4 /*yield*/, (0, changeStreamWatcher_1.emitToDocumentAndQueryRooms)(io, "items", event, { status: "active" }, function () { })];
+                case 1:
+                    _a.sent();
+                    (0, bun_test_1.expect)(io.emissions.some(function (e) { return e.room === "query:".concat(queryId); })).toBe(true);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("emits update events to query rooms via io.to when no entry and doc matches", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var queryId, io, event;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    queryId = (0, queryStore_1.computeQueryId)("items", { status: "active" });
+                    (0, queryStore_1.addQuerySubscription)("socket-a", "items", { status: "active" }, queryId);
+                    io = makeIoSimple();
+                    event = {
+                        collection: "items",
+                        id: "doc-1",
+                        method: "update",
+                        model: "Item",
+                        timestamp: 1,
+                    };
+                    return [4 /*yield*/, (0, changeStreamWatcher_1.emitToDocumentAndQueryRooms)(io, "items", event, { status: "active" }, function () { })];
+                case 1:
+                    _a.sent();
+                    (0, bun_test_1.expect)(io.emissions.some(function (e) { return e.room === "query:".concat(queryId); })).toBe(true);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("emits delete to query rooms via io.to when update no longer matches and no entry", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var queryId, io, event, queryEmissions;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    queryId = (0, queryStore_1.computeQueryId)("items", { status: "active" });
+                    (0, queryStore_1.addQuerySubscription)("socket-a", "items", { status: "active" }, queryId);
+                    io = makeIoSimple();
+                    event = {
+                        collection: "items",
+                        id: "doc-1",
+                        method: "update",
+                        model: "Item",
+                        timestamp: 1,
+                    };
+                    return [4 /*yield*/, (0, changeStreamWatcher_1.emitToDocumentAndQueryRooms)(io, "items", event, { status: "inactive" }, function () { })];
+                case 1:
+                    _a.sent();
+                    queryEmissions = io.emissions.filter(function (e) { return e.room === "query:".concat(queryId); });
+                    (0, bun_test_1.expect)(queryEmissions.length).toBe(1);
+                    (0, bun_test_1.expect)(queryEmissions[0].payload).toMatchObject({ method: "delete" });
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+});
+// ─────────────────────────────────────────────────────────────────────────────
+// RealtimeApp — onServerCreated, setupAdapter, close
+// ─────────────────────────────────────────────────────────────────────────────
+(0, bun_test_1.describe)("RealtimeApp — onServerCreated and setupAdapter", function () {
+    var originalEnv = process.env;
+    (0, bun_test_1.beforeEach)(function () {
+        process.env = __assign(__assign({}, originalEnv), { TOKEN_SECRET: "test-secret" });
+    });
+    (0, bun_test_1.afterEach)(function () { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            process.env = originalEnv;
+            (0, registry_1.clearRealtimeRegistry)();
+            return [2 /*return*/];
+        });
+    }); });
+    (0, bun_test_1.it)("register adds /realtime/health endpoint with debug flag", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var expressApp, app, supertest, st, res;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    expressApp = (0, express_1.default)();
+                    app = new realtimeApp_1.RealtimeApp({ debug: true });
+                    app.register(expressApp);
+                    return [4 /*yield*/, Promise.resolve().then(function () { return __importStar(require("supertest")); })];
+                case 1:
+                    supertest = _a.sent();
+                    st = supertest.default(expressApp);
+                    return [4 /*yield*/, st.get("/realtime/health").expect(200)];
+                case 2:
+                    res = _a.sent();
+                    (0, bun_test_1.expect)(res.body.status).toBe("not_started");
+                    (0, bun_test_1.expect)(res.body.debug).toBe(true);
+                    (0, bun_test_1.expect)(res.body.clients).toBe(0);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("onServerCreated sets up Socket.io with JWT auth", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var http, app, expressApp, server;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, Promise.resolve().then(function () { return __importStar(require("node:http")); })];
+                case 1:
+                    http = _a.sent();
+                    app = new realtimeApp_1.RealtimeApp({ debug: true, tokenSecret: "test-secret" });
+                    expressApp = (0, express_1.default)();
+                    app.register(expressApp);
+                    server = http.createServer(expressApp);
+                    app.onServerCreated(server);
+                    (0, bun_test_1.expect)(app.getIo()).not.toBeNull();
+                    return [4 /*yield*/, app.close()];
+                case 2:
+                    _a.sent();
+                    server.close();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("onServerCreated throws when TOKEN_SECRET is missing", function () {
+        var http = require("node:http");
+        var origSecret = process.env.TOKEN_SECRET;
+        process.env.TOKEN_SECRET = "";
+        var app = new realtimeApp_1.RealtimeApp({});
+        var expressApp = (0, express_1.default)();
+        app.register(expressApp);
+        var server = http.createServer(expressApp);
+        (0, bun_test_1.expect)(function () { return app.onServerCreated(server); }).toThrow("TOKEN_SECRET is required");
+        process.env.TOKEN_SECRET = origSecret;
+        server.close();
+    });
+    (0, bun_test_1.it)("onServerCreated uses default TOKEN_SECRET from env", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var http, app, expressApp, server;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, Promise.resolve().then(function () { return __importStar(require("node:http")); })];
+                case 1:
+                    http = _a.sent();
+                    process.env.TOKEN_SECRET = "env-secret";
+                    app = new realtimeApp_1.RealtimeApp({ debug: false });
+                    expressApp = (0, express_1.default)();
+                    app.register(expressApp);
+                    server = http.createServer(expressApp);
+                    app.onServerCreated(server);
+                    (0, bun_test_1.expect)(app.getIo()).not.toBeNull();
+                    return [4 /*yield*/, app.close()];
+                case 2:
+                    _a.sent();
+                    server.close();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("setupAdapter logs info for redis adapter with URL", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var http, app, expressApp, server;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, Promise.resolve().then(function () { return __importStar(require("node:http")); })];
+                case 1:
+                    http = _a.sent();
+                    app = new realtimeApp_1.RealtimeApp({
+                        adapter: "redis",
+                        debug: true,
+                        redisUrl: "redis://user:pass@localhost:6379",
+                        tokenSecret: "test-secret",
+                    });
+                    expressApp = (0, express_1.default)();
+                    app.register(expressApp);
+                    server = http.createServer(expressApp);
+                    app.onServerCreated(server);
+                    (0, bun_test_1.expect)(app.getIo()).not.toBeNull();
+                    return [4 /*yield*/, app.close()];
+                case 2:
+                    _a.sent();
+                    server.close();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("setupAdapter warns when redis adapter has no URL", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var http, origValkey, origRedis, app, expressApp, server;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, Promise.resolve().then(function () { return __importStar(require("node:http")); })];
+                case 1:
+                    http = _a.sent();
+                    origValkey = process.env.VALKEY_URL;
+                    origRedis = process.env.REDIS_URL;
+                    delete process.env.VALKEY_URL;
+                    delete process.env.REDIS_URL;
+                    app = new realtimeApp_1.RealtimeApp({
+                        adapter: "redis",
+                        debug: true,
+                        tokenSecret: "test-secret",
+                    });
+                    expressApp = (0, express_1.default)();
+                    app.register(expressApp);
+                    server = http.createServer(expressApp);
+                    app.onServerCreated(server);
+                    (0, bun_test_1.expect)(app.getIo()).not.toBeNull();
+                    return [4 /*yield*/, app.close()];
+                case 2:
+                    _a.sent();
+                    server.close();
+                    process.env.VALKEY_URL = origValkey;
+                    process.env.REDIS_URL = origRedis;
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("setupAdapter with none adapter does nothing extra", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var http, app, expressApp, server;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, Promise.resolve().then(function () { return __importStar(require("node:http")); })];
+                case 1:
+                    http = _a.sent();
+                    app = new realtimeApp_1.RealtimeApp({
+                        adapter: "none",
+                        debug: true,
+                        tokenSecret: "test-secret",
+                    });
+                    expressApp = (0, express_1.default)();
+                    app.register(expressApp);
+                    server = http.createServer(expressApp);
+                    app.onServerCreated(server);
+                    (0, bun_test_1.expect)(app.getIo()).not.toBeNull();
+                    return [4 /*yield*/, app.close()];
+                case 2:
+                    _a.sent();
+                    server.close();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("close is safe after onServerCreated", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var http, app, expressApp, server;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, Promise.resolve().then(function () { return __importStar(require("node:http")); })];
+                case 1:
+                    http = _a.sent();
+                    app = new realtimeApp_1.RealtimeApp({ tokenSecret: "test-secret" });
+                    expressApp = (0, express_1.default)();
+                    app.register(expressApp);
+                    server = http.createServer(expressApp);
+                    app.onServerCreated(server);
+                    return [4 /*yield*/, app.close()];
+                case 2:
+                    _a.sent();
+                    (0, bun_test_1.expect)(app.getIo()).toBeNull();
+                    server.close();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("health endpoint reports running after onServerCreated", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var http, app, expressApp, server, supertest, st, res;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, Promise.resolve().then(function () { return __importStar(require("node:http")); })];
+                case 1:
+                    http = _a.sent();
+                    app = new realtimeApp_1.RealtimeApp({ tokenSecret: "test-secret" });
+                    expressApp = (0, express_1.default)();
+                    app.register(expressApp);
+                    server = http.createServer(expressApp);
+                    app.onServerCreated(server);
+                    return [4 /*yield*/, Promise.resolve().then(function () { return __importStar(require("supertest")); })];
+                case 2:
+                    supertest = _a.sent();
+                    st = supertest.default(expressApp);
+                    return [4 /*yield*/, st.get("/realtime/health").expect(200)];
+                case 3:
+                    res = _a.sent();
+                    (0, bun_test_1.expect)(res.body.status).toBe("running");
+                    return [4 /*yield*/, app.close()];
+                case 4:
+                    _a.sent();
+                    server.close();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("onServerCreated with custom cors option", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var http, app, expressApp, server;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, Promise.resolve().then(function () { return __importStar(require("node:http")); })];
+                case 1:
+                    http = _a.sent();
+                    app = new realtimeApp_1.RealtimeApp({
+                        cors: { methods: ["GET"], origin: "https://example.com" },
+                        tokenSecret: "test-secret",
+                    });
+                    expressApp = (0, express_1.default)();
+                    app.register(expressApp);
+                    server = http.createServer(expressApp);
+                    app.onServerCreated(server);
+                    (0, bun_test_1.expect)(app.getIo()).not.toBeNull();
+                    return [4 /*yield*/, app.close()];
+                case 2:
+                    _a.sent();
+                    server.close();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("setupAdapter uses VALKEY_URL when redisUrl not provided", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var http, app, expressApp, server;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, Promise.resolve().then(function () { return __importStar(require("node:http")); })];
+                case 1:
+                    http = _a.sent();
+                    process.env.VALKEY_URL = "redis://localhost:6379";
+                    app = new realtimeApp_1.RealtimeApp({
+                        adapter: "redis",
+                        debug: true,
+                        tokenSecret: "test-secret",
+                    });
+                    expressApp = (0, express_1.default)();
+                    app.register(expressApp);
+                    server = http.createServer(expressApp);
+                    app.onServerCreated(server);
+                    (0, bun_test_1.expect)(app.getIo()).not.toBeNull();
+                    return [4 /*yield*/, app.close()];
+                case 2:
+                    _a.sent();
+                    server.close();
+                    delete process.env.VALKEY_URL;
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+});
+// ─────────────────────────────────────────────────────────────────────────────
+// redactCredentials — Redis URL logging
+// ─────────────────────────────────────────────────────────────────────────────
 (0, bun_test_1.describe)("redactCredentials", function () {
     (0, bun_test_1.it)("redacts user:password@ in a redis URL", function () {
         (0, bun_test_1.expect)((0, realtimeApp_1.redactCredentials)("redis://user:secret@host:6379/0")).toBe("redis://***@host:6379/0");