@terreno/api 0.13.2 → 0.14.0

package/dist/realtime/index.d.ts

@@ -0,0 +1,6 @@
+export { startChangeStreamWatcher, stopChangeStreamWatcher } from "./changeStreamWatcher";
+export { matchesQuery } from "./queryMatcher";
+export { addQuerySubscription, clearQueryStore, computeQueryId, getQuerySubscriptionsForCollection, removeAllSocketQueries, removeQuerySubscription, } from "./queryStore";
+export { installRealtimeSocketHandlers, MAX_DOCUMENT_SUBSCRIPTIONS, MAX_MODEL_SUBSCRIPTIONS, MAX_QUERY_SUBSCRIPTIONS, RealtimeApp, type RealtimeSocketLike, } from "./realtimeApp";
+export { clearRealtimeRegistry, findRegistryEntryByCollection, findRegistryEntryByRoutePath, getRealtimeRegistry, type RealtimeRegistryEntry, registerRealtime, } from "./registry";
+export type { ChangeStreamConfig, DocumentSubscription, QuerySubscription, RealtimeAppOptions, RealtimeConfig, RealtimeEvent, } from "./types";

package/dist/realtime/index.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerRealtime = exports.getRealtimeRegistry = exports.findRegistryEntryByRoutePath = exports.findRegistryEntryByCollection = exports.clearRealtimeRegistry = exports.RealtimeApp = exports.MAX_QUERY_SUBSCRIPTIONS = exports.MAX_MODEL_SUBSCRIPTIONS = exports.MAX_DOCUMENT_SUBSCRIPTIONS = exports.installRealtimeSocketHandlers = exports.removeQuerySubscription = exports.removeAllSocketQueries = exports.getQuerySubscriptionsForCollection = exports.computeQueryId = exports.clearQueryStore = exports.addQuerySubscription = exports.matchesQuery = exports.stopChangeStreamWatcher = exports.startChangeStreamWatcher = void 0;
+var changeStreamWatcher_1 = require("./changeStreamWatcher");
+Object.defineProperty(exports, "startChangeStreamWatcher", { enumerable: true, get: function () { return changeStreamWatcher_1.startChangeStreamWatcher; } });
+Object.defineProperty(exports, "stopChangeStreamWatcher", { enumerable: true, get: function () { return changeStreamWatcher_1.stopChangeStreamWatcher; } });
+var queryMatcher_1 = require("./queryMatcher");
+Object.defineProperty(exports, "matchesQuery", { enumerable: true, get: function () { return queryMatcher_1.matchesQuery; } });
+var queryStore_1 = require("./queryStore");
+Object.defineProperty(exports, "addQuerySubscription", { enumerable: true, get: function () { return queryStore_1.addQuerySubscription; } });
+Object.defineProperty(exports, "clearQueryStore", { enumerable: true, get: function () { return queryStore_1.clearQueryStore; } });
+Object.defineProperty(exports, "computeQueryId", { enumerable: true, get: function () { return queryStore_1.computeQueryId; } });
+Object.defineProperty(exports, "getQuerySubscriptionsForCollection", { enumerable: true, get: function () { return queryStore_1.getQuerySubscriptionsForCollection; } });
+Object.defineProperty(exports, "removeAllSocketQueries", { enumerable: true, get: function () { return queryStore_1.removeAllSocketQueries; } });
+Object.defineProperty(exports, "removeQuerySubscription", { enumerable: true, get: function () { return queryStore_1.removeQuerySubscription; } });
+var realtimeApp_1 = require("./realtimeApp");
+Object.defineProperty(exports, "installRealtimeSocketHandlers", { enumerable: true, get: function () { return realtimeApp_1.installRealtimeSocketHandlers; } });
+Object.defineProperty(exports, "MAX_DOCUMENT_SUBSCRIPTIONS", { enumerable: true, get: function () { return realtimeApp_1.MAX_DOCUMENT_SUBSCRIPTIONS; } });
+Object.defineProperty(exports, "MAX_MODEL_SUBSCRIPTIONS", { enumerable: true, get: function () { return realtimeApp_1.MAX_MODEL_SUBSCRIPTIONS; } });
+Object.defineProperty(exports, "MAX_QUERY_SUBSCRIPTIONS", { enumerable: true, get: function () { return realtimeApp_1.MAX_QUERY_SUBSCRIPTIONS; } });
+Object.defineProperty(exports, "RealtimeApp", { enumerable: true, get: function () { return realtimeApp_1.RealtimeApp; } });
+var registry_1 = require("./registry");
+Object.defineProperty(exports, "clearRealtimeRegistry", { enumerable: true, get: function () { return registry_1.clearRealtimeRegistry; } });
+Object.defineProperty(exports, "findRegistryEntryByCollection", { enumerable: true, get: function () { return registry_1.findRegistryEntryByCollection; } });
+Object.defineProperty(exports, "findRegistryEntryByRoutePath", { enumerable: true, get: function () { return registry_1.findRegistryEntryByRoutePath; } });
+Object.defineProperty(exports, "getRealtimeRegistry", { enumerable: true, get: function () { return registry_1.getRealtimeRegistry; } });
+Object.defineProperty(exports, "registerRealtime", { enumerable: true, get: function () { return registry_1.registerRealtime; } });

package/dist/realtime/queryMatcher.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Simple in-memory MongoDB query matcher.
+ * Evaluates a MongoDB-style query object against a document without hitting the database.
+ *
+ * Supports: equality, $eq, $ne, $gt, $gte, $lt, $lte, $in, $nin, $exists, $and, $or, $not.
+ */
+/**
+ * Check if a document matches a MongoDB-style query in memory.
+ *
+ * @param doc - The document to test (plain object or Mongoose document)
+ * @param query - MongoDB-style query object
+ * @returns true if the document matches all query conditions
+ */
+export declare const matchesQuery: (doc: any, query: Record<string, any>) => boolean;

package/dist/realtime/queryMatcher.js

@@ -0,0 +1,250 @@
+"use strict";
+// biome-ignore-all lint/suspicious/noExplicitAny: MongoDB query matcher evaluates dynamic filter shapes
+/**
+ * Simple in-memory MongoDB query matcher.
+ * Evaluates a MongoDB-style query object against a document without hitting the database.
+ *
+ * Supports: equality, $eq, $ne, $gt, $gte, $lt, $lte, $in, $nin, $exists, $and, $or, $not.
+ */
+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 __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchesQuery = void 0;
+// biome-ignore lint/suspicious/noExplicitAny: traversing arbitrary nested document fields by user-supplied dotted path
+var getNestedValue = function (doc, path) {
+    var e_1, _a;
+    var parts = path.split(".");
+    var current = doc;
+    try {
+        for (var parts_1 = __values(parts), parts_1_1 = parts_1.next(); !parts_1_1.done; parts_1_1 = parts_1.next()) {
+            var part = parts_1_1.value;
+            if (current === null || current === undefined) {
+                return undefined;
+            }
+            current = current[part];
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (parts_1_1 && !parts_1_1.done && (_a = parts_1.return)) _a.call(parts_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return current;
+};
+// biome-ignore lint/suspicious/noExplicitAny: value may be any document field type (string, number, ObjectId, etc.)
+var normalize = function (value) {
+    var _a;
+    if (value === null || value === undefined) {
+        return value;
+    }
+    // Handle ObjectId-like objects with toString
+    if (typeof value === "object" &&
+        typeof value.toString === "function" &&
+        ((_a = value.constructor) === null || _a === void 0 ? void 0 : _a.name) !== "Object" &&
+        !Array.isArray(value)) {
+        return value.toString();
+    }
+    return value;
+};
+// biome-ignore lint/suspicious/noExplicitAny: rawValue is an arbitrary document field, condition is an arbitrary user query operand
+var matchesCondition = function (rawValue, condition) {
+    var e_2, _a;
+    var value = normalize(rawValue);
+    // Direct equality (non-object condition)
+    if (condition === null || condition === undefined || typeof condition !== "object") {
+        var normalizedCondition = normalize(condition);
+        return value === normalizedCondition || String(value) === String(normalizedCondition);
+    }
+    // Array equality
+    if (Array.isArray(condition)) {
+        return JSON.stringify(value) === JSON.stringify(condition);
+    }
+    try {
+        // Operator object
+        for (var _b = __values(Object.entries(condition)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var _d = __read(_c.value, 2), op = _d[0], operand = _d[1];
+            var normOp = normalize(operand);
+            switch (op) {
+                case "$eq":
+                    if (value !== normOp && String(value) !== String(normOp)) {
+                        return false;
+                    }
+                    break;
+                case "$ne":
+                    if (value === normOp || String(value) === String(normOp)) {
+                        return false;
+                    }
+                    break;
+                case "$gt":
+                    if (!(value > normOp)) {
+                        return false;
+                    }
+                    break;
+                case "$gte":
+                    if (!(value >= normOp)) {
+                        return false;
+                    }
+                    break;
+                case "$lt":
+                    if (!(value < normOp)) {
+                        return false;
+                    }
+                    break;
+                case "$lte":
+                    if (!(value <= normOp)) {
+                        return false;
+                    }
+                    break;
+                case "$in": {
+                    if (!Array.isArray(operand)) {
+                        return false;
+                    }
+                    var inValues = operand.map(normalize);
+                    // biome-ignore lint/suspicious/noExplicitAny: normalized value of arbitrary document field
+                    if (!inValues.some(function (v) { return v === value || String(v) === String(value); })) {
+                        return false;
+                    }
+                    break;
+                }
+                case "$nin": {
+                    if (!Array.isArray(operand)) {
+                        return false;
+                    }
+                    var ninValues = operand.map(normalize);
+                    // biome-ignore lint/suspicious/noExplicitAny: normalized value of arbitrary document field
+                    if (ninValues.some(function (v) { return v === value || String(v) === String(value); })) {
+                        return false;
+                    }
+                    break;
+                }
+                case "$exists":
+                    if (operand && rawValue === undefined) {
+                        return false;
+                    }
+                    if (!operand && rawValue !== undefined) {
+                        return false;
+                    }
+                    break;
+                case "$not":
+                    if (matchesCondition(rawValue, operand)) {
+                        return false;
+                    }
+                    break;
+                default:
+                    // Unknown operator — fail closed to avoid leaking data
+                    return false;
+            }
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    return true;
+};
+/**
+ * Check if a document matches a MongoDB-style query in memory.
+ *
+ * @param doc - The document to test (plain object or Mongoose document)
+ * @param query - MongoDB-style query object
+ * @returns true if the document matches all query conditions
+ */
+// biome-ignore lint/suspicious/noExplicitAny: doc is arbitrary; query values are arbitrary user-supplied JSON
+var matchesQuery = function (doc, query) {
+    var e_3, _a, e_4, _b, e_5, _c;
+    try {
+        for (var _d = __values(Object.entries(query)), _e = _d.next(); !_e.done; _e = _d.next()) {
+            var _f = __read(_e.value, 2), key = _f[0], condition = _f[1];
+            if (key === "$and") {
+                if (!Array.isArray(condition)) {
+                    return false;
+                }
+                try {
+                    for (var condition_1 = (e_4 = void 0, __values(condition)), condition_1_1 = condition_1.next(); !condition_1_1.done; condition_1_1 = condition_1.next()) {
+                        var subQuery = condition_1_1.value;
+                        if (!(0, exports.matchesQuery)(doc, subQuery)) {
+                            return false;
+                        }
+                    }
+                }
+                catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                finally {
+                    try {
+                        if (condition_1_1 && !condition_1_1.done && (_b = condition_1.return)) _b.call(condition_1);
+                    }
+                    finally { if (e_4) throw e_4.error; }
+                }
+                continue;
+            }
+            if (key === "$or") {
+                if (!Array.isArray(condition)) {
+                    return false;
+                }
+                var matched = false;
+                try {
+                    for (var condition_2 = (e_5 = void 0, __values(condition)), condition_2_1 = condition_2.next(); !condition_2_1.done; condition_2_1 = condition_2.next()) {
+                        var subQuery = condition_2_1.value;
+                        if ((0, exports.matchesQuery)(doc, subQuery)) {
+                            matched = true;
+                            break;
+                        }
+                    }
+                }
+                catch (e_5_1) { e_5 = { error: e_5_1 }; }
+                finally {
+                    try {
+                        if (condition_2_1 && !condition_2_1.done && (_c = condition_2.return)) _c.call(condition_2);
+                    }
+                    finally { if (e_5) throw e_5.error; }
+                }
+                if (!matched) {
+                    return false;
+                }
+                continue;
+            }
+            var value = getNestedValue(doc, key);
+            if (!matchesCondition(value, condition)) {
+                return false;
+            }
+        }
+    }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    finally {
+        try {
+            if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
+        }
+        finally { if (e_3) throw e_3.error; }
+    }
+    return true;
+};
+exports.matchesQuery = matchesQuery;

package/dist/realtime/queryStore.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Manages query subscriptions for Socket.io clients.
+ *
+ * When a client subscribes to a query (e.g., `{completed: false}` on the "todos" collection),
+ * the query is stored here. The change stream watcher consults this store to determine
+ * which query rooms should receive a given change event.
+ */
+/**
+ * Compute a deterministic queryId from collection and query on the server side.
+ * This prevents clients from hijacking other subscriptions by providing a colliding queryId.
+ */
+export declare const computeQueryId: (collection: string, query: Record<string, any>) => string;
+/**
+ * Register a query subscription for a socket.
+ * The socket joins the `query:{queryId}` room (handled by the caller).
+ */
+export declare const addQuerySubscription: (socketId: string, collection: string, query: Record<string, any>, queryId: string) => void;
+/**
+ * Remove a single query subscription for a socket.
+ */
+export declare const removeQuerySubscription: (socketId: string, queryId: string) => void;
+/**
+ * Remove all query subscriptions for a disconnected socket.
+ */
+export declare const removeAllSocketQueries: (socketId: string) => void;
+/**
+ * Get all unique query subscriptions for a given collection.
+ * Used by the change stream watcher to evaluate which query rooms to emit to.
+ */
+export declare const getQuerySubscriptionsForCollection: (collection: string) => {
+    queryId: string;
+    query: Record<string, any>;
+}[];
+/**
+ * Clear all subscriptions (for testing).
+ */
+export declare const clearQueryStore: () => void;

package/dist/realtime/queryStore.js

@@ -0,0 +1,195 @@
+"use strict";
+// biome-ignore-all lint/suspicious/noExplicitAny: query filters are dynamic MongoDB query objects
+/**
+ * Manages query subscriptions for Socket.io clients.
+ *
+ * When a client subscribes to a query (e.g., `{completed: false}` on the "todos" collection),
+ * the query is stored here. The change stream watcher consults this store to determine
+ * which query rooms should receive a given change event.
+ */
+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 __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearQueryStore = exports.getQuerySubscriptionsForCollection = exports.removeAllSocketQueries = exports.removeQuerySubscription = exports.addQuerySubscription = exports.computeQueryId = void 0;
+/**
+ * Compute a deterministic queryId from collection and query on the server side.
+ * This prevents clients from hijacking other subscriptions by providing a colliding queryId.
+ */
+var computeQueryId = function (collection, 
+// biome-ignore lint/suspicious/noExplicitAny: MongoDB query filter values are arbitrary user-supplied JSON
+query) {
+    var e_1, _a;
+    var sortedKeys = Object.keys(query).sort();
+    // biome-ignore lint/suspicious/noExplicitAny: mirrors the input query value shape
+    var normalized = {};
+    try {
+        for (var sortedKeys_1 = __values(sortedKeys), sortedKeys_1_1 = sortedKeys_1.next(); !sortedKeys_1_1.done; sortedKeys_1_1 = sortedKeys_1.next()) {
+            var key = sortedKeys_1_1.value;
+            normalized[key] = query[key];
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (sortedKeys_1_1 && !sortedKeys_1_1.done && (_a = sortedKeys_1.return)) _a.call(sortedKeys_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return "".concat(collection, ":").concat(JSON.stringify(normalized));
+};
+exports.computeQueryId = computeQueryId;
+/** queryId → query subscription details (shared across all sockets in that room) */
+var querySubscriptions = new Map();
+/** socketId → set of queryIds that socket is subscribed to */
+var socketQueries = new Map();
+/**
+ * Register a query subscription for a socket.
+ * The socket joins the `query:{queryId}` room (handled by the caller).
+ */
+var addQuerySubscription = function (socketId, collection, 
+// biome-ignore lint/suspicious/noExplicitAny: MongoDB query filter values are arbitrary user-supplied JSON
+query, queryId) {
+    var _a;
+    querySubscriptions.set(queryId, { collection: collection, query: query, queryId: queryId });
+    if (!socketQueries.has(socketId)) {
+        socketQueries.set(socketId, new Set());
+    }
+    (_a = socketQueries.get(socketId)) === null || _a === void 0 ? void 0 : _a.add(queryId);
+};
+exports.addQuerySubscription = addQuerySubscription;
+/**
+ * Remove a single query subscription for a socket.
+ */
+var removeQuerySubscription = function (socketId, queryId) {
+    var e_2, _a;
+    var _b;
+    (_b = socketQueries.get(socketId)) === null || _b === void 0 ? void 0 : _b.delete(queryId);
+    // Check if any other socket still has this query
+    var stillUsed = false;
+    try {
+        for (var socketQueries_1 = __values(socketQueries), socketQueries_1_1 = socketQueries_1.next(); !socketQueries_1_1.done; socketQueries_1_1 = socketQueries_1.next()) {
+            var _c = __read(socketQueries_1_1.value, 2), queryIds = _c[1];
+            if (queryIds.has(queryId)) {
+                stillUsed = true;
+                break;
+            }
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (socketQueries_1_1 && !socketQueries_1_1.done && (_a = socketQueries_1.return)) _a.call(socketQueries_1);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    if (!stillUsed) {
+        querySubscriptions.delete(queryId);
+    }
+};
+exports.removeQuerySubscription = removeQuerySubscription;
+/**
+ * Remove all query subscriptions for a disconnected socket.
+ */
+var removeAllSocketQueries = function (socketId) {
+    var e_3, _a, e_4, _b;
+    var queryIds = socketQueries.get(socketId);
+    if (!queryIds) {
+        return;
+    }
+    socketQueries.delete(socketId);
+    try {
+        // Clean up any queries that no longer have subscribers
+        for (var queryIds_1 = __values(queryIds), queryIds_1_1 = queryIds_1.next(); !queryIds_1_1.done; queryIds_1_1 = queryIds_1.next()) {
+            var queryId = queryIds_1_1.value;
+            var stillUsed = false;
+            try {
+                for (var socketQueries_2 = (e_4 = void 0, __values(socketQueries)), socketQueries_2_1 = socketQueries_2.next(); !socketQueries_2_1.done; socketQueries_2_1 = socketQueries_2.next()) {
+                    var _c = __read(socketQueries_2_1.value, 2), otherQueryIds = _c[1];
+                    if (otherQueryIds.has(queryId)) {
+                        stillUsed = true;
+                        break;
+                    }
+                }
+            }
+            catch (e_4_1) { e_4 = { error: e_4_1 }; }
+            finally {
+                try {
+                    if (socketQueries_2_1 && !socketQueries_2_1.done && (_b = socketQueries_2.return)) _b.call(socketQueries_2);
+                }
+                finally { if (e_4) throw e_4.error; }
+            }
+            if (!stillUsed) {
+                querySubscriptions.delete(queryId);
+            }
+        }
+    }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    finally {
+        try {
+            if (queryIds_1_1 && !queryIds_1_1.done && (_a = queryIds_1.return)) _a.call(queryIds_1);
+        }
+        finally { if (e_3) throw e_3.error; }
+    }
+};
+exports.removeAllSocketQueries = removeAllSocketQueries;
+/**
+ * Get all unique query subscriptions for a given collection.
+ * Used by the change stream watcher to evaluate which query rooms to emit to.
+ */
+var getQuerySubscriptionsForCollection = function (collection
+// biome-ignore lint/suspicious/noExplicitAny: MongoDB query filter values are arbitrary user-supplied JSON
+) {
+    var e_5, _a;
+    // biome-ignore lint/suspicious/noExplicitAny: MongoDB query filter values are arbitrary user-supplied JSON
+    var result = [];
+    try {
+        for (var querySubscriptions_1 = __values(querySubscriptions), querySubscriptions_1_1 = querySubscriptions_1.next(); !querySubscriptions_1_1.done; querySubscriptions_1_1 = querySubscriptions_1.next()) {
+            var _b = __read(querySubscriptions_1_1.value, 2), queryId = _b[0], sub = _b[1];
+            if (sub.collection === collection) {
+                result.push({ query: sub.query, queryId: queryId });
+            }
+        }
+    }
+    catch (e_5_1) { e_5 = { error: e_5_1 }; }
+    finally {
+        try {
+            if (querySubscriptions_1_1 && !querySubscriptions_1_1.done && (_a = querySubscriptions_1.return)) _a.call(querySubscriptions_1);
+        }
+        finally { if (e_5) throw e_5.error; }
+    }
+    return result;
+};
+exports.getQuerySubscriptionsForCollection = getQuerySubscriptionsForCollection;
+/**
+ * Clear all subscriptions (for testing).
+ */
+var clearQueryStore = function () {
+    querySubscriptions.clear();
+    socketQueries.clear();
+};
+exports.clearQueryStore = clearQueryStore;

package/dist/realtime/realtime.test.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Tests for the realtime module's pure functions and classes:
+ *   - queryMatcher.ts (matchesQuery)
+ *   - queryStore.ts (addQuerySubscription, removeQuerySubscription, etc.)
+ *   - registry.ts (registerRealtime, getRealtimeRegistry, etc.)
+ *   - realtimeApp.ts (RealtimeApp class — register, getIo, close)
+ *   - realtimeApp.ts (installRealtimeSocketHandlers — permission and rate-limit logic)
+ *   - changeStreamWatcher.ts (serializeDoc — responseHandler fallback)
+ */
+export {};