@signe/room 2.10.0 → 3.0.0

package/src/node/index.ts

@@ -0,0 +1,1112 @@
+import type { IncomingMessage, ServerResponse as NodeServerResponse } from "node:http";
+import { EventEmitter } from "node:events";
+import { createRequire } from "node:module";
+import type { Duplex } from "node:stream";
+import type * as Party from "../types/party";
+
+export type NodeRoomStorage = {
+  get<T = unknown>(key: string): Promise<T | undefined>;
+  put<T = unknown>(key: string, value: T): Promise<void>;
+  put<T = unknown>(entries: Record<string, T>): Promise<void>;
+  delete(key: string | string[]): Promise<void | boolean | number>;
+  list<T = unknown>(options?: NodeRoomStorageListOptions): Promise<Map<string, T>>;
+};
+
+export type NodeRoomStorageListOptions = {
+  prefix?: string;
+  start?: string;
+  startAfter?: string;
+  end?: string;
+  reverse?: boolean;
+  limit?: number;
+};
+
+export type NodeRoomStorageFactory = (
+  namespace: string,
+  roomId: string
+) => NodeRoomStorage | Promise<NodeRoomStorage>;
+
+export type NodeRoomStorageProvider = {
+  getStorage(namespace: string, roomId: string): NodeRoomStorage | Promise<NodeRoomStorage>;
+};
+
+export type NodeMemoryStorageSnapshot = Record<string, [string, unknown][]>;
+
+export type NodeSqliteDatabase = {
+  exec(sql: string): unknown;
+  prepare(sql: string): {
+    get(...params: unknown[]): unknown;
+    run(...params: unknown[]): { changes: number | bigint };
+    all(...params: unknown[]): unknown[];
+  };
+};
+
+export type NodeSqliteStorageOptions = {
+  database?: NodeSqliteDatabase;
+  databasePath?: string;
+  tableName?: string;
+  busyTimeoutMs?: number;
+  journalMode?: NodeSqliteJournalMode;
+  busyRetries?: number;
+};
+
+export type NodeSqliteJournalMode =
+  | "DELETE"
+  | "TRUNCATE"
+  | "PERSIST"
+  | "MEMORY"
+  | "WAL"
+  | "OFF"
+  | "delete"
+  | "truncate"
+  | "persist"
+  | "memory"
+  | "wal"
+  | "off";
+
+export type NodeServerConstructor<TServer extends Party.Server = Party.Server> = {
+  new (room: Party.Room): TServer;
+};
+
+export type NodeRoomTransportOptions = {
+  partiesPath?: string;
+  env?: Record<string, unknown>;
+  storage?: NodeRoomStorageFactory | NodeRoomStorageProvider;
+  rooms?: Record<string, NodeServerConstructor>;
+  externalParties?: Record<string, {
+    get(id: string): Partial<Party.Stub>;
+  }>;
+};
+
+export type NodeRequestNext = (error?: unknown) => void;
+
+export type NodeWebSocketLike = {
+  readyState?: number;
+  send(data: string | ArrayBuffer | ArrayBufferView, cb?: (error?: Error) => void): void;
+  close(code?: number, reason?: string | Buffer): void;
+  on(event: string, listener: (...args: any[]) => void): unknown;
+  off?(event: string, listener: (...args: any[]) => void): unknown;
+  removeListener?(event: string, listener: (...args: any[]) => void): unknown;
+};
+
+export type NodeWebSocketServerLike = {
+  handleUpgrade(
+    request: IncomingMessage,
+    socket: Duplex,
+    head: Buffer,
+    cb: (webSocket: NodeWebSocketLike) => void
+  ): void;
+  emit?(event: "connection", webSocket: NodeWebSocketLike, request: IncomingMessage): boolean;
+};
+
+type RoomRecord = {
+  room: NodeRoom;
+  server: Party.Server;
+  started: Promise<void>;
+};
+
+type ParsedPartyPath = {
+  namespace: string;
+  roomId: string;
+  restPath: string;
+};
+
+const DEFAULT_PARTIES_PATH = "/parties/main";
+const WEBSOCKET_OPEN = 1;
+const DEFAULT_SQLITE_BUSY_TIMEOUT_MS = 5000;
+const DEFAULT_SQLITE_BUSY_RETRIES = 3;
+const SQLITE_RETRY_BASE_DELAY_MS = 25;
+
+export function createMemoryNodeRoomStorage(options: {
+  snapshot?: NodeMemoryStorageSnapshot;
+} = {}) {
+  return new MemoryNodeRoomStorage(options);
+}
+
+export function createSqliteNodeRoomStorage(options: NodeSqliteStorageOptions) {
+  return new SqliteNodeRoomStorage(options);
+}
+
+export function createNodeRoomTransport<TServer extends Party.Server>(
+  ServerClass: NodeServerConstructor<TServer>,
+  options: NodeRoomTransportOptions = {}
+) {
+  return new NodeRoomTransport(ServerClass, options);
+}
+
+export class MemoryNodeRoomStorage implements NodeRoomStorageProvider {
+  private readonly rooms = new Map<string, Map<string, unknown>>();
+
+  constructor(options: { snapshot?: NodeMemoryStorageSnapshot } = {}) {
+    if (options.snapshot) {
+      this.restore(options.snapshot);
+    }
+  }
+
+  getStorage(namespace: string, roomId: string): NodeRoomStorage {
+    const key = getStorageKey(namespace, roomId);
+    let memory = this.rooms.get(key);
+
+    if (!memory) {
+      memory = new Map();
+      this.rooms.set(key, memory);
+    }
+
+    return new MemoryNodeRoomStorageInstance(memory);
+  }
+
+  snapshot(): NodeMemoryStorageSnapshot {
+    const snapshot: NodeMemoryStorageSnapshot = {};
+
+    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: NodeMemoryStorageSnapshot) {
+    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();
+  }
+}
+
+class MemoryNodeRoomStorageInstance implements NodeRoomStorage {
+  constructor(private readonly memory: Map<string, unknown>) {}
+
+  async put<T = unknown>(keyOrEntries: string | Record<string, T>, value?: T) {
+    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<T = unknown>(key: string) {
+    return this.memory.get(key) as T | undefined;
+  }
+
+  async delete(keyOrKeys: string | string[]) {
+    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<T = unknown>(options: NodeRoomStorageListOptions = {}) {
+    let entries = Array.from(this.memory.entries());
+
+    if (options.prefix !== undefined) {
+      entries = entries.filter(([key]) => key.startsWith(options.prefix!));
+    }
+    if (options.start !== undefined) {
+      entries = entries.filter(([key]) => key >= options.start!);
+    }
+    if (options.startAfter !== undefined) {
+      entries = entries.filter(([key]) => key > options.startAfter!);
+    }
+    if (options.end !== undefined) {
+      entries = entries.filter(([key]) => key < options.end!);
+    }
+
+    entries.sort(([a], [b]) => a.localeCompare(b));
+    if (options.reverse) {
+      entries.reverse();
+    }
+    if (options.limit !== undefined) {
+      entries = entries.slice(0, options.limit);
+    }
+
+    return new Map(entries) as Map<string, T>;
+  }
+}
+
+export class SqliteNodeRoomStorage implements NodeRoomStorageProvider {
+  private readonly tableName: string;
+  private databasePromise?: Promise<NodeSqliteDatabase>;
+  private configured = false;
+
+  constructor(private readonly options: NodeSqliteStorageOptions) {
+    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: string, roomId: string): Promise<NodeRoomStorage> {
+    const database = await this.getDatabase();
+    await this.ensureConfigured(database);
+    return new SqliteNodeRoomStorageInstance(
+      database,
+      this.tableName,
+      namespace,
+      roomId,
+      this.options.busyRetries ?? DEFAULT_SQLITE_BUSY_RETRIES
+    );
+  }
+
+  private async getDatabase() {
+    if (!this.databasePromise) {
+      this.databasePromise = this.createDatabase();
+    }
+
+    return this.databasePromise;
+  }
+
+  private async createDatabase(): Promise<NodeSqliteDatabase> {
+    if (this.options.database) {
+      return this.options.database;
+    }
+
+    const sqliteModule = loadNodeSqliteModule();
+    const { DatabaseSync } = sqliteModule;
+    return new DatabaseSync(this.options.databasePath!) as NodeSqliteDatabase;
+  }
+
+  private async ensureConfigured(database: NodeSqliteDatabase) {
+    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;
+  }
+}
+
+class SqliteNodeRoomStorageInstance implements NodeRoomStorage {
+  constructor(
+    private readonly database: NodeSqliteDatabase,
+    private readonly tableName: string,
+    private readonly namespace: string,
+    private readonly roomId: string,
+    private readonly busyRetries: number
+  ) {}
+
+  async get<T = unknown>(key: string): Promise<T | undefined> {
+    const row = runSqliteOperation(
+      () => this.database
+        .prepare(`
+          SELECT value
+          FROM ${this.tableName}
+          WHERE namespace = ? AND room_id = ? AND key = ?
+        `)
+        .get(this.namespace, this.roomId, key) as { value: string } | undefined,
+      this.busyRetries
+    );
+
+    return row ? JSON.parse(row.value) as T : undefined;
+  }
+
+  async put<T = unknown>(keyOrEntries: string | Record<string, T>, value?: T): Promise<void> {
+    const entries = typeof keyOrEntries === "string"
+      ? [[keyOrEntries, value] as const]
+      : 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: string | string[]): Promise<boolean | number> {
+    if (Array.isArray(keyOrKeys)) {
+      if (keyOrKeys.length === 0) {
+        return 0;
+      }
+
+      const result = 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(result.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<T = unknown>(options: NodeRoomStorageListOptions = {}): Promise<Map<string, T>> {
+    const conditions = ["namespace = ?", "room_id = ?"];
+    const params: unknown[] = [this.namespace, this.roomId];
+
+    if (options.prefix !== undefined) {
+      conditions.push("key >= ?", "key < ?");
+      params.push(options.prefix, getPrefixEnd(options.prefix));
+    }
+    if (options.start !== undefined) {
+      conditions.push("key >= ?");
+      params.push(options.start);
+    }
+    if (options.startAfter !== undefined) {
+      conditions.push("key > ?");
+      params.push(options.startAfter);
+    }
+    if (options.end !== undefined) {
+      conditions.push("key < ?");
+      params.push(options.end);
+    }
+
+    const limit = options.limit !== undefined ? normalizeSqliteLimit(options.limit) : undefined;
+    const rows = runSqliteOperation(
+      () => this.database
+        .prepare(`
+          SELECT key, value
+          FROM ${this.tableName}
+          WHERE ${conditions.join(" AND ")}
+          ORDER BY key ${options.reverse ? "DESC" : "ASC"}
+          ${limit !== undefined ? `LIMIT ${limit}` : ""}
+        `)
+        .all(...params) as { key: string; value: string }[],
+      this.busyRetries
+    );
+
+    return new Map(rows.map((row) => [row.key, JSON.parse(row.value) as T]));
+  }
+}
+
+export class NodeRoomTransport<TServer extends Party.Server = Party.Server> {
+  readonly partiesPath: string;
+  readonly env: Record<string, unknown>;
+  readonly externalParties: Record<string, {
+    get(id: string): Partial<Party.Stub>;
+  }>;
+  private readonly rooms: Record<string, NodeServerConstructor>;
+  private readonly storage: NodeRoomStorageFactory | NodeRoomStorageProvider;
+  private readonly records = new Map<string, Promise<RoomRecord>>();
+
+  constructor(
+    private readonly ServerClass: NodeServerConstructor<TServer>,
+    options: NodeRoomTransportOptions = {}
+  ) {
+    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: string | Request, init?: RequestInit): Promise<Response> {
+    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 as unknown as Party.Request) ?? new Response("Not Found", { status: 404 });
+  }
+
+  async handleNodeRequest(
+    req: IncomingMessage,
+    res: NodeServerResponse,
+    next?: NodeRequestNext
+  ): Promise<void> {
+    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: NodeWebSocketServerLike,
+    request: IncomingMessage,
+    socket: Duplex,
+    head: Buffer
+  ): void {
+    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: NodeWebSocketLike,
+    request: IncomingMessage | Request,
+    parsedPath?: ParsedPartyPath
+  ): Promise<NodeConnection> {
+    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 as unknown as Party.Connection, {
+      request: connectRequest as unknown as Party.Request,
+    });
+
+    const onMessage = (data: unknown) => {
+      void record.server.onMessage?.(normalizeWebSocketMessage(data), connection as unknown as Party.Connection);
+    };
+    const onClose = () => {
+      record.room.deleteConnection(connection.id, connection);
+      void record.server.onClose?.(connection as unknown as Party.Connection);
+    };
+    const onError = (error: Error) => {
+      void record.server.onError?.(connection as unknown as Party.Connection, error);
+    };
+
+    webSocket.on("message", onMessage);
+    webSocket.on("close", onClose);
+    webSocket.on("error", onError);
+    record.room.addConnection(connection);
+
+    return connection;
+  }
+
+  getRoom(namespace: string, roomId: string): Promise<NodeRoom> {
+    return this.getRecord(namespace, roomId).then((record) => record.room);
+  }
+
+  getNamespacePath(namespace: string, roomId: string) {
+    const baseSegments = trimSlashes(this.getPartiesBase()).split("/").slice(0, -1);
+    return `/${[...baseSegments, namespace, encodeURIComponent(roomId)].join("/")}`;
+  }
+
+  private async getRecord(namespace: string, roomId: string): Promise<RoomRecord> {
+    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;
+    }
+  }
+
+  private async createRecord(namespace: string, roomId: string): Promise<RoomRecord> {
+    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 as Party.Room);
+    const record: RoomRecord = {
+      room,
+      server,
+      started: Promise.resolve(server.onStart?.()).then(() => undefined),
+    };
+
+    await record.started;
+    return record;
+  }
+
+  private async resolveStorage(namespace: string, roomId: string): Promise<NodeRoomStorage> {
+    if (typeof this.storage === "function") {
+      return this.storage(namespace, roomId);
+    }
+
+    return this.storage.getStorage(namespace, roomId);
+  }
+
+  private parsePartyRequest(url: string): ParsedPartyPath | null {
+    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}` : "/",
+    };
+  }
+
+  private getPartiesBase() {
+    return this.partiesPath;
+  }
+}
+
+export class NodeRoom implements Party.Room {
+  readonly id: string;
+  readonly internalID: string;
+  readonly name: string;
+  readonly env: Record<string, unknown>;
+  readonly storage: Party.Storage;
+  readonly context: Party.Context;
+  readonly connections = new Map<string, Party.Connection>();
+  readonly parties: Party.Context["parties"];
+  readonly analytics = {} as Party.Room["analytics"];
+
+  constructor(options: {
+    id: string;
+    name: string;
+    env: Record<string, unknown>;
+    storage: NodeRoomStorage;
+    transport: NodeRoomTransport;
+  }) {
+    this.id = options.id;
+    this.internalID = `${options.name}:${options.id}`;
+    this.name = options.name;
+    this.env = options.env;
+    this.storage = options.storage as Party.Storage;
+    this.parties = createPartiesContext(options.transport);
+    this.context = {
+      parties: this.parties,
+      ai: {},
+      vectorize: {},
+      analytics: this.analytics,
+      assets: {
+        fetch: async () => null,
+      },
+      bindings: {
+        r2: {},
+        kv: {},
+      },
+    } as Party.Context;
+  }
+
+  blockConcurrencyWhile<T>(callback: () => Promise<T>): Promise<T> {
+    return callback();
+  }
+
+  broadcast(msg: string | ArrayBuffer | ArrayBufferView, without: string[] = []) {
+    for (const connection of this.connections.values()) {
+      if (!without.includes(connection.id)) {
+        connection.send(msg);
+      }
+    }
+  }
+
+  getConnection<TState = unknown>(id: string): Party.Connection<TState> | undefined {
+    let connection: Party.Connection | undefined;
+    for (const current of this.connections.values()) {
+      if (current.id === id || current.sessionId === id) {
+        connection = current;
+      }
+    }
+    return connection as Party.Connection<TState> | undefined;
+  }
+
+  getConnections<TState = unknown>(): Iterable<Party.Connection<TState>> {
+    return Array.from(this.connections.values()) as Party.Connection<TState>[];
+  }
+
+  addConnection(connection: NodeConnection) {
+    this.connections.set(connection.id, connection as unknown as Party.Connection);
+  }
+
+  deleteConnection(id: string, connection?: NodeConnection) {
+    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);
+      }
+    }
+  }
+}
+
+export class NodeConnection<TState = unknown> {
+  readonly id = createConnectionId();
+  readonly sessionId: string;
+  readonly socket: this = this;
+  readonly uri: string;
+  state: Party.ConnectionState<TState> | TState | null = null;
+  private attachment: unknown = null;
+
+  constructor(
+    private readonly webSocket: NodeWebSocketLike,
+    uri: string,
+    sessionId?: string
+  ) {
+    this.sessionId = sessionId || this.id;
+    this.uri = uri;
+  }
+
+  send(data: string | ArrayBuffer | ArrayBufferView) {
+    if (this.webSocket.readyState === undefined || this.webSocket.readyState === WEBSOCKET_OPEN) {
+      this.webSocket.send(data);
+    }
+  }
+
+  close(code?: number, reason?: string) {
+    this.webSocket.close(code, reason);
+  }
+
+  setState(state: TState | Party.ConnectionSetStateFn<TState> | null) {
+    this.state = typeof state === "function"
+      ? (state as Party.ConnectionSetStateFn<TState>)(this.state as Party.ConnectionState<TState>)
+      : state;
+    return this.state as Party.ConnectionState<TState>;
+  }
+
+  serializeAttachment<T = unknown>(attachment: T): void {
+    this.attachment = attachment;
+  }
+
+  deserializeAttachment<T = unknown>(): T | null {
+    return this.attachment as T | null;
+  }
+}
+
+function createPartiesContext(transport: NodeRoomTransport): Party.Context["parties"] {
+  return new Proxy({}, {
+    get(_target, namespace: string) {
+      const externalNamespace = transport.externalParties[namespace];
+      if (externalNamespace) {
+        return externalNamespace;
+      }
+
+      return {
+        get(roomId: string) {
+          return {
+            connect: () => {
+              throw new Error("Party stub connect() is not implemented by @signe/room/node");
+            },
+            async socket(pathOrInit?: string | RequestInit, init?: RequestInit) {
+              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 as unknown as WebSocket;
+            },
+            fetch(pathOrInit?: string | RequestInit | Request, init?: RequestInit) {
+              const path = typeof pathOrInit === "string" ? pathOrInit : "/";
+              const requestInit = typeof pathOrInit === "string" ? init : pathOrInit;
+              return transport.fetch(`${transport.getNamespacePath(namespace, roomId)}${normalizeStubPath(path)}`, requestInit as RequestInit);
+            },
+          };
+        },
+      };
+    },
+  }) as Party.Context["parties"];
+}
+
+function createInMemoryWebSocketPair() {
+  const client = new InMemoryWebSocket();
+  const server = new InMemoryWebSocket();
+
+  client.setPeer(server);
+  server.setPeer(client);
+
+  return { client, server };
+}
+
+class InMemoryWebSocket implements NodeWebSocketLike {
+  readyState = WEBSOCKET_OPEN;
+  private readonly emitter = new EventEmitter();
+  private peer?: InMemoryWebSocket;
+
+  setPeer(peer: InMemoryWebSocket) {
+    this.peer = peer;
+  }
+
+  send(data: string | ArrayBuffer | ArrayBufferView, cb?: (error?: Error) => void): void {
+    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?: number, reason?: string | Buffer): void {
+    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: string, listener: (...args: any[]) => void): unknown {
+    this.emitter.on(event, listener);
+    return this;
+  }
+
+  off(event: string, listener: (...args: any[]) => void): unknown {
+    this.emitter.off(event, listener);
+    return this;
+  }
+
+  removeListener(event: string, listener: (...args: any[]) => void): unknown {
+    this.emitter.removeListener(event, listener);
+    return this;
+  }
+
+  addEventListener(type: string, listener: (event: any) => void): void {
+    if (type === "message") {
+      this.on("message", (data) => listener({ data }));
+      return;
+    }
+
+    this.on(type, (event) => listener(event));
+  }
+
+  private emitMessage(data: string | ArrayBuffer | ArrayBufferView) {
+    if (this.readyState === WEBSOCKET_OPEN) {
+      this.emitter.emit("message", data);
+    }
+  }
+}
+
+async function createWebRequest(req: IncomingMessage, url: string, includeBody = true): Promise<Request> {
+  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 !== undefined) {
+      headers.set(key, String(value));
+    }
+  }
+
+  const method = req.method ?? "GET";
+  const hasBody = includeBody && !["GET", "HEAD"].includes(method);
+  const body = hasBody ? await readIncomingBody(req) : undefined;
+
+  return new Request(url, {
+    method,
+    headers,
+    body,
+  });
+}
+
+async function readIncomingBody(req: IncomingMessage): Promise<Uint8Array> {
+  const chunks: Uint8Array[] = [];
+
+  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: NodeServerResponse, response: 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: IncomingMessage) {
+  const protocol = req.headers["x-forwarded-proto"] ?? "http";
+  const host = req.headers.host ?? "localhost";
+  return `${protocol}://${host}${req.url ?? "/"}`;
+}
+
+function normalizeWebSocketMessage(data: unknown): string | ArrayBuffer | ArrayBufferView {
+  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: string) {
+  return `/${trimSlashes(path)}`;
+}
+
+function normalizeStubPath(path: string) {
+  if (!path || path === "/") {
+    return "";
+  }
+  return path.startsWith("/") ? path : `/${path}`;
+}
+
+function toLocalUrl(path: string) {
+  return path.startsWith("http://") || path.startsWith("https://")
+    ? path
+    : `http://localhost${path.startsWith("/") ? path : `/${path}`}`;
+}
+
+function getConnectionIdFromUrl(url: string) {
+  const requestedId = new URL(url).searchParams.get("id")?.trim();
+  return requestedId || undefined;
+}
+
+function trimSlashes(value: string) {
+  return value.replace(/^\/+|\/+$/g, "");
+}
+
+function getStorageKey(namespace: string, roomId: string) {
+  return `${encodeURIComponent(namespace)}:${encodeURIComponent(roomId)}`;
+}
+
+function assertSafeSqlIdentifier(identifier: string) {
+  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(identifier)) {
+    throw new Error(`Invalid SQLite table name: ${identifier}`);
+  }
+}
+
+function getPrefixEnd(prefix: string) {
+  return `${prefix}\uffff`;
+}
+
+function normalizeSqliteLimit(value: number) {
+  if (!Number.isFinite(value) || value < 0) {
+    return 0;
+  }
+
+  return Math.floor(value);
+}
+
+function normalizeSqliteTimeout(value: number) {
+  if (!Number.isFinite(value) || value < 0) {
+    return DEFAULT_SQLITE_BUSY_TIMEOUT_MS;
+  }
+
+  return Math.floor(value);
+}
+
+function normalizeSqliteJournalMode(value: NodeSqliteJournalMode) {
+  const journalMode = value.toUpperCase() as NodeSqliteJournalMode;
+  const allowedModes = new Set<NodeSqliteJournalMode>([
+    "DELETE",
+    "TRUNCATE",
+    "PERSIST",
+    "MEMORY",
+    "WAL",
+    "OFF",
+  ]);
+
+  if (!allowedModes.has(journalMode)) {
+    throw new Error(`Invalid SQLite journal mode: ${value}`);
+  }
+
+  return journalMode;
+}
+
+function runSqliteOperation<T>(operation: () => T, retries: number): T {
+  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: unknown) {
+  if (!error || typeof error !== "object") {
+    return false;
+  }
+
+  const err = error as { errcode?: number; errstr?: string; code?: string; message?: string };
+  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: number) {
+  const buffer = new SharedArrayBuffer(4);
+  const view = new Int32Array(buffer);
+  Atomics.wait(view, 0, 0, ms);
+}
+
+function loadNodeSqliteModule(): typeof import("node:sqlite") {
+  const require = createRequire(`${process.cwd()}/package.json`);
+  return require("node:sqlite");
+}
+
+function cloneStorageValue<T>(value: T): T {
+  if (typeof structuredClone === "function") {
+    try {
+      return structuredClone(value);
+    } catch {
+      return value;
+    }
+  }
+
+  return value;
+}
+
+function createConnectionId() {
+  return Math.random().toString(36).slice(2, 12);
+}