@mh-gg/cli 0.1.1-alpha.20260613T085325975Z

package/runtime/host/memberRootRegistry.cjs

@@ -0,0 +1,132 @@
+const fs = require("node:fs");
+const path = require("node:path");
+
+function registryPathFromOptions(options = {}) {
+  if (options.registryPath) return options.registryPath;
+  if (options.memberRootRegistryPath) return options.memberRootRegistryPath;
+  if (options.storagePath) return `${options.storagePath}.member-roots.json`;
+  if (options.dataDir) return path.join(options.dataDir, "member-roots.json");
+  return undefined;
+}
+
+function clone(value) {
+  return value === undefined ? undefined : JSON.parse(JSON.stringify(value));
+}
+
+function safeKeyPart(value) {
+  return String(value || "").replace(/[\u0000-\u001f\u007f:]/g, "_");
+}
+
+function rootKeyFor(roomName, memberId) {
+  return `${safeKeyPart(roomName)}:${safeKeyPart(memberId)}`;
+}
+
+function claimRoom(claim) {
+  return claim?.roomId || claim?.roomName;
+}
+
+function normalizeClaim(claim) {
+  const roomName = claimRoom(claim);
+  if (!roomName || !claim?.memberId || !claim?.rootPublicKey) return undefined;
+  return {
+    roomName,
+    memberId: claim.memberId,
+    rootPublicKey: claim.rootPublicKey,
+    firstSeenAt: Number.isFinite(Number(claim.createdAt)) ? Number(claim.createdAt) : Date.now(),
+    updatedAt: Date.now(),
+    lastDeviceId: claim.deviceId,
+    lastKeyId: claim.keyId
+  };
+}
+
+function createMemoryRegistry(initial = {}) {
+  const roots = new Map(Object.entries(initial));
+  return {
+    path: undefined,
+    entries() {
+      return Object.fromEntries(roots.entries());
+    },
+    get(roomName, memberId) {
+      return clone(roots.get(rootKeyFor(roomName, memberId)));
+    },
+    remember(claim) {
+      const normalized = normalizeClaim(claim);
+      if (!normalized) return { ok: false, error: "member root claim is incomplete" };
+      const key = rootKeyFor(normalized.roomName, normalized.memberId);
+      const existing = roots.get(key);
+      if (existing && existing.rootPublicKey !== normalized.rootPublicKey) {
+        return {
+          ok: false,
+          error: "member root public key changed",
+          existing: clone(existing),
+          incoming: clone(normalized)
+        };
+      }
+      const next = existing ? { ...existing, ...normalized, firstSeenAt: existing.firstSeenAt || normalized.firstSeenAt } : normalized;
+      roots.set(key, next);
+      return { ok: true, entry: clone(next) };
+    }
+  };
+}
+
+function readRegistryFile(file) {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(file, "utf8"));
+    if (parsed && parsed.version === 1 && parsed.roots && typeof parsed.roots === "object" && !Array.isArray(parsed.roots)) {
+      return parsed.roots;
+    }
+  } catch (error) {
+    if (error && error.code === "ENOENT") return {};
+  }
+  return {};
+}
+
+function writeRegistryFile(file, roots) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const tmp = `${file}.${process.pid}.${Date.now()}.tmp`;
+  fs.writeFileSync(tmp, JSON.stringify({ version: 1, roots }, null, 2));
+  fs.renameSync(tmp, file);
+}
+
+function createMemberRootRegistry(options = {}) {
+  const file = registryPathFromOptions(options);
+  if (!file) return createMemoryRegistry(options.initialRoots);
+  let roots = readRegistryFile(file);
+  function persist() {
+    writeRegistryFile(file, roots);
+  }
+  return {
+    path: file,
+    entries() {
+      roots = readRegistryFile(file);
+      return clone(roots);
+    },
+    get(roomName, memberId) {
+      roots = readRegistryFile(file);
+      return clone(roots[rootKeyFor(roomName, memberId)]);
+    },
+    remember(claim) {
+      const normalized = normalizeClaim(claim);
+      if (!normalized) return { ok: false, error: "member root claim is incomplete" };
+      roots = readRegistryFile(file);
+      const key = rootKeyFor(normalized.roomName, normalized.memberId);
+      const existing = roots[key];
+      if (existing && existing.rootPublicKey !== normalized.rootPublicKey) {
+        return {
+          ok: false,
+          error: "member root public key changed",
+          existing: clone(existing),
+          incoming: clone(normalized)
+        };
+      }
+      roots[key] = existing ? { ...existing, ...normalized, firstSeenAt: existing.firstSeenAt || normalized.firstSeenAt } : normalized;
+      persist();
+      return { ok: true, entry: clone(roots[key]) };
+    }
+  };
+}
+
+module.exports = {
+  createMemberRootRegistry,
+  rootKeyFor
+};

package/runtime/host/nodePeer.cjs

@@ -0,0 +1,127 @@
+const wrtcModule = require("@roamhq/wrtc");
+const WebSocketModule = require("ws");
+const xhr2Module = require("xhr2");
+const {
+  DEFAULT_PEERJS_HOST,
+  DEFAULT_PEERJS_PATH,
+  DEFAULT_PEERJS_PORT,
+  peerJsSignalingConfig
+} = require("./peerJsConfig.cjs");
+const { patchNodePeer } = require("./nodePeerRacePatch.cjs");
+
+const wrtc = wrtcModule.default || wrtcModule;
+const WebSocket = WebSocketModule.default || WebSocketModule;
+const XMLHttpRequest = xhr2Module.XMLHttpRequest || xhr2Module.default?.XMLHttpRequest || xhr2Module;
+
+function debugPeerJs(message) {
+  if (process.env.MATTERHORN_DEBUG === "1") {
+    console.log(`matterhorn peerjs debug: ${message}`);
+  }
+}
+
+function peerJsSocketTarget(address) {
+  try {
+    const url = new URL(String(address));
+    const id = url.searchParams.get("id");
+    const version = url.searchParams.get("version");
+    const suffix = [id ? `id=${id}` : "", version ? `version=${version}` : ""].filter(Boolean).join("&");
+    return `${url.protocol}//${url.host}${url.pathname}${suffix ? `?${suffix}` : ""}`;
+  } catch {
+    return String(address).replace(/([?&](?:key|token)=)[^&]+/g, "$1<redacted>");
+  }
+}
+
+function createDebugWebSocket() {
+  return class MatterhornDebugWebSocket extends WebSocket {
+    constructor(address, protocols, options) {
+      const target = peerJsSocketTarget(address);
+      const openedAt = Date.now();
+      let lastMessage = "none";
+      debugPeerJs(`socket opening ${target}`);
+      super(address, protocols, options);
+      this.on("open", () => debugPeerJs(`socket open ${target}`));
+      this.on("message", (data) => {
+        lastMessage = peerJsServerMessageSummary(data);
+        debugPeerJs(`socket message ${target} ${lastMessage}`);
+      });
+      this.on("close", (code, reason) => {
+        const reasonText = Buffer.isBuffer(reason) ? reason.toString("utf8") : String(reason || "");
+        const ageMs = Date.now() - openedAt;
+        debugPeerJs(`socket close ${target} code=${code} ageMs=${ageMs} lastMessage=${lastMessage}${reasonText ? ` reason=${reasonText}` : ""}`);
+      });
+      this.on("error", (error) => {
+        const code = error?.code ? ` code=${error.code}` : "";
+        debugPeerJs(`socket error ${target}${code}: ${error?.message || String(error)}`);
+      });
+      this.on("unexpected-response", (_request, response) => {
+        debugPeerJs(`socket unexpected response ${target}: ${response.statusCode} ${response.statusMessage || ""}`.trim());
+      });
+    }
+  };
+}
+
+function peerJsServerMessageSummary(data) {
+  try {
+    const raw = Buffer.isBuffer(data) ? data.toString("utf8") : String(data);
+    const message = JSON.parse(raw);
+    const parts = [`type=${message.type || "unknown"}`];
+    if (message.src) parts.push(`src=${message.src}`);
+    if (message.dst) parts.push(`dst=${message.dst}`);
+    return parts.join(" ");
+  } catch {
+    return "unparseable";
+  }
+}
+
+function installGlobal(name, value, force = false) {
+  if (!force && globalThis[name] != null) return;
+  Object.defineProperty(globalThis, name, {
+    value,
+    configurable: true,
+    writable: true
+  });
+}
+
+function installPeerJsNodeGlobals(signaling = peerJsSignalingConfig()) {
+  installGlobal("window", globalThis);
+  installGlobal("self", globalThis);
+  installGlobal("location", {
+    protocol: signaling.secure ? "https:" : "http:",
+    hostname: signaling.host,
+    host: `${signaling.host}:${signaling.port}`
+  }, true);
+  installGlobal("navigator", { userAgent: "node" });
+  installGlobal("WebSocket", createDebugWebSocket(), true);
+  installGlobal("XMLHttpRequest", XMLHttpRequest);
+  installGlobal("RTCPeerConnection", wrtc.RTCPeerConnection);
+  installGlobal("RTCSessionDescription", wrtc.RTCSessionDescription);
+  installGlobal("RTCIceCandidate", wrtc.RTCIceCandidate);
+  installGlobal("MediaStream", wrtc.MediaStream);
+  installGlobal("MediaStreamTrack", wrtc.MediaStreamTrack);
+}
+
+async function createNodePeer(peerId, iceServers, options = {}) {
+  const signaling = options.signaling || peerJsSignalingConfig();
+  installPeerJsNodeGlobals(signaling);
+  const peerjs = await import("peerjs");
+  const Peer = peerjs.Peer || peerjs.default?.Peer || peerjs["module.exports"]?.Peer;
+  const peer = new Peer(peerId, {
+    debug: Number(process.env.PEER_DEBUG || 0),
+    host: signaling.host,
+    port: signaling.port,
+    path: signaling.path,
+    secure: signaling.secure,
+    config: {
+      iceServers,
+      sdpSemantics: "unified-plan"
+    }
+  });
+  return patchNodePeer(peer, debugPeerJs);
+}
+
+module.exports = {
+  DEFAULT_PEERJS_HOST,
+  DEFAULT_PEERJS_PATH,
+  DEFAULT_PEERJS_PORT,
+  createNodePeer
+};

package/runtime/host/nodePeerRacePatch.cjs

@@ -0,0 +1,106 @@
+function isPromiseLike(value) {
+  return value && typeof value.then === "function";
+}
+
+function isMissingProviderCandidateRace(connection, error) {
+  const message = error?.message || "";
+  return !connection?.provider
+    && message.includes("Cannot read properties of null")
+    && message.includes("emitError");
+}
+
+function isMissingDataChannelRace(error) {
+  const message = error?.message || "";
+  const stack = error?.stack || "";
+  return message.includes("Cannot read properties of null")
+    && message.includes("_initializeDataChannel")
+    && stack.includes("peerjs");
+}
+
+function isPeerJsConnectionRace(connection, error) {
+  const stack = error?.stack || "";
+  return isMissingProviderCandidateRace(connection, error)
+    || isMissingDataChannelRace(error)
+    || (stack.includes("peerjs") && stack.includes("handleCandidate") && String(error?.message || "").includes("emitError"));
+}
+
+function ignorePeerJsConnectionRace(connection, error, debug) {
+  if (!isPeerJsConnectionRace(connection, error)) return false;
+  debug?.(`ignored stale PeerJS connection event: ${error?.message || String(error)}`);
+  return true;
+}
+
+function withRaceFilter(connection, debug, callback) {
+  try {
+    const result = callback();
+    if (!isPromiseLike(result)) return result;
+    return result.catch((error) => {
+      if (ignorePeerJsConnectionRace(connection, error, debug)) return undefined;
+      throw error;
+    });
+  } catch (error) {
+    if (ignorePeerJsConnectionRace(connection, error, debug)) return undefined;
+    throw error;
+  }
+}
+
+function patchPeerConnectionEvents(connection, debug) {
+  const peerConnection = connection?.peerConnection;
+  if (!peerConnection || peerConnection.MatterhornPeerJsRacePatched) return;
+  peerConnection.MatterhornPeerJsRacePatched = true;
+  const originalDataChannel = peerConnection.ondatachannel;
+  if (typeof originalDataChannel === "function") {
+    peerConnection.ondatachannel = function onDataChannel(event) {
+      return withRaceFilter(connection, debug, () => originalDataChannel.call(this, event));
+    };
+  }
+}
+
+function patchNegotiator(connection, debug) {
+  const negotiator = connection?._negotiator;
+  if (!negotiator || negotiator.MatterhornPeerJsRacePatched) return;
+  negotiator.MatterhornPeerJsRacePatched = true;
+  const originalCandidate = negotiator.handleCandidate;
+  if (typeof originalCandidate === "function") {
+    negotiator.handleCandidate = function handleCandidate(ice) {
+      return withRaceFilter(connection, debug, () => originalCandidate.call(this, ice));
+    };
+  }
+}
+
+function patchConnectionMessageHandler(connection, debug) {
+  if (!connection || connection.MatterhornPeerJsRacePatched) return;
+  connection.MatterhornPeerJsRacePatched = true;
+  const originalHandleMessage = connection.handleMessage;
+  if (typeof originalHandleMessage === "function") {
+    connection.handleMessage = function handleMessage(message) {
+      return withRaceFilter(connection, debug, () => originalHandleMessage.call(this, message));
+    };
+  }
+}
+
+function patchPeerJsConnection(connection, debug) {
+  if (!connection) return connection;
+  patchConnectionMessageHandler(connection, debug);
+  patchNegotiator(connection, debug);
+  patchPeerConnectionEvents(connection, debug);
+  return connection;
+}
+
+function patchNodePeer(peer, debug) {
+  if (!peer || peer.MatterhornPeerJsRacePatched) return peer;
+  peer.MatterhornPeerJsRacePatched = true;
+  const originalAddConnection = peer._addConnection;
+  if (typeof originalAddConnection === "function") {
+    peer._addConnection = function addConnection(peerId, connection) {
+      return originalAddConnection.call(this, peerId, patchPeerJsConnection(connection, debug));
+    };
+  }
+  return peer;
+}
+
+module.exports = {
+  isPeerJsConnectionRace,
+  patchNodePeer,
+  patchPeerJsConnection
+};

package/runtime/host/peerJsConfig.cjs

@@ -0,0 +1,26 @@
+const { signalingUrl } = require("@mh-gg/relay-core");
+
+const DEFAULT_PEERJS_HOST = "peer.yage.games";
+const DEFAULT_PEERJS_PORT = 443;
+const DEFAULT_PEERJS_PATH = "/";
+
+function peerJsSignalingConfig(env = process.env) {
+  return {
+    host: env.MATTERHORN_PEERJS_HOST || DEFAULT_PEERJS_HOST,
+    port: Number(env.MATTERHORN_PEERJS_PORT || DEFAULT_PEERJS_PORT),
+    path: env.MATTERHORN_PEERJS_PATH || DEFAULT_PEERJS_PATH,
+    secure: env.MATTERHORN_PEERJS_SECURE !== "false"
+  };
+}
+
+function peerJsSignalingUrl(env = process.env) {
+  return signalingUrl(peerJsSignalingConfig(env));
+}
+
+module.exports = {
+  DEFAULT_PEERJS_HOST,
+  DEFAULT_PEERJS_PATH,
+  DEFAULT_PEERJS_PORT,
+  peerJsSignalingConfig,
+  peerJsSignalingUrl
+};

package/runtime/host/pushEgress.cjs

@@ -0,0 +1,48 @@
+const { sendToUser } = require("@mh-gg/push");
+
+function createPushEgress({ pushStorage, subject, send = sendToUser }) {
+  function payloadDeviceId(payload) {
+    try {
+      const parsed = typeof payload === "string" ? JSON.parse(payload) : payload;
+      return typeof parsed?.deviceId === "string" ? parsed.deviceId : undefined;
+    } catch {
+      return undefined;
+    }
+  }
+
+  async function sendRelayPush(message) {
+    const userId = message?.target?.userId;
+    if (!userId) throw new Error("relay.push target userId is required.");
+    const grant = pushStorage.selectGrant(userId);
+    if (!grant) return { delivered: 0, pruned: 0, reason: "missing-vapid-grant" };
+    const deviceId = payloadDeviceId(message.payload);
+    const subscriptions = deviceId
+      ? [pushStorage.selectSubscription(userId, deviceId)].filter(Boolean)
+      : pushStorage.selectSubscriptionsForUser(userId);
+    if (subscriptions.length === 0) return { delivered: 0, pruned: 0, reason: "missing-subscription" };
+    const results = await send({
+      vapidPublicKey: grant.vapidPublicKey,
+      vapidPrivateKey: grant.vapidPrivateKey,
+      subject,
+      subscriptions,
+      payload: Buffer.from(message.payload),
+      ttlSeconds: message.ttlSeconds,
+      urgency: message.urgency
+    });
+    let delivered = 0;
+    let pruned = 0;
+    for (const result of results) {
+      if (result.gone) {
+        pushStorage.deleteSubscriptionByEndpoint(userId, result.endpoint);
+        pruned += 1;
+      } else {
+        delivered += 1;
+      }
+    }
+    return { delivered, pruned };
+  }
+
+  return { sendRelayPush };
+}
+
+module.exports = { createPushEgress };

package/runtime/host/pushStorage.cjs

@@ -0,0 +1,233 @@
+const fs = require("node:fs");
+const path = require("node:path");
+const { DatabaseSync } = require("node:sqlite");
+
+function sqliteFile(storagePath) {
+  return path.join(storagePath, "events.sqlite");
+}
+
+class PushStorage {
+  constructor(storagePathOrDb) {
+    if (typeof storagePathOrDb === "string") {
+      fs.mkdirSync(storagePathOrDb, { recursive: true });
+      this.db = new DatabaseSync(sqliteFile(storagePathOrDb));
+    } else {
+      this.db = storagePathOrDb;
+    }
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS push_subscriptions (
+        user_id    TEXT NOT NULL,
+        device_id  TEXT NOT NULL,
+        endpoint   TEXT NOT NULL,
+        p256dh     TEXT NOT NULL,
+        auth       TEXT NOT NULL,
+        updated_at INTEGER NOT NULL,
+        PRIMARY KEY (user_id, device_id)
+      );
+
+      CREATE TABLE IF NOT EXISTS push_grants (
+        user_id          TEXT PRIMARY KEY,
+        vapid_private    TEXT NOT NULL,
+        vapid_public     TEXT NOT NULL,
+        updated_at       INTEGER NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS pending_pushes (
+        push_id    TEXT PRIMARY KEY,
+        user_id    TEXT NOT NULL,
+        payload    TEXT NOT NULL,
+        created_at INTEGER NOT NULL,
+        expires_at INTEGER NOT NULL,
+        attempts   INTEGER NOT NULL DEFAULT 0
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_pending_pushes_user
+      ON pending_pushes (user_id);
+
+      CREATE INDEX IF NOT EXISTS idx_pending_pushes_expires
+      ON pending_pushes (expires_at);
+    `);
+    this.upsertSubscriptionStatement = this.db.prepare(`
+      INSERT INTO push_subscriptions (user_id, device_id, endpoint, p256dh, auth, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?)
+      ON CONFLICT(user_id, device_id) DO UPDATE SET
+        endpoint = excluded.endpoint,
+        p256dh = excluded.p256dh,
+        auth = excluded.auth,
+        updated_at = excluded.updated_at
+    `);
+    this.selectSubscriptionStatement = this.db.prepare(`
+      SELECT user_id, device_id, endpoint, p256dh, auth, updated_at
+      FROM push_subscriptions
+      WHERE user_id = ? AND device_id = ?
+      LIMIT 1
+    `);
+    this.selectSubscriptionsForUserStatement = this.db.prepare(`
+      SELECT user_id, device_id, endpoint, p256dh, auth, updated_at
+      FROM push_subscriptions
+      WHERE user_id = ?
+      ORDER BY device_id ASC
+    `);
+    this.deleteSubscriptionStatement = this.db.prepare(`
+      DELETE FROM push_subscriptions
+      WHERE user_id = ? AND device_id = ?
+    `);
+    this.deleteSubscriptionByEndpointStatement = this.db.prepare(`
+      DELETE FROM push_subscriptions
+      WHERE user_id = ? AND endpoint = ?
+    `);
+    this.upsertGrantStatement = this.db.prepare(`
+      INSERT INTO push_grants (user_id, vapid_private, vapid_public, updated_at)
+      VALUES (?, ?, ?, ?)
+      ON CONFLICT(user_id) DO UPDATE SET
+        vapid_private = excluded.vapid_private,
+        vapid_public = excluded.vapid_public,
+        updated_at = excluded.updated_at
+    `);
+    this.selectGrantStatement = this.db.prepare(`
+      SELECT user_id, vapid_private, vapid_public, updated_at
+      FROM push_grants
+      WHERE user_id = ?
+      LIMIT 1
+    `);
+    this.upsertPendingPushStatement = this.db.prepare(`
+      INSERT INTO pending_pushes (push_id, user_id, payload, created_at, expires_at, attempts)
+      VALUES (?, ?, ?, ?, ?, 0)
+      ON CONFLICT(push_id) DO NOTHING
+    `);
+    this.selectPendingPushesStatement = this.db.prepare(`
+      SELECT push_id, user_id, payload, created_at, expires_at, attempts
+      FROM pending_pushes
+      WHERE expires_at > ?
+      ORDER BY created_at ASC
+      LIMIT ?
+    `);
+    this.deletePendingPushStatement = this.db.prepare(`
+      DELETE FROM pending_pushes
+      WHERE push_id = ?
+    `);
+    this.pruneExpiredPendingPushesStatement = this.db.prepare(`
+      DELETE FROM pending_pushes
+      WHERE expires_at <= ?
+    `);
+    this.incrementPendingPushAttemptsStatement = this.db.prepare(`
+      UPDATE pending_pushes
+      SET attempts = attempts + 1
+      WHERE push_id = ?
+    `);
+  }
+
+  subscriptionFromRow(row) {
+    if (!row) return undefined;
+    return {
+      userId: row.user_id,
+      deviceId: row.device_id,
+      endpoint: row.endpoint,
+      keys: {
+        p256dh: row.p256dh,
+        auth: row.auth
+      },
+      updatedAt: row.updated_at
+    };
+  }
+
+  grantFromRow(row) {
+    if (!row) return undefined;
+    return {
+      userId: row.user_id,
+      vapidPrivateKey: row.vapid_private,
+      vapidPublicKey: row.vapid_public,
+      updatedAt: row.updated_at
+    };
+  }
+
+  upsertSubscription(input, now = Date.now()) {
+    this.upsertSubscriptionStatement.run(
+      input.userId,
+      input.deviceId,
+      input.subscription.endpoint,
+      input.subscription.keys.p256dh,
+      input.subscription.keys.auth,
+      now
+    );
+  }
+
+  selectSubscription(userId, deviceId) {
+    return this.subscriptionFromRow(this.selectSubscriptionStatement.get(userId, deviceId));
+  }
+
+  selectSubscriptionsForUser(userId) {
+    return this.selectSubscriptionsForUserStatement.all(userId).map((row) => this.subscriptionFromRow(row));
+  }
+
+  deleteSubscription(userId, deviceId) {
+    this.deleteSubscriptionStatement.run(userId, deviceId);
+  }
+
+  deleteSubscriptionByEndpoint(userId, endpoint) {
+    this.deleteSubscriptionByEndpointStatement.run(userId, endpoint);
+  }
+
+  upsertGrant(input, now = Date.now()) {
+    this.upsertGrantStatement.run(input.userId, input.vapidPrivateKey, input.vapidPublicKey, now);
+  }
+
+  selectGrant(userId) {
+    return this.grantFromRow(this.selectGrantStatement.get(userId));
+  }
+
+  pendingPushFromRow(row) {
+    if (!row) return undefined;
+    try {
+      return {
+        pushId: row.push_id,
+        userId: row.user_id,
+        payload: JSON.parse(row.payload),
+        createdAt: row.created_at,
+        expiresAt: row.expires_at,
+        attempts: row.attempts
+      };
+    } catch {
+      return undefined;
+    }
+  }
+
+  upsertPendingPush(input, now = Date.now()) {
+    const ttlSeconds = Number.isInteger(input.ttlSeconds) && input.ttlSeconds > 0 ? input.ttlSeconds : 60 * 60;
+    const createdAt = Number.isInteger(input.createdAt) ? input.createdAt : now;
+    const expiresAt = Number.isInteger(input.expiresAt) ? input.expiresAt : createdAt + ttlSeconds * 1000;
+    this.upsertPendingPushStatement.run(input.pushId, input.userId, JSON.stringify(input.payload), createdAt, expiresAt);
+  }
+
+  selectPendingPushes(limit = 100, now = Date.now()) {
+    return this.selectPendingPushesStatement.all(now, limit).map((row) => this.pendingPushFromRow(row)).filter(Boolean);
+  }
+
+  deletePendingPush(pushId) {
+    this.deletePendingPushStatement.run(pushId);
+  }
+
+  incrementPendingPushAttempts(pushId) {
+    this.incrementPendingPushAttemptsStatement.run(pushId);
+  }
+
+  pruneExpiredPendingPushes(now = Date.now()) {
+    return this.pruneExpiredPendingPushesStatement.run(now).changes;
+  }
+
+  close() {
+    try {
+      this.db.close();
+    } catch {}
+  }
+}
+
+function createPushStorage(storagePath) {
+  return new PushStorage(storagePath);
+}
+
+module.exports = {
+  PushStorage,
+  createPushStorage,
+  sqliteFile
+};