@mh-gg/relay-core 0.1.1-alpha.20260613T085325975Z

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@mh-gg/relay-core",
+  "version": "0.1.1-alpha.20260613T085325975Z",
+  "description": "Transport-independent Nostr relay core for matterhorn rooms.",
+  "type": "commonjs",
+  "main": "src/index.cjs",
+  "exports": {
+    ".": "./src/index.cjs"
+  },
+  "dependencies": {
+    "nostr-tools": "^2.23.5"
+  },
+  "engines": {
+    "node": ">=22.12"
+  },
+  "scripts": {
+    "test": "node --test test/*.test.cjs",
+    "coverage": "node --test --experimental-test-coverage --test-coverage-lines=80 --test-coverage-functions=80 --test-coverage-branches=80 --test-coverage-include=src/**/*.cjs test/*.test.cjs"
+  }
+}

package/src/addresses.cjs

@@ -0,0 +1,148 @@
+const crypto = require("node:crypto");
+
+const RELAY_ADDRESS_PREFIX = "peerjs:";
+const RELAY_MESH_SUFFIX = "-relay";
+const DEFAULT_SECURE_PORT = 443;
+const DEFAULT_INSECURE_PORT = 80;
+
+function normalizePeerId(peerId) {
+  const value = String(peerId || "").trim();
+  if (!value || !/^[a-zA-Z0-9_-]{1,128}$/.test(value)) return undefined;
+  return value;
+}
+
+function normalizePath(path) {
+  const value = String(path || "/").trim() || "/";
+  return value.startsWith("/") ? value : `/${value}`;
+}
+
+function normalizeSignalingConfig(signaling) {
+  if (!signaling) return undefined;
+  if (typeof signaling === "string") {
+    try {
+      const url = new URL(signaling);
+      if (url.protocol !== "ws:" && url.protocol !== "wss:") return undefined;
+      if (url.search || url.hash || !url.hostname) return undefined;
+      const secure = url.protocol === "wss:";
+      return {
+        host: url.hostname,
+        port: Number(url.port || (secure ? DEFAULT_SECURE_PORT : DEFAULT_INSECURE_PORT)),
+        path: normalizePath(url.pathname),
+        secure
+      };
+    } catch {
+      return undefined;
+    }
+  }
+  if (typeof signaling !== "object") return undefined;
+  const host = String(signaling.host || "").trim();
+  if (!host) return undefined;
+  const secure = signaling.secure !== false;
+  const port = Number(signaling.port || (secure ? DEFAULT_SECURE_PORT : DEFAULT_INSECURE_PORT));
+  if (!Number.isInteger(port) || port <= 0 || port > 65535) return undefined;
+  return {
+    host,
+    port,
+    path: normalizePath(signaling.path),
+    secure
+  };
+}
+
+function signalingUrl(signaling) {
+  const config = normalizeSignalingConfig(signaling);
+  if (!config) return undefined;
+  return `${config.secure ? "wss" : "ws"}://${config.host}:${config.port}${config.path}`;
+}
+
+function parseRelayAddress(address, defaultSignaling) {
+  if (typeof address !== "string") return undefined;
+  const trimmed = address.trim();
+  if (!trimmed) return undefined;
+  const raw = trimmed.startsWith(RELAY_ADDRESS_PREFIX) ? trimmed.slice(RELAY_ADDRESS_PREFIX.length) : trimmed;
+  const separatorIndex = raw.indexOf("@");
+  const peerId = normalizePeerId(separatorIndex >= 0 ? raw.slice(0, separatorIndex) : raw);
+  if (!peerId) return undefined;
+  const endpoint = separatorIndex >= 0 ? raw.slice(separatorIndex + 1) : undefined;
+  const signaling = normalizeSignalingConfig(endpoint || defaultSignaling);
+  if (endpoint && !signaling) return undefined;
+  const endpointUrl = signalingUrl(signaling);
+  return {
+    peerId,
+    signaling,
+    signalingUrl: endpointUrl,
+    address: endpointUrl ? `${RELAY_ADDRESS_PREFIX}${peerId}@${endpointUrl}` : `${RELAY_ADDRESS_PREFIX}${peerId}`
+  };
+}
+
+function relayAddressForPeerId(peerId, signaling) {
+  const value = normalizePeerId(peerId);
+  if (!value) return undefined;
+  const endpointUrl = signalingUrl(signaling);
+  return endpointUrl ? `${RELAY_ADDRESS_PREFIX}${value}@${endpointUrl}` : `${RELAY_ADDRESS_PREFIX}${value}`;
+}
+
+function relayMeshPeerIdForRoomPeerId(peerId) {
+  const value = normalizePeerId(peerId);
+  if (!value) return undefined;
+  return `${value.slice(0, 128 - RELAY_MESH_SUFFIX.length)}${RELAY_MESH_SUFFIX}`;
+}
+
+function relayMeshPeerIdFromAddressPeerId(peerId) {
+  const value = normalizePeerId(peerId);
+  if (!value) return undefined;
+  if (value.endsWith(RELAY_MESH_SUFFIX)) return value.slice(0, 128);
+  return `${value.slice(0, 128 - RELAY_MESH_SUFFIX.length)}${RELAY_MESH_SUFFIX}`;
+}
+
+function relayMeshAddressForPeerId(peerId, signaling) {
+  const meshPeerId = relayMeshPeerIdForRoomPeerId(peerId);
+  return meshPeerId ? relayAddressForPeerId(meshPeerId, signaling) : undefined;
+}
+
+function relayMeshAddressFromAddress(address, defaultSignaling) {
+  const parsed = parseRelayAddress(address, defaultSignaling);
+  const peerId = parsed?.peerId;
+  const meshPeerId = relayMeshPeerIdFromAddressPeerId(peerId);
+  return meshPeerId ? relayAddressForPeerId(meshPeerId, parsed?.signaling) : undefined;
+}
+
+function roomPeerAddressFromRelayAddress(address, defaultSignaling) {
+  const parsed = parseRelayAddress(address, defaultSignaling);
+  if (!parsed) return undefined;
+  const roomPeerId = parsed.peerId.endsWith(RELAY_MESH_SUFFIX)
+    ? parsed.peerId.slice(0, -RELAY_MESH_SUFFIX.length)
+    : parsed.peerId;
+  return relayAddressForPeerId(roomPeerId, parsed.signaling);
+}
+
+function peerIdFromRelayAddress(address) {
+  return parseRelayAddress(address)?.peerId;
+}
+
+function peerJsOptionsFromAddress(address, fallbackSignaling) {
+  const parsed = parseRelayAddress(address, fallbackSignaling);
+  if (!parsed?.signaling) return undefined;
+  return { ...parsed.signaling };
+}
+
+function randomRelayPeerId(roomName = "relay") {
+  const suffix = crypto.randomBytes(8).toString("base64url").toLowerCase().replace(/[^a-z0-9_-]/g, "");
+  return `matterhorn-${roomName}-${suffix}`.slice(0, 120);
+}
+
+module.exports = {
+  RELAY_ADDRESS_PREFIX,
+  RELAY_MESH_SUFFIX,
+  normalizeSignalingConfig,
+  parseRelayAddress,
+  peerIdFromRelayAddress,
+  peerJsOptionsFromAddress,
+  randomRelayPeerId,
+  relayAddressForPeerId,
+  relayMeshAddressFromAddress,
+  relayMeshAddressForPeerId,
+  relayMeshPeerIdFromAddressPeerId,
+  relayMeshPeerIdForRoomPeerId,
+  roomPeerAddressFromRelayAddress,
+  signalingUrl
+};

package/src/index.cjs

@@ -0,0 +1,10 @@
+module.exports = {
+  ...require("./addresses.cjs"),
+  ...require("./messages.cjs"),
+  ...require("./negentropy.cjs"),
+  ...require("./nips.cjs"),
+  ...require("./policies.cjs"),
+  ...require("./relayInfo.cjs"),
+  ...require("./relay.cjs"),
+  ...require("./validation.cjs")
+};

package/src/messages.cjs

@@ -0,0 +1,264 @@
+const { isNegentropyMessage } = require("./negentropy.cjs");
+
+const RELAY_CHUNK_BYTES = 10 * 1024;
+const RELAY_CHUNK_BACKPRESSURE_HIGH = 1024 * 1024;
+const RELAY_CHUNK_BACKPRESSURE_LOW = 512 * 1024;
+const RELAY_CHUNK_MAX_AGE_MS = 60_000;
+const RELAY_CHUNK_MAX_MESSAGES = 64;
+const RELAY_CHUNK_MAX_IN_FLIGHT_BYTES = 4 * 1024 * 1024;
+const RELAY_CHUNK_MAX_TOTAL_IN_FLIGHT_BYTES = 32 * 1024 * 1024;
+const RELAY_CHUNK_MAX_CHUNKS = 1024;
+const RELAY_SEND_QUEUE_MAX_MESSAGES = 256;
+const RELAY_SEND_QUEUE_MAX_BYTES = 4 * 1024 * 1024;
+
+const sendQueues = new WeakMap();
+const sendQueueStats = new WeakMap();
+let globalChunkBytes = 0;
+let chunkSeq = 0;
+
+function isNostrMessage(message) {
+  return Array.isArray(message) && (["EVENT", "REQ", "CLOSE", "IHAVE", "GRAFT"].includes(message[0]) || isNegentropyMessage(message));
+}
+
+function messageJsonByteLength(message) {
+  try {
+    return Buffer.byteLength(JSON.stringify(message), "utf8");
+  } catch {
+    return undefined;
+  }
+}
+
+function objectMessage(message) {
+  return message && typeof message === "object" && !Array.isArray(message) ? message : undefined;
+}
+
+function messageType(message) {
+  if (Array.isArray(message)) return typeof message[0] === "string" ? message[0] : "array";
+  return objectMessage(message)?.type || typeof message;
+}
+
+function chunkId(conn, message) {
+  chunkSeq += 1;
+  const peerId = conn?.MatterhornPeerId || conn?.peer || conn?.id || "conn";
+  return `${peerId}:${messageType(message)}:${Date.now()}:${chunkSeq}`;
+}
+
+function dataChannel(conn) {
+  return conn?.dataChannel || conn?._dc;
+}
+
+function waitForBufferedAmountLow(channel) {
+  if (!channel || channel.bufferedAmount <= RELAY_CHUNK_BACKPRESSURE_HIGH) return Promise.resolve();
+  return new Promise((resolve) => {
+    let done = false;
+    const finish = () => {
+      if (done) return;
+      done = true;
+      if (typeof channel.removeEventListener === "function") {
+        channel.removeEventListener("bufferedamountlow", finish);
+      }
+      if (channel.onbufferedamountlow === finish) channel.onbufferedamountlow = null;
+      resolve();
+    };
+    try {
+      channel.bufferedAmountLowThreshold = RELAY_CHUNK_BACKPRESSURE_LOW;
+      if (typeof channel.addEventListener === "function") channel.addEventListener("bufferedamountlow", finish, { once: true });
+      else channel.onbufferedamountlow = finish;
+    } catch {
+      setTimeout(finish, 10);
+    }
+  });
+}
+
+function sendRawMessage(conn, message) {
+  try {
+    if (!conn || conn.open === false || typeof conn.send !== "function") return false;
+    conn.send(message);
+    return true;
+  } catch {
+    // Closed WebRTC data channels are expected during mobile sleep/reconnects.
+    return false;
+  }
+}
+
+async function sendChunkedMessage(conn, message, json) {
+  const id = chunkId(conn, message);
+  const details = objectMessage(message);
+  const bytes = Buffer.from(json, "utf8");
+  const totalChunks = Math.ceil(bytes.length / RELAY_CHUNK_BYTES);
+  for (let offset = 0, index = 0; offset < bytes.length; offset += RELAY_CHUNK_BYTES, index += 1) {
+    await waitForBufferedAmountLow(dataChannel(conn));
+    const chunk = bytes.subarray(offset, offset + RELAY_CHUNK_BYTES);
+    sendRawMessage(conn, {
+      type: "relay.chunk",
+      protocol: 1,
+      id,
+      messageType: messageType(message),
+      roomName: details?.roomName,
+      clientId: details?.clientId,
+      index,
+      totalChunks,
+      byteLength: bytes.length,
+      encoding: "base64",
+      data: chunk.toString("base64")
+    });
+  }
+  await waitForBufferedAmountLow(dataChannel(conn));
+  sendRawMessage(conn, {
+    type: "relay.chunk",
+    protocol: 1,
+    id,
+    messageType: messageType(message),
+    roomName: details?.roomName,
+    clientId: details?.clientId,
+    done: true,
+    totalChunks,
+    byteLength: bytes.length
+  });
+}
+
+async function sendMessageNow(conn, message, json) {
+  const byteLength = Buffer.byteLength(json, "utf8");
+  if (byteLength > RELAY_CHUNK_BYTES) {
+    await sendChunkedMessage(conn, message, json);
+    return;
+  }
+  await waitForBufferedAmountLow(dataChannel(conn));
+  sendRawMessage(conn, message);
+}
+
+function sendMessage(conn, message) {
+  let json;
+  try {
+    json = JSON.stringify(message);
+  } catch {
+    return undefined;
+  }
+  if (typeof json !== "string") return undefined;
+
+  const channel = dataChannel(conn);
+  const previous = sendQueues.get(conn);
+  const byteLength = Buffer.byteLength(json, "utf8");
+  if (!previous && byteLength <= RELAY_CHUNK_BYTES && (!channel || channel.bufferedAmount <= RELAY_CHUNK_BACKPRESSURE_HIGH)) {
+    sendRawMessage(conn, message);
+    return undefined;
+  }
+
+  const maxQueuedMessages = Number.isInteger(conn?.maxQueuedMessages) && conn.maxQueuedMessages > 0 ? conn.maxQueuedMessages : RELAY_SEND_QUEUE_MAX_MESSAGES;
+  const maxQueuedBytes = Number.isInteger(conn?.maxQueuedBytes) && conn.maxQueuedBytes > 0 ? conn.maxQueuedBytes : RELAY_SEND_QUEUE_MAX_BYTES;
+  const stats = sendQueueStats.get(conn) || { messages: 0, bytes: 0 };
+  if (stats.messages + 1 > maxQueuedMessages || stats.bytes + byteLength > maxQueuedBytes) {
+    try { conn?.close?.(); } catch {}
+    return undefined;
+  }
+  stats.messages += 1;
+  stats.bytes += byteLength;
+  sendQueueStats.set(conn, stats);
+
+  const queued = (previous || Promise.resolve())
+    .catch(() => undefined)
+    .then(() => sendMessageNow(conn, message, json))
+    .catch(() => undefined)
+    .finally(() => {
+      const current = sendQueueStats.get(conn);
+      if (!current) return;
+      current.messages = Math.max(0, current.messages - 1);
+      current.bytes = Math.max(0, current.bytes - byteLength);
+      if (current.messages === 0 && current.bytes === 0) sendQueueStats.delete(conn);
+    });
+  sendQueues.set(conn, queued);
+  return queued;
+}
+
+function isRelayChunk(message) {
+  return objectMessage(message)?.type === "relay.chunk";
+}
+
+function createRelayChunkAssembler(options = {}) {
+  const chunks = new Map();
+  const maxBytes = Number.isInteger(options.maxBytes) && options.maxBytes > 0 ? options.maxBytes : undefined;
+  const maxAgeMs = Number.isInteger(options.maxAgeMs) && options.maxAgeMs > 0 ? options.maxAgeMs : RELAY_CHUNK_MAX_AGE_MS;
+  const maxMessages = Number.isInteger(options.maxMessages) && options.maxMessages > 0 ? options.maxMessages : RELAY_CHUNK_MAX_MESSAGES;
+  const maxInFlightBytes = Number.isInteger(options.maxInFlightBytes) && options.maxInFlightBytes > 0 ? options.maxInFlightBytes : RELAY_CHUNK_MAX_IN_FLIGHT_BYTES;
+  const maxGlobalInFlightBytes = Number.isInteger(options.maxGlobalInFlightBytes) && options.maxGlobalInFlightBytes > 0 ? options.maxGlobalInFlightBytes : RELAY_CHUNK_MAX_TOTAL_IN_FLIGHT_BYTES;
+  const maxChunks = Number.isInteger(options.maxChunks) && options.maxChunks > 0 ? options.maxChunks : RELAY_CHUNK_MAX_CHUNKS;
+  let inFlightBytes = 0;
+
+  function remove(id) {
+    const item = chunks.get(id);
+    if (!item) return;
+    inFlightBytes = Math.max(0, inFlightBytes - item.byteLength);
+    globalChunkBytes = Math.max(0, globalChunkBytes - item.byteLength);
+    chunks.delete(id);
+  }
+
+  function prune(now = Date.now()) {
+    for (const [id, item] of chunks) {
+      if (now - item.createdAt > maxAgeMs) remove(id);
+    }
+  }
+
+  function accept(message) {
+    if (!isRelayChunk(message)) return message;
+    if (typeof message.id !== "string" || !message.id) return undefined;
+    prune();
+
+    const byteLength = Number(message.byteLength);
+    if (!Number.isInteger(byteLength) || byteLength < 0 || (maxBytes && byteLength > maxBytes)) {
+      remove(message.id);
+      return undefined;
+    }
+
+    const totalChunks = Number(message.totalChunks);
+    if (!Number.isInteger(totalChunks) || totalChunks <= 0 || totalChunks > maxChunks) return undefined;
+
+    let item = chunks.get(message.id);
+    if (!item) {
+      if (chunks.size >= maxMessages || inFlightBytes + byteLength > maxInFlightBytes || globalChunkBytes + byteLength > maxGlobalInFlightBytes) return undefined;
+      item = { chunks: [], byteLength, createdAt: Date.now(), receivedBytes: 0, totalChunks };
+      chunks.set(message.id, item);
+      inFlightBytes += byteLength;
+      globalChunkBytes += byteLength;
+    }
+    if (item.byteLength !== byteLength || item.totalChunks !== totalChunks) {
+      remove(message.id);
+      return undefined;
+    }
+
+    if (!message.done) {
+      if (!Number.isInteger(message.index) || message.index < 0 || message.index >= totalChunks || message.encoding !== "base64" || typeof message.data !== "string") return undefined;
+      const chunk = Buffer.from(message.data, "base64");
+      if (!item.chunks[message.index]) item.receivedBytes += chunk.length;
+      if (item.receivedBytes > byteLength || (maxBytes && item.receivedBytes > maxBytes)) {
+        remove(message.id);
+        return undefined;
+      }
+      item.chunks[message.index] = chunk;
+      return undefined;
+    }
+
+    remove(message.id);
+    if (item.chunks.length !== totalChunks || item.chunks.some((chunk) => !Buffer.isBuffer(chunk))) return undefined;
+    const buffer = Buffer.concat(item.chunks);
+    if (buffer.length !== byteLength) return undefined;
+    try {
+      return JSON.parse(buffer.toString("utf8"));
+    } catch {
+      return undefined;
+    }
+  }
+
+  return {
+    accept,
+    prune
+  };
+}
+
+module.exports = {
+  RELAY_CHUNK_BYTES,
+  createRelayChunkAssembler,
+  isRelayChunk,
+  isNostrMessage,
+  messageJsonByteLength,
+  sendMessage
+};

package/src/negentropy.cjs

@@ -0,0 +1,45 @@
+const { nip77 } = require("nostr-tools");
+const { Negentropy, NegentropyStorageVector } = nip77;
+
+const NIP77_DEFAULT_FILTER = Object.freeze({});
+const NIP77_MAX_NEED_IDS = 200;
+
+function negentropyStorage(events, filter) {
+  const storage = new NegentropyStorageVector();
+  for (const event of events) {
+    if (filter && !filter(event)) continue;
+    storage.insert(event.created_at, event.id);
+  }
+  storage.seal();
+  return storage;
+}
+
+function createNegentropySession(events, filter) {
+  return {
+    negentropy: new Negentropy(negentropyStorage(events, filter)),
+    haveIds: [],
+    needIds: []
+  };
+}
+
+function tagValue(tags, name) {
+  const tag = Array.isArray(tags) ? tags.find((item) => Array.isArray(item) && item[0] === name) : undefined;
+  return tag ? tag[1] : undefined;
+}
+
+function createStreamNegentropySession(stream, events) {
+  return createNegentropySession(events, (event) => tagValue(event?.tags, "stream") === stream);
+}
+
+function isNegentropyMessage(message) {
+  return Array.isArray(message) && ["NEG-OPEN", "NEG-MSG", "NEG-CLOSE", "NEG-ERR"].includes(message[0]);
+}
+
+module.exports = {
+  NIP77_DEFAULT_FILTER,
+  NIP77_MAX_NEED_IDS,
+  createNegentropySession,
+  createStreamNegentropySession,
+  isNegentropyMessage,
+  negentropyStorage
+};

package/src/nips.cjs

@@ -0,0 +1,79 @@
+const SUBPATH_NIPS = Object.freeze([
+  "nip04",
+  "nip05",
+  "nip06",
+  "nip10",
+  "nip11",
+  "nip13",
+  "nip17",
+  "nip18",
+  "nip19",
+  "nip21",
+  "nip22",
+  "nip25",
+  "nip27",
+  "nip28",
+  "nip29",
+  "nip30",
+  "nip39",
+  "nip42",
+  "nip44",
+  "nip46",
+  "nip49",
+  "nip54",
+  "nip57",
+  "nip58",
+  "nip59",
+  "nip75",
+  "nip94",
+  "nip98",
+  "nip99",
+  "nipb7"
+]);
+const INDEX_NIPS = Object.freeze(["nip47", "nip77"]);
+const KIND_NIPS = Object.freeze(["nip09", "nip16", "nip52", "nip65"]);
+const SUPPORTED_NOSTR_TOOLS_NIPS = Object.freeze(["nip01", ...KIND_NIPS, ...SUBPATH_NIPS, ...INDEX_NIPS].sort());
+
+function normalizeNipName(value) {
+  return typeof value === "string" ? value.trim().toLowerCase() : "";
+}
+
+function hasNipSupport(name) {
+  return SUPPORTED_NOSTR_TOOLS_NIPS.includes(normalizeNipName(name));
+}
+
+function unsupportedNips(requiredNips = []) {
+  if (!Array.isArray(requiredNips)) return [];
+  const unsupported = [];
+  const seen = new Set();
+  for (const required of requiredNips) {
+    const name = normalizeNipName(required);
+    if (!name || seen.has(name)) continue;
+    seen.add(name);
+    if (!hasNipSupport(name)) unsupported.push(name);
+  }
+  return unsupported;
+}
+
+function loadNip(name) {
+  const normalized = normalizeNipName(name);
+  if (normalized === "nip01") {
+    return {
+      ...require("nostr-tools/pure"),
+      ...require("nostr-tools/filter"),
+      kinds: require("nostr-tools/kinds")
+    };
+  }
+  if (SUBPATH_NIPS.includes(normalized)) return require(`nostr-tools/${normalized}`);
+  if (INDEX_NIPS.includes(normalized)) return require("nostr-tools")[normalized];
+  if (KIND_NIPS.includes(normalized)) return require("nostr-tools/kinds");
+  return undefined;
+}
+
+module.exports = {
+  SUPPORTED_NOSTR_TOOLS_NIPS,
+  hasNipSupport,
+  loadNip,
+  normalizeNipName,
+  unsupportedNips
+};

package/src/policies.cjs

@@ -0,0 +1,84 @@
+const { normalizeNipName, unsupportedNips } = require("./nips.cjs");
+
+function normalizeRequiredNips(requiredNips = []) {
+  if (!Array.isArray(requiredNips)) return [];
+  const normalized = [];
+  const seen = new Set();
+  for (const required of requiredNips) {
+    const name = normalizeNipName(required);
+    if (!name || seen.has(name)) continue;
+    seen.add(name);
+    normalized.push(name);
+  }
+  return normalized;
+}
+
+function ok() {
+  return { ok: true };
+}
+
+function reject(code, message) {
+  return { ok: false, code, message };
+}
+
+function createFeaturePolicy(options = {}) {
+  const name = typeof options.name === "string" && options.name.trim() ? options.name.trim() : "nostr-feature";
+  const requiredNips = Object.freeze(normalizeRequiredNips(options.requiredNips));
+  const unsupported = unsupportedNips(requiredNips);
+  const validate = typeof options.validate === "function" ? options.validate : ok;
+
+  function featurePolicy(nostrEvent, context = {}) {
+    if (unsupported.length > 0) {
+      return reject("unsupported-nips", `${name} requires unsupported Nostr NIPs: ${unsupported.join(", ")}`);
+    }
+    const result = validate(nostrEvent, context);
+    if (!result || result.ok !== false) return ok();
+    return reject(result.code || "policy-rejected", result.message || `${name} rejected this Nostr event`);
+  }
+
+  featurePolicy.feature = Object.freeze({ name, requiredNips });
+  return featurePolicy;
+}
+
+function eventPoliciesFromOptions(...sources) {
+  const policies = [];
+  for (const source of sources) {
+    if (!source || typeof source !== "object") continue;
+    if (typeof source.eventPolicy === "function") policies.push(source.eventPolicy);
+    if (Array.isArray(source.eventPolicies)) {
+      for (const policy of source.eventPolicies) {
+        if (typeof policy === "function") policies.push(policy);
+      }
+    }
+  }
+  return policies;
+}
+
+function featurePolicyUnsupportedNips(policy) {
+  const requiredNips = normalizeRequiredNips(policy?.feature?.requiredNips);
+  return unsupportedNips(requiredNips);
+}
+
+function validateEventPolicies(nostrEvent, context = {}, policies = []) {
+  for (const policy of policies) {
+    const unsupported = featurePolicyUnsupportedNips(policy);
+    if (unsupported.length > 0) {
+      const featureName = policy.feature?.name || "nostr-feature";
+      return reject("unsupported-nips", `${featureName} requires unsupported Nostr NIPs: ${unsupported.join(", ")}`);
+    }
+
+    const result = policy(nostrEvent, context);
+    if (result?.ok === false) {
+      return reject(result.code || "policy-rejected", result.message || "Nostr event rejected by feature policy");
+    }
+  }
+  return ok();
+}
+
+module.exports = {
+  createFeaturePolicy,
+  eventPoliciesFromOptions,
+  featurePolicyUnsupportedNips,
+  normalizeRequiredNips,
+  validateEventPolicies
+};