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

package/src/ngramIndex.cjs

@@ -0,0 +1,198 @@
+const crypto = require("node:crypto");
+const { createSignedPartyEvent } = require("./signing.cjs");
+const { partyEventToNostrEvent } = require("./nostrMapping.cjs");
+
+const ROOM_INDEX_NGRAM_PAYLOAD_KIND = "matterhorn.room-index-ngram";
+const ROOM_INDEX_NGRAM_PAYLOAD_VERSION = 1;
+const ROOM_INDEX_NGRAM_SUITE = "matterhorn.ngram.hmac-sha256.v1";
+const DEFAULT_NGRAM_SIZE = 3;
+const DEFAULT_MAX_TOKENS_PER_EVENT = 96;
+const MAX_NGRAM_SIZE = 8;
+
+function keyBytes(roomIndexKey) {
+  const value = String(roomIndexKey || "").trim();
+  if (/^[0-9a-f]{64}$/i.test(value)) return Buffer.from(value, "hex");
+  return Buffer.from(value, "utf8");
+}
+
+function normalizeSearchText(value) {
+  return String(value || "")
+    .normalize("NFKD")
+    .replace(/[\u0300-\u036f]/g, "")
+    .toLowerCase()
+    .replace(/[^\p{Letter}\p{Number}]+/gu, " ")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+function integerOption(value, fallback, min, max) {
+  if (!Number.isInteger(value)) return fallback;
+  return Math.min(max, Math.max(min, value));
+}
+
+function ngramOptions(options = {}) {
+  const minGram = integerOption(options.minGram, DEFAULT_NGRAM_SIZE, 1, MAX_NGRAM_SIZE);
+  const maxGram = integerOption(options.maxGram, options.minGram === undefined ? DEFAULT_NGRAM_SIZE : minGram, minGram, MAX_NGRAM_SIZE);
+  return { minGram, maxGram };
+}
+
+function ngramsForText(value, options = {}) {
+  const { minGram, maxGram } = ngramOptions(options);
+  const normalized = normalizeSearchText(value);
+  if (!normalized) return [];
+  const grams = new Set();
+
+  for (let width = minGram; width <= maxGram; width += 1) {
+    if (normalized.length >= width) {
+      for (let index = 0; index <= normalized.length - width; index += 1) {
+        grams.add(`c${width}:${normalized.slice(index, index + width)}`);
+      }
+    }
+  }
+
+  // Short exact-word sentinels keep one- and two-character searches usable
+  // without forcing every one-character substring of every document into the index.
+  const words = normalized.split(" ").filter(Boolean);
+  for (const word of words) {
+    if (word.length < minGram) grams.add(`w:${word}`);
+  }
+
+  // If the whole query/body is shorter than the configured n-gram size, add a
+  // full-string token so exact short phrases can still be searched.
+  if (normalized.length < minGram) grams.add(`s:${normalized}`);
+
+  return Array.from(grams).sort();
+}
+
+function roomIndexKeyId(roomIndexKey) {
+  const hash = crypto.createHash("sha256")
+    .update(Buffer.from("matterhorn.room-index-key-id.v1\0", "utf8"))
+    .update(keyBytes(roomIndexKey))
+    .digest();
+  return hash.subarray(0, 16).toString("base64url");
+}
+
+function roomIndexToken(input) {
+  const roomIndexKey = input?.roomIndexKey;
+  const roomName = String(input?.roomName || "");
+  const gram = String(input?.gram || "");
+  const suite = input?.suite || ROOM_INDEX_NGRAM_SUITE;
+  if (!roomIndexKey) throw new Error("roomIndexKey is required");
+  if (!roomName) throw new Error("roomName is required");
+  if (!gram) throw new Error("gram is required");
+  return crypto.createHmac("sha256", keyBytes(roomIndexKey))
+    .update(suite)
+    .update("\0")
+    .update(roomName)
+    .update("\0")
+    .update(gram)
+    .digest("base64url");
+}
+
+function roomIndexTokensForText(input = {}) {
+  const roomIndexKey = input.roomIndexKey;
+  const roomName = String(input.roomName || "");
+  if (!roomIndexKey) throw new Error("roomIndexKey is required");
+  if (!roomName) throw new Error("roomName is required");
+  const suite = input.suite || ROOM_INDEX_NGRAM_SUITE;
+  const grams = ngramsForText(input.text, input);
+  return {
+    suite,
+    keyId: roomIndexKeyId(roomIndexKey),
+    minGram: ngramOptions(input).minGram,
+    maxGram: ngramOptions(input).maxGram,
+    grams,
+    tokens: grams.map((gram) => roomIndexToken({ roomIndexKey, roomName, gram, suite }))
+  };
+}
+
+function digestTokens(tokens) {
+  const hash = crypto.createHash("sha256");
+  for (const token of tokens.slice().sort()) {
+    hash.update(String(token));
+    hash.update("\0");
+  }
+  return `sha256:${hash.digest("hex")}`;
+}
+
+function chunkArray(values, size) {
+  const chunks = [];
+  for (let index = 0; index < values.length; index += size) chunks.push(values.slice(index, index + size));
+  return chunks.length > 0 ? chunks : [[]];
+}
+
+function buildRoomIndexNgramPayloads(input = {}) {
+  const roomName = String(input.roomName || "");
+  const targetEventId = String(input.targetEventId || "");
+  if (!roomName) throw new Error("roomName is required");
+  if (!/^[0-9a-f]{64}$/i.test(targetEventId)) throw new Error("targetEventId must be a Nostr event id");
+  const maxTokensPerEvent = integerOption(input.maxTokensPerEvent, DEFAULT_MAX_TOKENS_PER_EVENT, 1, 512);
+  const indexed = roomIndexTokensForText(input);
+  const tokens = Array.from(new Set(indexed.tokens)).sort();
+  if (tokens.length === 0) return [];
+  const chunks = chunkArray(tokens, maxTokensPerEvent);
+  const createdAt = Number.isInteger(input.createdAt) ? input.createdAt : Date.now();
+  const tokenDigest = digestTokens(tokens);
+  return chunks.map((chunkTokens, index) => ({
+    kind: ROOM_INDEX_NGRAM_PAYLOAD_KIND,
+    version: ROOM_INDEX_NGRAM_PAYLOAD_VERSION,
+    suite: indexed.suite,
+    roomName,
+    keyId: indexed.keyId,
+    targetEventId,
+    ...(input.targetOperationId ? { targetOperationId: String(input.targetOperationId) } : {}),
+    ...(input.targetHlc ? { targetHlc: String(input.targetHlc) } : {}),
+    ...(input.stream ? { stream: String(input.stream) } : {}),
+    ...(input.field ? { field: String(input.field) } : {}),
+    minGram: indexed.minGram,
+    maxGram: indexed.maxGram,
+    tokenCount: tokens.length,
+    tokenDigest,
+    chunk: { index, count: chunks.length },
+    tokens: chunkTokens,
+    createdAt
+  }));
+}
+
+function createRoomIndexNgramEvents(input = {}) {
+  const identity = input.identity;
+  const roomName = String(input.roomName || "");
+  if (!identity) throw new Error("identity is required");
+  const payloads = buildRoomIndexNgramPayloads(input);
+  return payloads.map((payload, index) => partyEventToNostrEvent(createSignedPartyEvent({
+    kind: "room.index.ngram",
+    partyId: roomName,
+    identity,
+    payload,
+    createdAt: (Number.isInteger(input.createdAt) ? input.createdAt : Date.now()) + index
+  })));
+}
+
+function roomIndexSearchQuery(input = {}) {
+  const indexed = roomIndexTokensForText(input);
+  return {
+    suite: indexed.suite,
+    keyId: indexed.keyId,
+    minGram: indexed.minGram,
+    maxGram: indexed.maxGram,
+    tokens: Array.from(new Set(indexed.tokens)).sort()
+  };
+}
+
+module.exports = {
+  DEFAULT_MAX_TOKENS_PER_EVENT,
+  DEFAULT_NGRAM_SIZE,
+  MAX_NGRAM_SIZE,
+  ROOM_INDEX_NGRAM_PAYLOAD_KIND,
+  ROOM_INDEX_NGRAM_PAYLOAD_VERSION,
+  ROOM_INDEX_NGRAM_SUITE,
+  buildRoomIndexNgramPayloads,
+  createRoomIndexNgramEvents,
+  digestTokens,
+  ngramsForText,
+  normalizeSearchText,
+  roomIndexKeyId,
+  roomIndexSearchQuery,
+  roomIndexToken,
+  roomIndexTokensForText
+};

package/src/ngramIndex.d.ts

@@ -0,0 +1,48 @@
+export const ROOM_INDEX_NGRAM_PAYLOAD_KIND: "matterhorn.room-index-ngram";
+export const ROOM_INDEX_NGRAM_PAYLOAD_VERSION: 1;
+export const ROOM_INDEX_NGRAM_SUITE: "matterhorn.ngram.hmac-sha256.v1";
+export const DEFAULT_NGRAM_SIZE: number;
+export const DEFAULT_MAX_TOKENS_PER_EVENT: number;
+export const MAX_NGRAM_SIZE: number;
+
+export type RoomIndexNgramOptions = {
+  minGram?: number;
+  maxGram?: number;
+};
+
+export type RoomIndexTextInput = RoomIndexNgramOptions & {
+  roomIndexKey: string;
+  roomName: string;
+  text: string;
+  suite?: typeof ROOM_INDEX_NGRAM_SUITE;
+};
+
+export type RoomIndexTokens = {
+  suite: typeof ROOM_INDEX_NGRAM_SUITE;
+  keyId: string;
+  minGram: number;
+  maxGram: number;
+  grams: string[];
+  tokens: string[];
+};
+
+export type BuildRoomIndexNgramPayloadInput = RoomIndexTextInput & {
+  identity?: unknown;
+  targetEventId: string;
+  targetOperationId?: string;
+  targetHlc?: string;
+  stream?: string;
+  field?: string;
+  maxTokensPerEvent?: number;
+  createdAt?: number;
+};
+
+export function normalizeSearchText(value: unknown): string;
+export function ngramsForText(value: unknown, options?: RoomIndexNgramOptions): string[];
+export function roomIndexKeyId(roomIndexKey: string): string;
+export function roomIndexToken(input: { roomIndexKey: string; roomName: string; gram: string; suite?: string }): string;
+export function roomIndexTokensForText(input: RoomIndexTextInput): RoomIndexTokens;
+export function digestTokens(tokens: string[]): string;
+export function roomIndexSearchQuery(input: RoomIndexTextInput): { suite: string; keyId: string; minGram: number; maxGram: number; tokens: string[] };
+export function buildRoomIndexNgramPayloads(input: BuildRoomIndexNgramPayloadInput): unknown[];
+export function createRoomIndexNgramEvents(input: BuildRoomIndexNgramPayloadInput & { identity: unknown }): unknown[];

package/src/ngramIndex.js

@@ -0,0 +1,17 @@
+import ngramIndex from "./ngramIndex.cjs";
+
+export const DEFAULT_MAX_TOKENS_PER_EVENT = ngramIndex.DEFAULT_MAX_TOKENS_PER_EVENT;
+export const DEFAULT_NGRAM_SIZE = ngramIndex.DEFAULT_NGRAM_SIZE;
+export const MAX_NGRAM_SIZE = ngramIndex.MAX_NGRAM_SIZE;
+export const ROOM_INDEX_NGRAM_PAYLOAD_KIND = ngramIndex.ROOM_INDEX_NGRAM_PAYLOAD_KIND;
+export const ROOM_INDEX_NGRAM_PAYLOAD_VERSION = ngramIndex.ROOM_INDEX_NGRAM_PAYLOAD_VERSION;
+export const ROOM_INDEX_NGRAM_SUITE = ngramIndex.ROOM_INDEX_NGRAM_SUITE;
+export const buildRoomIndexNgramPayloads = ngramIndex.buildRoomIndexNgramPayloads;
+export const createRoomIndexNgramEvents = ngramIndex.createRoomIndexNgramEvents;
+export const digestTokens = ngramIndex.digestTokens;
+export const ngramsForText = ngramIndex.ngramsForText;
+export const normalizeSearchText = ngramIndex.normalizeSearchText;
+export const roomIndexKeyId = ngramIndex.roomIndexKeyId;
+export const roomIndexSearchQuery = ngramIndex.roomIndexSearchQuery;
+export const roomIndexToken = ngramIndex.roomIndexToken;
+export const roomIndexTokensForText = ngramIndex.roomIndexTokensForText;

package/src/nostrMapping.cjs

@@ -0,0 +1,287 @@
+const crypto = require("node:crypto");
+const { getEventHash } = require("nostr-tools/pure");
+const { canonicalJson } = require("./canonicalJson.cjs");
+const {
+  MATTERHORN_EVENT_KIND_BY_NOSTR_KIND,
+  MATTERHORN_EVENT_KINDS,
+  MATTERHORN_NOSTR_KIND_BY_EVENT_KIND,
+  PROTOCOL,
+  VERSION
+} = require("./constants.cjs");
+
+function roomChannelEventId(partyId) {
+  return crypto.createHash("sha256").update(`matterhorn:nip28:channel:${partyId}`).digest("hex");
+}
+
+function unsignedFields(event) {
+  return {
+    protocol: event.protocol,
+    version: event.version,
+    kind: event.kind,
+    partyId: event.partyId,
+    pubkey: event.pubkey,
+    createdAt: event.createdAt,
+    payload: event.payload,
+    header: event.header
+  };
+}
+
+function dateSeconds(value) {
+  if (Number.isInteger(value)) return value > 10_000_000_000 ? Math.floor(value / 1000) : value;
+  if (typeof value !== "string" || !value.trim()) return undefined;
+  const parsed = Date.parse(value);
+  return Number.isFinite(parsed) ? Math.floor(parsed / 1000) : undefined;
+}
+
+function stringTag(tags, name, value, max = 500) {
+  if (typeof value !== "string") return;
+  const text = value.replace(/[\u0000-\u001f\u007f]/g, " ").replace(/\s+/g, " ").trim();
+  if (text) tags.push([name, text.slice(0, max)]);
+}
+
+function stringListTag(tags, name, values = []) {
+  if (!Array.isArray(values) || values.length === 0) return;
+  const filtered = values.filter((v) => typeof v === "string" && v.length > 0);
+  if (filtered.length === 0) return;
+  tags.push([name, ...filtered]);
+}
+
+function partyCreatedTags(unsigned, tags) {
+  const payload = unsigned.payload || {};
+  const start = dateSeconds(payload.start)
+    ?? dateSeconds(payload.startAt)
+    ?? dateSeconds(payload.date)
+    ?? Math.floor(unsigned.createdAt / 1000);
+  const end = dateSeconds(payload.end) ?? dateSeconds(payload.endAt);
+  tags.push(["title", typeof payload.title === "string" && payload.title.trim() ? payload.title.trim().slice(0, 200) : unsigned.partyId]);
+  tags.push(["start", String(start)]);
+  tags.push(["D", String(Math.floor(start / 86400))]);
+  stringTag(tags, "summary", payload.summary || payload.description, 700);
+  stringTag(tags, "location", payload.location, 300);
+  stringTag(tags, "g", payload.geohash || payload.geoHash, 80);
+  stringTag(tags, "start_tzid", payload.startTzid || payload.timezone, 80);
+  if (end && end > start) tags.push(["end", String(end)]);
+  stringTag(tags, "end_tzid", payload.endTzid || payload.timezone, 80);
+}
+
+function roomOperationTags(unsigned, tags) {
+  const h = unsigned.header || {};
+  tags.push(["scheme", "matterhorn.operation.v2"]);
+  stringTag(tags, "op-id", h.opId, 80);
+  stringTag(tags, "hlc", h.hlc, 80);
+  stringTag(tags, "plugin", h.plugin, 200);
+  stringTag(tags, "type", h.type, 200);
+  if (h.action) stringTag(tags, "action", h.action, 200);
+  stringTag(tags, "member", h.member, 200);
+  stringTag(tags, "device", h.device, 200);
+  stringTag(tags, "role", h.role, 80);
+  stringListTag(tags, "grants", h.grants);
+  stringTag(tags, "epoch", h.epoch, 80);
+  stringTag(tags, "stream", h.stream, 200);
+  if (typeof h.seq === "number" && Number.isInteger(h.seq) && h.seq >= 0) {
+    tags.push(["seq", String(h.seq)]);
+  }
+  stringTag(tags, "app-pack-id", h.appPackId, 200);
+  stringTag(tags, "app-pack-hash", h.appPackHash, 100);
+  stringTag(tags, "payload-hash", h.payloadHash, 80);
+}
+
+function roomKeyEpochTags(unsigned, tags) {
+  const p = unsigned.payload || {};
+  stringTag(tags, "epoch", p.id, 80);
+  if (typeof p.index === "number" && Number.isInteger(p.index) && p.index >= 0) {
+    tags.push(["epoch-index", String(p.index)]);
+  }
+  stringTag(tags, "member", p.createdBy, 200);
+  stringTag(tags, "room", unsigned.partyId, 200);
+}
+
+function roomKeyEpochGrantTags(unsigned, tags) {
+  const p = unsigned.payload || {};
+  stringTag(tags, "epoch", p.epochId, 80);
+  stringTag(tags, "member", p.recipientMemberId, 200);
+  stringTag(tags, "device", p.recipientDeviceId, 200);
+  stringTag(tags, "key", p.recipientEncryptionKeyId, 80);
+  stringTag(tags, "room", unsigned.partyId, 200);
+}
+
+function roomIndexKeyGrantTags(unsigned, tags) {
+  const p = unsigned.payload || {};
+  stringTag(tags, "member", p.recipientMemberId, 200);
+  stringTag(tags, "device", p.recipientDeviceId, 200);
+  stringTag(tags, "key", p.recipientEncryptionKeyId, 80);
+  stringTag(tags, "room", unsigned.partyId, 200);
+}
+
+
+function roomIndexNgramTags(unsigned, tags) {
+  const p = unsigned.payload || {};
+  stringTag(tags, "room", p.roomName || unsigned.partyId, 200);
+  stringTag(tags, "suite", p.suite, 120);
+  stringTag(tags, "key", p.keyId, 80);
+  stringTag(tags, "target", p.targetEventId, 128);
+  stringTag(tags, "target-operation-id", p.targetOperationId, 128);
+  stringTag(tags, "target-hlc", p.targetHlc, 128);
+  stringTag(tags, "stream", p.stream, 300);
+  stringTag(tags, "field", p.field, 120);
+  if (p.chunk && typeof p.chunk === "object") {
+    if (Number.isInteger(p.chunk.index) && p.chunk.index >= 0) tags.push(["chunk", String(p.chunk.index), String(p.chunk.count || 1)]);
+  }
+}
+
+function partyNostrTags(unsigned) {
+  const tags = [
+    ["protocol", PROTOCOL],
+    ["version", String(VERSION)],
+    ["d", unsigned.partyId],
+    ["created-at-ms", String(unsigned.createdAt)]
+  ];
+  if (unsigned.kind === "party.created") {
+    partyCreatedTags(unsigned, tags);
+  }
+  if (unsigned.kind === "chat.message") {
+    tags.push(["e", roomChannelEventId(unsigned.partyId), "", "root"]);
+    if (typeof unsigned.payload?.replyTo === "string") tags.push(["e", unsigned.payload.replyTo, "", "reply"]);
+  }
+  if (unsigned.kind === "chat.delete" && typeof unsigned.payload?.targetEventId === "string") {
+    tags.push(["e", unsigned.payload.targetEventId]);
+    tags.push(["k", String(MATTERHORN_NOSTR_KIND_BY_EVENT_KIND["chat.message"])]);
+  }
+  if (unsigned.kind === "relay.announce" && typeof unsigned.payload?.relayUrl === "string") {
+    tags.push(["r", unsigned.payload.relayUrl]);
+  }
+  if (unsigned.kind === "room.operation" && unsigned.header && typeof unsigned.header === "object") {
+    roomOperationTags(unsigned, tags);
+  }
+  if (unsigned.kind === "room.key.epoch") {
+    roomKeyEpochTags(unsigned, tags);
+  }
+  if (unsigned.kind === "room.key.epoch.grant") {
+    roomKeyEpochGrantTags(unsigned, tags);
+  }
+  if (unsigned.kind === "room.index.key.grant") {
+    roomIndexKeyGrantTags(unsigned, tags);
+  }
+  if (unsigned.kind === "room.index.ngram") {
+    roomIndexNgramTags(unsigned, tags);
+  }
+  return tags;
+}
+
+function tagValue(tags, name) {
+  const tag = tags.find((item) => Array.isArray(item) && item[0] === name);
+  return tag ? tag[1] : undefined;
+}
+
+function tagValues(tags, name) {
+  const vals = [];
+  for (const item of tags) {
+    if (Array.isArray(item) && item[0] === name && item.length > 1) {
+      vals.push(...item.slice(1));
+    }
+  }
+  return vals;
+}
+
+function matterhornKindFromNostrEvent(nostrEvent, tags) {
+  const legacyKind = tagValue(tags, "k");
+  if (legacyKind && MATTERHORN_EVENT_KINDS.has(legacyKind)) return legacyKind;
+  return MATTERHORN_EVENT_KIND_BY_NOSTR_KIND[nostrEvent.kind];
+}
+
+function headerFromTags(tags) {
+  const grants = tagValues(tags, "grants");
+  const header = {
+    scheme: tagValue(tags, "scheme") || undefined,
+    opId: tagValue(tags, "op-id") || undefined,
+    hlc: tagValue(tags, "hlc") || undefined,
+    plugin: tagValue(tags, "plugin") || undefined,
+    type: tagValue(tags, "type") || undefined,
+    action: tagValue(tags, "action") || undefined,
+    member: tagValue(tags, "member") || undefined,
+    device: tagValue(tags, "device") || undefined,
+    role: tagValue(tags, "role") || undefined,
+    grants: grants.length > 0 ? grants : undefined,
+    epoch: tagValue(tags, "epoch") || undefined,
+    stream: tagValue(tags, "stream") || undefined,
+    seq: (() => {
+      const raw = tagValue(tags, "seq");
+      if (!raw) return undefined;
+      const n = Number(raw);
+      return Number.isInteger(n) && n >= 0 ? n : undefined;
+    })(),
+    appPackId: tagValue(tags, "app-pack-id") || undefined,
+    appPackHash: tagValue(tags, "app-pack-hash") || undefined,
+    payloadHash: tagValue(tags, "payload-hash") || undefined
+  };
+  // Drop undefined values for canonical compactness.
+  const out = {};
+  for (const [k, v] of Object.entries(header)) {
+    if (v !== undefined) out[k] = v;
+  }
+  return Object.keys(out).length > 0 ? out : undefined;
+}
+
+function isControlPlaneKind(kind) {
+  return kind === "room.key.epoch" || kind === "room.key.epoch.grant" || kind === "room.index.key.grant" || kind === "room.index.ngram";
+}
+
+function partyEventToNostrTemplate(unsigned) {
+  const nostrKind = MATTERHORN_NOSTR_KIND_BY_EVENT_KIND[unsigned.kind];
+  if (!nostrKind) throw new Error("Unknown party event kind");
+  return {
+    kind: nostrKind,
+    created_at: Math.floor(unsigned.createdAt / 1000),
+    tags: partyNostrTags(unsigned),
+    content: isControlPlaneKind(unsigned.kind) ? canonicalJson(unsigned.payload || {}) : canonicalJson({ payload: unsigned.payload })
+  };
+}
+
+function partyEventToNostrEvent(event) {
+  return {
+    ...partyEventToNostrTemplate(unsignedFields(event)),
+    id: event.id,
+    pubkey: event.pubkey,
+    sig: event.sig
+  };
+}
+
+function nostrEventToPartyEvent(nostrEvent) {
+  const tags = Array.isArray(nostrEvent?.tags) ? nostrEvent.tags : [];
+  const content = JSON.parse(nostrEvent.content || "{}");
+  const kind = matterhornKindFromNostrEvent(nostrEvent, tags);
+  const header = kind === "room.operation" ? headerFromTags(tags) : undefined;
+  return {
+    protocol: tagValue(tags, "protocol"),
+    version: Number(tagValue(tags, "version")),
+    id: nostrEvent.id,
+    kind,
+    partyId: tagValue(tags, "d"),
+    pubkey: nostrEvent.pubkey,
+    createdAt: Number(tagValue(tags, "created-at-ms")),
+    payload: isControlPlaneKind(kind) ? content : content.payload,
+    header,
+    sig: nostrEvent.sig
+  };
+}
+
+function eventIdForUnsigned(unsigned) {
+  return getEventHash({
+    ...partyEventToNostrTemplate(unsigned),
+    pubkey: unsigned.pubkey
+  });
+}
+
+module.exports = {
+  eventIdForUnsigned,
+  headerFromTags,
+  nostrEventToPartyEvent,
+  partyEventToNostrEvent,
+  partyEventToNostrTemplate,
+  partyNostrTags,
+  roomChannelEventId,
+  roomOperationTags,
+  tagValue,
+  tagValues,
+  unsignedFields
+};

package/src/payload.cjs

@@ -0,0 +1,21 @@
+const { ENCRYPTION_ALG } = require("./constants.cjs");
+
+function isPlainObject(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+function isEncryptedPayload(value) {
+  return (
+    isPlainObject(value) &&
+    value.encrypted === true &&
+    value.alg === ENCRYPTION_ALG &&
+    (value.epochId === undefined || typeof value.epochId === "string") &&
+    typeof value.iv === "string" &&
+    typeof value.data === "string"
+  );
+}
+
+module.exports = {
+  isEncryptedPayload,
+  isPlainObject
+};

package/src/relayPolicy.cjs

@@ -0,0 +1,35 @@
+const { MATTERHORN_NOSTR_KINDS } = require("./constants.cjs");
+const { nostrEventToPartyEvent } = require("./nostrMapping.cjs");
+const { validatePartyEvent } = require("./validation.cjs");
+
+const MATTERHORN_EVENT_REQUIRED_NIPS = Object.freeze(["nip01", "nip09", "nip28", "nip52", "nip65", "nip94"]);
+
+function createPartyEventPolicy(validationOptions = {}) {
+  function partyEventPolicy(nostrEvent) {
+    if (!nostrEvent || typeof nostrEvent !== "object" || !MATTERHORN_NOSTR_KINDS.includes(nostrEvent.kind)) {
+      return { ok: false, code: "invalid", message: "Only matterhorn Nostr events are accepted" };
+    }
+
+    let partyEvent;
+    try {
+      partyEvent = nostrEventToPartyEvent(nostrEvent);
+    } catch {
+      return { ok: false, code: "invalid", message: "Invalid matterhorn Nostr event" };
+    }
+
+    const validation = validatePartyEvent(partyEvent, validationOptions);
+    if (!validation.ok) return validation;
+    return { ok: true, event: partyEvent };
+  }
+
+  partyEventPolicy.feature = Object.freeze({
+    name: "matterhorn-event",
+    requiredNips: MATTERHORN_EVENT_REQUIRED_NIPS
+  });
+  return partyEventPolicy;
+}
+
+module.exports = {
+  MATTERHORN_EVENT_REQUIRED_NIPS,
+  createPartyEventPolicy
+};

package/src/results.cjs

@@ -0,0 +1,12 @@
+function ok() {
+  return { ok: true };
+}
+
+function fail(code, message) {
+  return { ok: false, code, message };
+}
+
+module.exports = {
+  fail,
+  ok
+};