@signe/room 2.9.4 → 3.0.0

package/dist/node/index.js

@@ -0,0 +1,786 @@
+import "../chunk-EUXUH3YW.js";
+
+// src/node/index.ts
+import { EventEmitter } from "node:events";
+import { createRequire } from "node:module";
+var DEFAULT_PARTIES_PATH = "/parties/main";
+var WEBSOCKET_OPEN = 1;
+var DEFAULT_SQLITE_BUSY_TIMEOUT_MS = 5e3;
+var DEFAULT_SQLITE_BUSY_RETRIES = 3;
+var SQLITE_RETRY_BASE_DELAY_MS = 25;
+function createMemoryNodeRoomStorage(options = {}) {
+  return new MemoryNodeRoomStorage(options);
+}
+function createSqliteNodeRoomStorage(options) {
+  return new SqliteNodeRoomStorage(options);
+}
+function createNodeRoomTransport(ServerClass, options = {}) {
+  return new NodeRoomTransport(ServerClass, options);
+}
+var MemoryNodeRoomStorage = class {
+  constructor(options = {}) {
+    this.rooms = /* @__PURE__ */ new Map();
+    if (options.snapshot) {
+      this.restore(options.snapshot);
+    }
+  }
+  getStorage(namespace, roomId) {
+    const key = getStorageKey(namespace, roomId);
+    let memory = this.rooms.get(key);
+    if (!memory) {
+      memory = /* @__PURE__ */ new Map();
+      this.rooms.set(key, memory);
+    }
+    return new MemoryNodeRoomStorageInstance(memory);
+  }
+  snapshot() {
+    const snapshot = {};
+    for (const [roomKey, memory] of this.rooms) {
+      if (memory.size === 0) {
+        continue;
+      }
+      snapshot[roomKey] = Array.from(memory.entries()).map(([key, value]) => [
+        key,
+        cloneStorageValue(value)
+      ]);
+    }
+    return snapshot;
+  }
+  restore(snapshot) {
+    this.clear();
+    for (const [roomKey, entries] of Object.entries(snapshot)) {
+      this.rooms.set(
+        roomKey,
+        new Map(entries.map(([key, value]) => [key, cloneStorageValue(value)]))
+      );
+    }
+  }
+  clear() {
+    this.rooms.clear();
+  }
+};
+var MemoryNodeRoomStorageInstance = class {
+  constructor(memory) {
+    this.memory = memory;
+  }
+  async put(keyOrEntries, value) {
+    if (typeof keyOrEntries === "string") {
+      this.memory.set(keyOrEntries, value);
+      return;
+    }
+    for (const [key, entryValue] of Object.entries(keyOrEntries)) {
+      this.memory.set(key, entryValue);
+    }
+  }
+  async get(key) {
+    return this.memory.get(key);
+  }
+  async delete(keyOrKeys) {
+    if (Array.isArray(keyOrKeys)) {
+      let deleted = 0;
+      for (const key of keyOrKeys) {
+        if (this.memory.delete(key)) {
+          deleted += 1;
+        }
+      }
+      return deleted;
+    }
+    return this.memory.delete(keyOrKeys);
+  }
+  async list(options = {}) {
+    let entries = Array.from(this.memory.entries());
+    if (options.prefix !== void 0) {
+      entries = entries.filter(([key]) => key.startsWith(options.prefix));
+    }
+    if (options.start !== void 0) {
+      entries = entries.filter(([key]) => key >= options.start);
+    }
+    if (options.startAfter !== void 0) {
+      entries = entries.filter(([key]) => key > options.startAfter);
+    }
+    if (options.end !== void 0) {
+      entries = entries.filter(([key]) => key < options.end);
+    }
+    entries.sort(([a], [b]) => a.localeCompare(b));
+    if (options.reverse) {
+      entries.reverse();
+    }
+    if (options.limit !== void 0) {
+      entries = entries.slice(0, options.limit);
+    }
+    return new Map(entries);
+  }
+};
+var SqliteNodeRoomStorage = class {
+  constructor(options) {
+    this.options = options;
+    this.configured = false;
+    if (!options.database && !options.databasePath) {
+      throw new Error("createSqliteNodeRoomStorage requires `database` or `databasePath`.");
+    }
+    this.tableName = options.tableName ?? "signe_room_storage";
+    assertSafeSqlIdentifier(this.tableName);
+  }
+  async getStorage(namespace, roomId) {
+    const database = await this.getDatabase();
+    await this.ensureConfigured(database);
+    return new SqliteNodeRoomStorageInstance(
+      database,
+      this.tableName,
+      namespace,
+      roomId,
+      this.options.busyRetries ?? DEFAULT_SQLITE_BUSY_RETRIES
+    );
+  }
+  async getDatabase() {
+    if (!this.databasePromise) {
+      this.databasePromise = this.createDatabase();
+    }
+    return this.databasePromise;
+  }
+  async createDatabase() {
+    if (this.options.database) {
+      return this.options.database;
+    }
+    const sqliteModule = loadNodeSqliteModule();
+    const { DatabaseSync } = sqliteModule;
+    return new DatabaseSync(this.options.databasePath);
+  }
+  async ensureConfigured(database) {
+    if (this.configured) {
+      return;
+    }
+    const busyTimeoutMs = normalizeSqliteTimeout(
+      this.options.busyTimeoutMs ?? DEFAULT_SQLITE_BUSY_TIMEOUT_MS
+    );
+    const journalMode = normalizeSqliteJournalMode(this.options.journalMode ?? "WAL");
+    runSqliteOperation(
+      () => {
+        database.exec(`PRAGMA busy_timeout = ${busyTimeoutMs}`);
+        database.exec(`PRAGMA journal_mode = ${journalMode}`);
+        database.exec(`
+          CREATE TABLE IF NOT EXISTS ${this.tableName} (
+            namespace TEXT NOT NULL,
+            room_id TEXT NOT NULL,
+            key TEXT NOT NULL,
+            value TEXT NOT NULL,
+            PRIMARY KEY (namespace, room_id, key)
+          )
+        `);
+      },
+      this.options.busyRetries ?? DEFAULT_SQLITE_BUSY_RETRIES
+    );
+    this.configured = true;
+  }
+};
+var SqliteNodeRoomStorageInstance = class {
+  constructor(database, tableName, namespace, roomId, busyRetries) {
+    this.database = database;
+    this.tableName = tableName;
+    this.namespace = namespace;
+    this.roomId = roomId;
+    this.busyRetries = busyRetries;
+  }
+  async get(key) {
+    const row = runSqliteOperation(
+      () => this.database.prepare(`
+          SELECT value
+          FROM ${this.tableName}
+          WHERE namespace = ? AND room_id = ? AND key = ?
+        `).get(this.namespace, this.roomId, key),
+      this.busyRetries
+    );
+    return row ? JSON.parse(row.value) : void 0;
+  }
+  async put(keyOrEntries, value) {
+    const entries = typeof keyOrEntries === "string" ? [[keyOrEntries, value]] : Object.entries(keyOrEntries);
+    runSqliteOperation(
+      () => {
+        const statement = this.database.prepare(`
+          INSERT INTO ${this.tableName} (namespace, room_id, key, value)
+          VALUES (?, ?, ?, ?)
+          ON CONFLICT(namespace, room_id, key) DO UPDATE SET value = excluded.value
+        `);
+        for (const [key, entryValue] of entries) {
+          statement.run(this.namespace, this.roomId, key, JSON.stringify(entryValue));
+        }
+      },
+      this.busyRetries
+    );
+  }
+  async delete(keyOrKeys) {
+    if (Array.isArray(keyOrKeys)) {
+      if (keyOrKeys.length === 0) {
+        return 0;
+      }
+      const result2 = runSqliteOperation(
+        () => this.database.prepare(`
+            DELETE FROM ${this.tableName}
+            WHERE namespace = ? AND room_id = ? AND key IN (${keyOrKeys.map(() => "?").join(", ")})
+          `).run(this.namespace, this.roomId, ...keyOrKeys),
+        this.busyRetries
+      );
+      return Number(result2.changes);
+    }
+    const result = runSqliteOperation(
+      () => this.database.prepare(`
+          DELETE FROM ${this.tableName}
+          WHERE namespace = ? AND room_id = ? AND key = ?
+        `).run(this.namespace, this.roomId, keyOrKeys),
+      this.busyRetries
+    );
+    return Number(result.changes) > 0;
+  }
+  async list(options = {}) {
+    const conditions = ["namespace = ?", "room_id = ?"];
+    const params = [this.namespace, this.roomId];
+    if (options.prefix !== void 0) {
+      conditions.push("key >= ?", "key < ?");
+      params.push(options.prefix, getPrefixEnd(options.prefix));
+    }
+    if (options.start !== void 0) {
+      conditions.push("key >= ?");
+      params.push(options.start);
+    }
+    if (options.startAfter !== void 0) {
+      conditions.push("key > ?");
+      params.push(options.startAfter);
+    }
+    if (options.end !== void 0) {
+      conditions.push("key < ?");
+      params.push(options.end);
+    }
+    const limit = options.limit !== void 0 ? normalizeSqliteLimit(options.limit) : void 0;
+    const rows = runSqliteOperation(
+      () => this.database.prepare(`
+          SELECT key, value
+          FROM ${this.tableName}
+          WHERE ${conditions.join(" AND ")}
+          ORDER BY key ${options.reverse ? "DESC" : "ASC"}
+          ${limit !== void 0 ? `LIMIT ${limit}` : ""}
+        `).all(...params),
+      this.busyRetries
+    );
+    return new Map(rows.map((row) => [row.key, JSON.parse(row.value)]));
+  }
+};
+var NodeRoomTransport = class {
+  constructor(ServerClass, options = {}) {
+    this.ServerClass = ServerClass;
+    this.records = /* @__PURE__ */ new Map();
+    this.partiesPath = normalizePath(options.partiesPath ?? DEFAULT_PARTIES_PATH);
+    this.env = options.env ?? {};
+    this.rooms = {
+      main: ServerClass,
+      ...options.rooms ?? {}
+    };
+    this.storage = options.storage ?? createMemoryNodeRoomStorage();
+    this.externalParties = options.externalParties ?? {};
+  }
+  async fetch(pathOrRequest, init) {
+    const request = typeof pathOrRequest === "string" ? new Request(toLocalUrl(pathOrRequest), init) : pathOrRequest;
+    const parsed = this.parsePartyRequest(request.url);
+    if (!parsed) {
+      return new Response("Not Found", { status: 404 });
+    }
+    const record = await this.getRecord(parsed.namespace, parsed.roomId);
+    return record.server.onRequest?.(request) ?? new Response("Not Found", { status: 404 });
+  }
+  async handleNodeRequest(req, res, next) {
+    const url = getRequestUrl(req);
+    if (!this.parsePartyRequest(url)) {
+      if (next) {
+        next();
+        return;
+      }
+      await writeNodeResponse(res, new Response("Not Found", { status: 404 }));
+      return;
+    }
+    try {
+      const request = await createWebRequest(req, url);
+      const response = await this.fetch(request);
+      await writeNodeResponse(res, response);
+    } catch (error) {
+      if (next) {
+        next(error);
+        return;
+      }
+      await writeNodeResponse(res, new Response("Internal Server Error", { status: 500 }));
+    }
+  }
+  handleUpgrade(wsServer, request, socket, head) {
+    const parsed = this.parsePartyRequest(getRequestUrl(request));
+    if (!parsed) {
+      socket.destroy();
+      return;
+    }
+    wsServer.handleUpgrade(request, socket, head, (webSocket) => {
+      void this.acceptWebSocket(webSocket, request, parsed).catch(() => {
+        webSocket.close(1011, "Unable to start room connection");
+      });
+      wsServer.emit?.("connection", webSocket, request);
+    });
+  }
+  async acceptWebSocket(webSocket, request, parsedPath) {
+    const url = request instanceof Request ? request.url : getRequestUrl(request);
+    const parsed = parsedPath ?? this.parsePartyRequest(url);
+    if (!parsed) {
+      webSocket.close(1008, "Invalid room path");
+      throw new Error(`Unable to route WebSocket URL: ${url}`);
+    }
+    const record = await this.getRecord(parsed.namespace, parsed.roomId);
+    const connection = new NodeConnection(webSocket, url, getConnectionIdFromUrl(url));
+    const connectRequest = request instanceof Request ? request : await createWebRequest(request, url, false);
+    await record.server.onConnect?.(connection, {
+      request: connectRequest
+    });
+    const onMessage = (data) => {
+      void record.server.onMessage?.(normalizeWebSocketMessage(data), connection);
+    };
+    const onClose = () => {
+      record.room.deleteConnection(connection.id, connection);
+      void record.server.onClose?.(connection);
+    };
+    const onError = (error) => {
+      void record.server.onError?.(connection, error);
+    };
+    webSocket.on("message", onMessage);
+    webSocket.on("close", onClose);
+    webSocket.on("error", onError);
+    record.room.addConnection(connection);
+    return connection;
+  }
+  getRoom(namespace, roomId) {
+    return this.getRecord(namespace, roomId).then((record) => record.room);
+  }
+  getNamespacePath(namespace, roomId) {
+    const baseSegments = trimSlashes(this.getPartiesBase()).split("/").slice(0, -1);
+    return `/${[...baseSegments, namespace, encodeURIComponent(roomId)].join("/")}`;
+  }
+  async getRecord(namespace, roomId) {
+    const key = `${namespace}:${roomId}`;
+    const existing = this.records.get(key);
+    if (existing) {
+      return existing;
+    }
+    const recordPromise = this.createRecord(namespace, roomId);
+    this.records.set(key, recordPromise);
+    try {
+      return await recordPromise;
+    } catch (error) {
+      this.records.delete(key);
+      throw error;
+    }
+  }
+  async createRecord(namespace, roomId) {
+    const ServerClass = this.rooms[namespace] ?? this.ServerClass;
+    const room = new NodeRoom({
+      id: roomId,
+      name: namespace,
+      env: this.env,
+      storage: await this.resolveStorage(namespace, roomId),
+      transport: this
+    });
+    const server = new ServerClass(room);
+    const record = {
+      room,
+      server,
+      started: Promise.resolve(server.onStart?.()).then(() => void 0)
+    };
+    await record.started;
+    return record;
+  }
+  async resolveStorage(namespace, roomId) {
+    if (typeof this.storage === "function") {
+      return this.storage(namespace, roomId);
+    }
+    return this.storage.getStorage(namespace, roomId);
+  }
+  parsePartyRequest(url) {
+    const requestUrl = new URL(url, "http://localhost");
+    const partiesBase = this.getPartiesBase();
+    const segments = trimSlashes(requestUrl.pathname).split("/");
+    const configuredSegments = trimSlashes(partiesBase).split("/");
+    const baseSegments = configuredSegments.slice(0, -1);
+    if (segments.length < baseSegments.length + 2) {
+      return null;
+    }
+    for (let index = 0; index < baseSegments.length; index++) {
+      if (segments[index] !== baseSegments[index]) {
+        return null;
+      }
+    }
+    const namespace = decodeURIComponent(segments[baseSegments.length]);
+    const roomId = decodeURIComponent(segments[baseSegments.length + 1]);
+    const rest = segments.slice(baseSegments.length + 2).join("/");
+    return {
+      namespace,
+      roomId,
+      restPath: rest ? `/${rest}` : "/"
+    };
+  }
+  getPartiesBase() {
+    return this.partiesPath;
+  }
+};
+var NodeRoom = class {
+  constructor(options) {
+    this.connections = /* @__PURE__ */ new Map();
+    this.analytics = {};
+    this.id = options.id;
+    this.internalID = `${options.name}:${options.id}`;
+    this.name = options.name;
+    this.env = options.env;
+    this.storage = options.storage;
+    this.parties = createPartiesContext(options.transport);
+    this.context = {
+      parties: this.parties,
+      ai: {},
+      vectorize: {},
+      analytics: this.analytics,
+      assets: {
+        fetch: async () => null
+      },
+      bindings: {
+        r2: {},
+        kv: {}
+      }
+    };
+  }
+  blockConcurrencyWhile(callback) {
+    return callback();
+  }
+  broadcast(msg, without = []) {
+    for (const connection of this.connections.values()) {
+      if (!without.includes(connection.id)) {
+        connection.send(msg);
+      }
+    }
+  }
+  getConnection(id) {
+    let connection;
+    for (const current of this.connections.values()) {
+      if (current.id === id || current.sessionId === id) {
+        connection = current;
+      }
+    }
+    return connection;
+  }
+  getConnections() {
+    return Array.from(this.connections.values());
+  }
+  addConnection(connection) {
+    this.connections.set(connection.id, connection);
+  }
+  deleteConnection(id, connection) {
+    if (connection) {
+      this.connections.delete(connection.id);
+      return;
+    }
+    for (const [connectionKey, current] of this.connections) {
+      if (current.id === id || current.sessionId === id) {
+        this.connections.delete(connectionKey);
+      }
+    }
+  }
+};
+var NodeConnection = class {
+  constructor(webSocket, uri, sessionId) {
+    this.webSocket = webSocket;
+    this.id = createConnectionId();
+    this.socket = this;
+    this.state = null;
+    this.attachment = null;
+    this.sessionId = sessionId || this.id;
+    this.uri = uri;
+  }
+  send(data) {
+    if (this.webSocket.readyState === void 0 || this.webSocket.readyState === WEBSOCKET_OPEN) {
+      this.webSocket.send(data);
+    }
+  }
+  close(code, reason) {
+    this.webSocket.close(code, reason);
+  }
+  setState(state) {
+    this.state = typeof state === "function" ? state(this.state) : state;
+    return this.state;
+  }
+  serializeAttachment(attachment) {
+    this.attachment = attachment;
+  }
+  deserializeAttachment() {
+    return this.attachment;
+  }
+};
+function createPartiesContext(transport) {
+  return new Proxy({}, {
+    get(_target, namespace) {
+      const externalNamespace = transport.externalParties[namespace];
+      if (externalNamespace) {
+        return externalNamespace;
+      }
+      return {
+        get(roomId) {
+          return {
+            connect: () => {
+              throw new Error("Party stub connect() is not implemented by @signe/room/node");
+            },
+            async socket(pathOrInit, init) {
+              const path = typeof pathOrInit === "string" ? pathOrInit : "/";
+              const requestInit = typeof pathOrInit === "string" ? init : pathOrInit;
+              const request = new Request(
+                toLocalUrl(`${transport.getNamespacePath(namespace, roomId)}${normalizeStubPath(path)}`),
+                requestInit
+              );
+              const pair = createInMemoryWebSocketPair();
+              void transport.acceptWebSocket(pair.server, request).catch(() => {
+                pair.client.close(1011, "Unable to start room connection");
+              });
+              return pair.client;
+            },
+            fetch(pathOrInit, init) {
+              const path = typeof pathOrInit === "string" ? pathOrInit : "/";
+              const requestInit = typeof pathOrInit === "string" ? init : pathOrInit;
+              return transport.fetch(`${transport.getNamespacePath(namespace, roomId)}${normalizeStubPath(path)}`, requestInit);
+            }
+          };
+        }
+      };
+    }
+  });
+}
+function createInMemoryWebSocketPair() {
+  const client = new InMemoryWebSocket();
+  const server = new InMemoryWebSocket();
+  client.setPeer(server);
+  server.setPeer(client);
+  return { client, server };
+}
+var InMemoryWebSocket = class {
+  constructor() {
+    this.readyState = WEBSOCKET_OPEN;
+    this.emitter = new EventEmitter();
+  }
+  setPeer(peer) {
+    this.peer = peer;
+  }
+  send(data, cb) {
+    if (this.readyState !== WEBSOCKET_OPEN || this.peer?.readyState !== WEBSOCKET_OPEN) {
+      cb?.(new Error("WebSocket is not open"));
+      return;
+    }
+    queueMicrotask(() => {
+      this.peer?.emitMessage(data);
+      cb?.();
+    });
+  }
+  close(code, reason) {
+    if (this.readyState !== WEBSOCKET_OPEN) {
+      return;
+    }
+    this.readyState = 3;
+    this.emitter.emit("close", code, reason);
+    if (this.peer?.readyState === WEBSOCKET_OPEN) {
+      this.peer.readyState = 3;
+      this.peer.emitter.emit("close", code, reason);
+    }
+  }
+  on(event, listener) {
+    this.emitter.on(event, listener);
+    return this;
+  }
+  off(event, listener) {
+    this.emitter.off(event, listener);
+    return this;
+  }
+  removeListener(event, listener) {
+    this.emitter.removeListener(event, listener);
+    return this;
+  }
+  addEventListener(type, listener) {
+    if (type === "message") {
+      this.on("message", (data) => listener({ data }));
+      return;
+    }
+    this.on(type, (event) => listener(event));
+  }
+  emitMessage(data) {
+    if (this.readyState === WEBSOCKET_OPEN) {
+      this.emitter.emit("message", data);
+    }
+  }
+};
+async function createWebRequest(req, url, includeBody = true) {
+  const headers = new Headers();
+  for (const [key, value] of Object.entries(req.headers)) {
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        headers.append(key, item);
+      }
+    } else if (value !== void 0) {
+      headers.set(key, String(value));
+    }
+  }
+  const method = req.method ?? "GET";
+  const hasBody = includeBody && !["GET", "HEAD"].includes(method);
+  const body = hasBody ? await readIncomingBody(req) : void 0;
+  return new Request(url, {
+    method,
+    headers,
+    body
+  });
+}
+async function readIncomingBody(req) {
+  const chunks = [];
+  for await (const chunk of req) {
+    if (typeof chunk === "string") {
+      chunks.push(new TextEncoder().encode(chunk));
+    } else {
+      chunks.push(chunk);
+    }
+  }
+  const size = chunks.reduce((total, chunk) => total + chunk.byteLength, 0);
+  const body = new Uint8Array(size);
+  let offset = 0;
+  for (const chunk of chunks) {
+    body.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return body;
+}
+async function writeNodeResponse(res, response) {
+  res.statusCode = response.status;
+  response.headers.forEach((value, key) => {
+    res.setHeader(key, value);
+  });
+  const body = new Uint8Array(await response.arrayBuffer());
+  res.end(body);
+}
+function getRequestUrl(req) {
+  const protocol = req.headers["x-forwarded-proto"] ?? "http";
+  const host = req.headers.host ?? "localhost";
+  return `${protocol}://${host}${req.url ?? "/"}`;
+}
+function normalizeWebSocketMessage(data) {
+  if (typeof data === "string") {
+    return data;
+  }
+  if (data instanceof ArrayBuffer) {
+    return new TextDecoder().decode(data);
+  }
+  if (ArrayBuffer.isView(data)) {
+    return new TextDecoder().decode(data);
+  }
+  return String(data);
+}
+function normalizePath(path) {
+  return `/${trimSlashes(path)}`;
+}
+function normalizeStubPath(path) {
+  if (!path || path === "/") {
+    return "";
+  }
+  return path.startsWith("/") ? path : `/${path}`;
+}
+function toLocalUrl(path) {
+  return path.startsWith("http://") || path.startsWith("https://") ? path : `http://localhost${path.startsWith("/") ? path : `/${path}`}`;
+}
+function getConnectionIdFromUrl(url) {
+  const requestedId = new URL(url).searchParams.get("id")?.trim();
+  return requestedId || void 0;
+}
+function trimSlashes(value) {
+  return value.replace(/^\/+|\/+$/g, "");
+}
+function getStorageKey(namespace, roomId) {
+  return `${encodeURIComponent(namespace)}:${encodeURIComponent(roomId)}`;
+}
+function assertSafeSqlIdentifier(identifier) {
+  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(identifier)) {
+    throw new Error(`Invalid SQLite table name: ${identifier}`);
+  }
+}
+function getPrefixEnd(prefix) {
+  return `${prefix}\uFFFF`;
+}
+function normalizeSqliteLimit(value) {
+  if (!Number.isFinite(value) || value < 0) {
+    return 0;
+  }
+  return Math.floor(value);
+}
+function normalizeSqliteTimeout(value) {
+  if (!Number.isFinite(value) || value < 0) {
+    return DEFAULT_SQLITE_BUSY_TIMEOUT_MS;
+  }
+  return Math.floor(value);
+}
+function normalizeSqliteJournalMode(value) {
+  const journalMode = value.toUpperCase();
+  const allowedModes = /* @__PURE__ */ new Set([
+    "DELETE",
+    "TRUNCATE",
+    "PERSIST",
+    "MEMORY",
+    "WAL",
+    "OFF"
+  ]);
+  if (!allowedModes.has(journalMode)) {
+    throw new Error(`Invalid SQLite journal mode: ${value}`);
+  }
+  return journalMode;
+}
+function runSqliteOperation(operation, retries) {
+  const maxRetries = Math.max(0, Math.floor(retries));
+  for (let attempt = 0; ; attempt += 1) {
+    try {
+      return operation();
+    } catch (error) {
+      if (!isSqliteBusyError(error) || attempt >= maxRetries) {
+        throw error;
+      }
+      sleepSync(Math.min(250, SQLITE_RETRY_BASE_DELAY_MS * 2 ** attempt));
+    }
+  }
+}
+function isSqliteBusyError(error) {
+  if (!error || typeof error !== "object") {
+    return false;
+  }
+  const err = error;
+  return err.errcode === 5 || err.errcode === 6 || err.errstr === "database is locked" || err.errstr === "database table is locked" || err.code === "SQLITE_BUSY" || err.code === "SQLITE_LOCKED" || err.message?.includes("database is locked") || err.message?.includes("database table is locked");
+}
+function sleepSync(ms) {
+  const buffer = new SharedArrayBuffer(4);
+  const view = new Int32Array(buffer);
+  Atomics.wait(view, 0, 0, ms);
+}
+function loadNodeSqliteModule() {
+  const require2 = createRequire(`${process.cwd()}/package.json`);
+  return require2("node:sqlite");
+}
+function cloneStorageValue(value) {
+  if (typeof structuredClone === "function") {
+    try {
+      return structuredClone(value);
+    } catch {
+      return value;
+    }
+  }
+  return value;
+}
+function createConnectionId() {
+  return Math.random().toString(36).slice(2, 12);
+}
+export {
+  MemoryNodeRoomStorage,
+  NodeConnection,
+  NodeRoom,
+  NodeRoomTransport,
+  SqliteNodeRoomStorage,
+  createMemoryNodeRoomStorage,
+  createNodeRoomTransport,
+  createSqliteNodeRoomStorage
+};
+//# sourceMappingURL=index.js.map