@hashtree/nostr 0.1.14 → 0.2.6

package/src/snapshot.ts

@@ -0,0 +1,214 @@
+import { objectKeyFromHex } from '@hashtree/core';
+import { HashTree, cid, fromHex, type CID, type Store, type TreeVisibility } from '@hashtree/core';
+import type { StoredNostrEvent } from './events.js';
+
+const HEX_64 = /^[0-9a-f]{64}$/;
+const HEX_128 = /^[0-9a-f]{128}$/;
+const MAX_SNAPSHOT_BYTES = 256 * 1024;
+const textEncoder = new TextEncoder();
+const textDecoder = new TextDecoder();
+
+export const HASHTREE_ROOT_KIND = 30064;
+export const HASHTREE_LEGACY_ROOT_KIND = 30078;
+export const HASHTREE_ROOT_KINDS = [HASHTREE_ROOT_KIND, HASHTREE_LEGACY_ROOT_KIND] as const;
+export const HASHTREE_LABEL = 'hashtree';
+
+export function isHashtreeRootKind(kind: number): boolean {
+  return kind === HASHTREE_ROOT_KIND || kind === HASHTREE_LEGACY_ROOT_KIND;
+}
+
+export interface ParsedHashtreeRootEvent {
+  event: StoredNostrEvent;
+  treeName: string;
+  rootCid: CID;
+  visibility: TreeVisibility;
+  labels: string[];
+  encryptedKey?: string;
+  keyId?: string;
+  selfEncryptedKey?: string;
+  selfEncryptedLinkKey?: string;
+}
+
+export interface SnapshotTreeLike {
+  putFile(
+    data: Uint8Array,
+    options?: { unencrypted?: boolean },
+  ): Promise<{ cid: CID; size: number }>;
+  readFileRange(id: CID, start: number, end?: number): Promise<Uint8Array | null>;
+}
+
+export type SnapshotTarget = Store | SnapshotTreeLike;
+
+function isSnapshotTreeLike(target: SnapshotTarget): target is SnapshotTreeLike {
+  return (
+    typeof (target as SnapshotTreeLike).putFile === 'function' &&
+    typeof (target as SnapshotTreeLike).readFileRange === 'function'
+  );
+}
+
+function getSnapshotTree(target: SnapshotTarget): SnapshotTreeLike {
+  if (isSnapshotTreeLike(target)) {
+    return target;
+  }
+  return new HashTree({ store: target });
+}
+
+function assertStringTags(tags: unknown): asserts tags is string[][] {
+  if (!Array.isArray(tags)) {
+    throw new Error('Nostr event tags must be an array');
+  }
+  for (const tag of tags) {
+    if (!Array.isArray(tag) || tag.some((value) => typeof value !== 'string')) {
+      throw new Error('Nostr event tags must be an array of string arrays');
+    }
+  }
+}
+
+function uniqueLabels(labels: string[]): string[] {
+  const seen = new Set<string>();
+  const result: string[] = [];
+  for (const label of labels) {
+    if (!label || seen.has(label)) continue;
+    seen.add(label);
+    result.push(label);
+  }
+  return result;
+}
+
+export function normalizeSignedNostrEvent(event: StoredNostrEvent): StoredNostrEvent {
+  const { id, pubkey, created_at, kind, tags, content, sig } = event;
+  if (!HEX_64.test(id)) {
+    throw new Error('Nostr event id must be a lowercase 64-character hex string');
+  }
+  if (!HEX_64.test(pubkey)) {
+    throw new Error('Nostr event pubkey must be a lowercase 64-character hex string');
+  }
+  if (!Number.isInteger(created_at) || created_at < 0) {
+    throw new Error('Nostr event created_at must be a non-negative integer');
+  }
+  if (!Number.isInteger(kind) || kind < 0) {
+    throw new Error('Nostr event kind must be a non-negative integer');
+  }
+  assertStringTags(tags);
+  if (typeof content !== 'string') {
+    throw new Error('Nostr event content must be a string');
+  }
+  if (!HEX_128.test(sig)) {
+    throw new Error('Nostr event sig must be a lowercase 128-character hex string');
+  }
+
+  return {
+    id,
+    pubkey,
+    created_at,
+    kind,
+    tags: tags.map((tag) => [...tag]),
+    content,
+    sig,
+  };
+}
+
+export function encodeSignedNostrEventJson(event: StoredNostrEvent): Uint8Array {
+  const normalized = normalizeSignedNostrEvent(event);
+  return textEncoder.encode(JSON.stringify({
+    id: normalized.id,
+    pubkey: normalized.pubkey,
+    created_at: normalized.created_at,
+    kind: normalized.kind,
+    tags: normalized.tags,
+    content: normalized.content,
+    sig: normalized.sig,
+  }));
+}
+
+export function decodeSignedNostrEventJson(data: Uint8Array): StoredNostrEvent {
+  const parsed = JSON.parse(textDecoder.decode(data)) as Record<string, unknown>;
+  return normalizeSignedNostrEvent({
+    id: typeof parsed.id === 'string' ? parsed.id : '',
+    pubkey: typeof parsed.pubkey === 'string' ? parsed.pubkey : '',
+    created_at: typeof parsed.created_at === 'number' ? parsed.created_at : NaN,
+    kind: typeof parsed.kind === 'number' ? parsed.kind : NaN,
+    tags: parsed.tags,
+    content: typeof parsed.content === 'string' ? parsed.content : '',
+    sig: typeof parsed.sig === 'string' ? parsed.sig : '',
+  } as StoredNostrEvent);
+}
+
+export async function storeSignedNostrEventSnapshot(target: SnapshotTarget, event: StoredNostrEvent): Promise<CID> {
+  const tree = getSnapshotTree(target);
+  return (await tree.putFile(encodeSignedNostrEventJson(event), { unencrypted: true })).cid;
+}
+
+export async function readSignedNostrEventSnapshot(
+  target: SnapshotTarget,
+  snapshotCid: CID,
+  maxBytes = MAX_SNAPSHOT_BYTES,
+): Promise<StoredNostrEvent> {
+  const tree = getSnapshotTree(target);
+  const bytes = await tree.readFileRange(snapshotCid, 0, maxBytes + 1);
+  if (!bytes) {
+    throw new Error('Signed Nostr event snapshot is missing');
+  }
+  if (bytes.length > maxBytes) {
+    throw new Error(`Signed Nostr event snapshot exceeds ${maxBytes} bytes`);
+  }
+  return decodeSignedNostrEventJson(bytes);
+}
+
+function hasLabel(event: Pick<StoredNostrEvent, 'tags'>, label: string): boolean {
+  return event.tags.some((tag) => tag[0] === 'l' && tag[1] === label);
+}
+
+function hasAnyLabel(event: Pick<StoredNostrEvent, 'tags'>): boolean {
+  return event.tags.some((tag) => tag[0] === 'l');
+}
+
+export function parseHashtreeRootEvent(event: StoredNostrEvent): ParsedHashtreeRootEvent | null {
+  const normalized = normalizeSignedNostrEvent(event);
+  if (!isHashtreeRootKind(normalized.kind)) {
+    return null;
+  }
+
+  const treeName = normalized.tags.find((tag) => tag[0] === 'd')?.[1];
+  const hashHex = normalized.tags.find((tag) => tag[0] === 'hash')?.[1];
+  if (!treeName || !hashHex || !HEX_64.test(hashHex)) {
+    return null;
+  }
+
+  if (hasAnyLabel(normalized) && !hasLabel(normalized, HASHTREE_LABEL)) {
+    return null;
+  }
+
+  const labels = uniqueLabels(
+    normalized.tags
+      .filter((tag) => tag[0] === 'l' && typeof tag[1] === 'string' && tag[1].length > 0)
+      .map((tag) => tag[1]!)
+  );
+  const keyHex = normalized.tags.find((tag) => tag[0] === 'key')?.[1];
+  const encryptedKey = normalized.tags.find((tag) => tag[0] === 'encryptedKey')?.[1];
+  const keyId = normalized.tags.find((tag) => tag[0] === 'keyId')?.[1];
+  const selfEncryptedKey = normalized.tags.find((tag) => tag[0] === 'selfEncryptedKey')?.[1];
+  const selfEncryptedLinkKey = normalized.tags.find((tag) => tag[0] === 'selfEncryptedLinkKey')?.[1];
+
+  const visibility: TreeVisibility = encryptedKey
+    ? 'link-visible'
+    : selfEncryptedKey
+      ? 'private'
+      : 'public';
+
+  try {
+    return {
+      event: normalized,
+      treeName,
+      rootCid: cid(fromHex(hashHex), visibility === 'public' && keyHex !== undefined ? objectKeyFromHex(keyHex) : undefined),
+      visibility,
+      labels,
+      encryptedKey,
+      keyId,
+      selfEncryptedKey,
+      selfEncryptedLinkKey,
+    };
+  } catch {
+    return null;
+  }
+}

package/src/treeEventSnapshotPermalinks.ts

@@ -0,0 +1,150 @@
+import { nhashDecode } from '@hashtree/core';
+
+const NHASH_PATTERN = /^nhash1[a-z0-9]+$/;
+const LINK_KEY_PATTERN = /^(?:[a-f0-9]{2}){32,33}$/i;
+
+export interface TreeEventSnapshotPermalink {
+  snapshotNhash: string;
+  path: string[];
+  linkKey?: string;
+}
+
+export interface BuildTreeEventSnapshotPermalinkOptions {
+  prefix?: string;
+}
+
+function safeDecode(value: string): string {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+
+function extractPermalinkCandidate(input: string | URL): string {
+  const raw = `${input instanceof URL ? input.toString() : input}`.trim();
+  if (!raw) {
+    return '';
+  }
+
+  try {
+    const parsed = input instanceof URL ? input : new URL(raw);
+    if (parsed.hash.startsWith('#/')) {
+      return parsed.hash.slice(1);
+    }
+    return `/${parsed.host}${parsed.pathname}${parsed.search}`;
+  } catch {
+    if (raw.startsWith('#/')) {
+      return raw.slice(1);
+    }
+    return raw;
+  }
+}
+
+function normalizeSnapshotNhash(value: string): string | null {
+  const trimmed = value.trim();
+  if (!NHASH_PATTERN.test(trimmed)) {
+    return null;
+  }
+
+  try {
+    const decoded = nhashDecode(trimmed);
+    if (decoded.key) {
+      return null;
+    }
+    return trimmed;
+  } catch {
+    return null;
+  }
+}
+
+export function normalizeTreeEventSnapshotLinkKey(value?: string | null): string | null {
+  const trimmed = value?.trim();
+  if (!trimmed) {
+    return null;
+  }
+  if (!LINK_KEY_PATTERN.test(trimmed)) {
+    return null;
+  }
+  return trimmed.toLowerCase();
+}
+
+function normalizeTreeEventSnapshotPermalink(
+  value: TreeEventSnapshotPermalink,
+): TreeEventSnapshotPermalink {
+  const snapshotNhash = normalizeSnapshotNhash(value.snapshotNhash);
+  if (!snapshotNhash) {
+    throw new Error(`Invalid tree event snapshot nhash: ${value.snapshotNhash}`);
+  }
+
+  const linkKey = normalizeTreeEventSnapshotLinkKey(value.linkKey);
+  if (value.linkKey?.trim() && !linkKey) {
+    throw new Error('Invalid tree event snapshot link key');
+  }
+
+  return {
+    snapshotNhash,
+    path: value.path.filter(Boolean),
+    ...(linkKey ? { linkKey } : {}),
+  };
+}
+
+export function buildTreeEventSnapshotPermalink(
+  value: TreeEventSnapshotPermalink,
+  options: BuildTreeEventSnapshotPermalinkOptions = {},
+): string {
+  const normalized = normalizeTreeEventSnapshotPermalink(value);
+  const encodedPath = normalized.path.map((part) => encodeURIComponent(part)).join('/');
+  const query = new URLSearchParams();
+  query.set('snapshot', '1');
+  if (normalized.linkKey) {
+    query.set('k', normalized.linkKey);
+  }
+  const prefix = options.prefix ?? '';
+  return `${prefix}${normalized.snapshotNhash}${encodedPath ? `/${encodedPath}` : ''}?${query.toString()}`;
+}
+
+export function parseTreeEventSnapshotPermalink(input: string | URL): TreeEventSnapshotPermalink | null {
+  const candidate = extractPermalinkCandidate(input);
+  if (!candidate) {
+    return null;
+  }
+
+  const [pathPart, queryPart = ''] = candidate.split('?', 2);
+  const parts = pathPart
+    .replace(/^\/+/, '')
+    .split('/')
+    .filter(Boolean)
+    .map(safeDecode);
+
+  if (parts[0] === 'nhash') {
+    parts.shift();
+  }
+
+  const snapshotNhash = parts.shift();
+  if (!snapshotNhash) {
+    return null;
+  }
+
+  const normalizedSnapshotNhash = normalizeSnapshotNhash(snapshotNhash);
+  if (!normalizedSnapshotNhash) {
+    return null;
+  }
+
+  const params = new URLSearchParams(queryPart);
+  if (params.get('snapshot')?.trim() !== '1') {
+    return null;
+  }
+
+  const rawLinkKey = params.get('k');
+  const linkKey = normalizeTreeEventSnapshotLinkKey(rawLinkKey);
+  if (rawLinkKey?.trim() && !linkKey) {
+    return null;
+  }
+
+  return {
+    snapshotNhash: normalizedSnapshotNhash,
+    path: parts,
+    ...(linkKey ? { linkKey } : {}),
+  };
+}

package/src/treeEventSnapshots.ts

@@ -0,0 +1,283 @@
+import {
+  decryptKeyFromLink,
+  fromHex,
+  nhashEncode,
+  toHex,
+  type CID,
+} from '@hashtree/core';
+import type { StoredNostrEvent } from './events.js';
+import { normalizeTreeEventSnapshotLinkKey } from './treeEventSnapshotPermalinks.js';
+import { compareReplaceableEvents } from './eventKeys.js';
+import type { Nip19Like, NostrFilter } from './resolver/nostr.js';
+import {
+  HASHTREE_ROOT_KINDS,
+  parseHashtreeRootEvent,
+  readSignedNostrEventSnapshot,
+  storeSignedNostrEventSnapshot,
+  type ParsedHashtreeRootEvent,
+  type SnapshotTarget,
+} from './snapshot.js';
+
+const DEFAULT_SNAPSHOT_FETCH_LIMIT = 20;
+
+export interface TreeEventSnapshotInfo extends ParsedHashtreeRootEvent {
+  snapshotCid: CID;
+  snapshotNhash: string;
+  npub: string;
+}
+
+export interface TreeEventSnapshotQuery extends NostrFilter {
+  limit?: number;
+}
+
+export interface FetchLatestTreeEventSnapshotConfig {
+  snapshotTarget: SnapshotTarget;
+  nip19: Nip19Like;
+  fetchEvents: (filter: TreeEventSnapshotQuery) => Promise<StoredNostrEvent[]>;
+  snapshotFetchLimit?: number;
+}
+
+export interface WatchTreeEventSnapshotsConfig extends FetchLatestTreeEventSnapshotConfig {
+  subscribeEvents: (
+    filter: TreeEventSnapshotQuery,
+    onEvent: (event: StoredNostrEvent) => void,
+  ) => () => void;
+}
+
+function snapshotInfoFromParsed(
+  parsed: ParsedHashtreeRootEvent,
+  snapshotCid: CID,
+  nip19: Nip19Like,
+): TreeEventSnapshotInfo {
+  return {
+    ...parsed,
+    snapshotCid,
+    snapshotNhash: nhashEncode(snapshotCid),
+    npub: nip19.npubEncode(parsed.event.pubkey),
+  };
+}
+
+function tryParseHashtreeRootEvent(event: StoredNostrEvent): ParsedHashtreeRootEvent | null {
+  try {
+    return parseHashtreeRootEvent(event);
+  } catch {
+    return null;
+  }
+}
+
+function normalizeLinkKey(linkKey?: string | Uint8Array | null): Uint8Array | null {
+  if (!linkKey) {
+    return null;
+  }
+  if (typeof linkKey !== 'string') return linkKey;
+  const hex = normalizeTreeEventSnapshotLinkKey(linkKey);
+  return hex ? fromHex(hex) : null;
+}
+
+function isValidTreeEventFor(
+  event: StoredNostrEvent,
+  pubkey: string,
+  treeName: string,
+): boolean {
+  if (event.pubkey !== pubkey) {
+    return false;
+  }
+  const parsed = tryParseHashtreeRootEvent(event);
+  return parsed?.treeName === treeName;
+}
+
+export function compareTreeEventSnapshots(a: TreeEventSnapshotInfo, b: TreeEventSnapshotInfo): number {
+  return compareReplaceableEvents(a.event, b.event);
+}
+
+export function isNewerTreeEventSnapshot(
+  candidate: TreeEventSnapshotInfo,
+  current: TreeEventSnapshotInfo,
+): boolean {
+  return compareTreeEventSnapshots(candidate, current) > 0;
+}
+
+export function snapshotMatchesRootCid(
+  snapshot: TreeEventSnapshotInfo | null | undefined,
+  rootCid: CID | null | undefined,
+): boolean {
+  if (!snapshot || !rootCid) {
+    return false;
+  }
+  if (toHex(snapshot.rootCid.hash) !== toHex(rootCid.hash)) {
+    return false;
+  }
+  if (snapshot.visibility !== 'public') {
+    return true;
+  }
+  const snapshotKey = snapshot.rootCid.key ? toHex(snapshot.rootCid.key) : null;
+  const rootKey = rootCid.key ? toHex(rootCid.key) : null;
+  if (snapshotKey === null || rootKey === null) {
+    return true;
+  }
+  return snapshotKey === rootKey;
+}
+
+export async function resolveSnapshotRootCid(
+  snapshot: TreeEventSnapshotInfo,
+  linkKey?: string | Uint8Array | null,
+): Promise<CID | null> {
+  if (snapshot.visibility === 'public') {
+    return snapshot.rootCid;
+  }
+
+  if (snapshot.visibility === 'link-visible' && snapshot.encryptedKey) {
+    const normalizedLinkKey = normalizeLinkKey(linkKey);
+    if (!normalizedLinkKey) {
+      return null;
+    }
+    try {
+      const decryptedKey = await decryptKeyFromLink(
+        fromHex(snapshot.encryptedKey),
+        normalizedLinkKey,
+      );
+      if (decryptedKey) {
+        return { hash: snapshot.rootCid.hash, key: decryptedKey };
+      }
+    } catch {
+      return null;
+    }
+  }
+
+  return null;
+}
+
+export async function storeTreeEventSnapshot(
+  snapshotTarget: SnapshotTarget,
+  nip19: Nip19Like,
+  event: StoredNostrEvent,
+): Promise<TreeEventSnapshotInfo | null> {
+  const parsed = tryParseHashtreeRootEvent(event);
+  if (!parsed) {
+    return null;
+  }
+  const snapshotCid = await storeSignedNostrEventSnapshot(snapshotTarget, parsed.event);
+  return snapshotInfoFromParsed(parsed, snapshotCid, nip19);
+}
+
+export async function readTreeEventSnapshot(
+  snapshotTarget: SnapshotTarget,
+  nip19: Nip19Like,
+  snapshotCid: CID,
+  maxBytes?: number,
+): Promise<TreeEventSnapshotInfo | null> {
+  try {
+    const event = await readSignedNostrEventSnapshot(snapshotTarget, snapshotCid, maxBytes);
+    const parsed = tryParseHashtreeRootEvent(event);
+    if (!parsed) {
+      return null;
+    }
+    return snapshotInfoFromParsed(parsed, snapshotCid, nip19);
+  } catch {
+    return null;
+  }
+}
+
+export async function fetchLatestTreeEventSnapshot(
+  config: FetchLatestTreeEventSnapshotConfig,
+  npub: string,
+  treeName: string,
+): Promise<TreeEventSnapshotInfo | null> {
+  let decoded;
+  try {
+    decoded = config.nip19.decode(npub);
+  } catch {
+    return null;
+  }
+  if (decoded.type !== 'npub' || typeof decoded.data !== 'string') {
+    return null;
+  }
+
+  const events = await config.fetchEvents({
+    kinds: [...HASHTREE_ROOT_KINDS],
+    authors: [decoded.data],
+    '#d': [treeName],
+    limit: config.snapshotFetchLimit ?? DEFAULT_SNAPSHOT_FETCH_LIMIT,
+  });
+
+  const candidates: StoredNostrEvent[] = [];
+  for (const event of events) {
+    if (!isValidTreeEventFor(event, decoded.data, treeName)) {
+      continue;
+    }
+    candidates.push(event);
+  }
+  if (candidates.length === 0) {
+    return null;
+  }
+
+  candidates.sort(compareReplaceableEvents);
+  return storeTreeEventSnapshot(config.snapshotTarget, config.nip19, candidates[candidates.length - 1]!);
+}
+
+export function watchLatestTreeEventSnapshot(
+  config: WatchTreeEventSnapshotsConfig,
+  npub: string,
+  treeName: string,
+  onSnapshot: (snapshot: TreeEventSnapshotInfo) => void | Promise<void>,
+): () => void {
+  let decoded;
+  try {
+    decoded = config.nip19.decode(npub);
+  } catch {
+    return () => {};
+  }
+  if (decoded.type !== 'npub' || typeof decoded.data !== 'string') {
+    return () => {};
+  }
+  const pubkey = decoded.data;
+
+  let closed = false;
+  let latestSnapshot: TreeEventSnapshotInfo | null = null;
+
+  const emitIfNewer = async (event: StoredNostrEvent): Promise<void> => {
+    if (closed || !isValidTreeEventFor(event, pubkey, treeName)) {
+      return;
+    }
+
+    const snapshot = await storeTreeEventSnapshot(config.snapshotTarget, config.nip19, event);
+    if (!snapshot) {
+      return;
+    }
+    if (latestSnapshot && compareTreeEventSnapshots(snapshot, latestSnapshot) <= 0) {
+      return;
+    }
+
+    latestSnapshot = snapshot;
+    await onSnapshot(snapshot);
+  };
+
+  fetchLatestTreeEventSnapshot(config, npub, treeName)
+    .then(async (snapshot) => {
+      if (closed || !snapshot) {
+        return;
+      }
+      if (latestSnapshot && compareTreeEventSnapshots(snapshot, latestSnapshot) <= 0) {
+        return;
+      }
+      latestSnapshot = snapshot;
+      await onSnapshot(snapshot);
+    })
+    .catch(() => {});
+
+  const unsubscribe = config.subscribeEvents(
+    {
+      kinds: [...HASHTREE_ROOT_KINDS],
+      authors: [pubkey],
+      '#d': [treeName],
+    },
+    (event) => {
+      void emitIfNewer(event);
+    },
+  );
+
+  return () => {
+    closed = true;
+    unsubscribe();
+  };
+}

package/dist/webrtc/index.d.ts

@@ -1,6 +0,0 @@
-export { WebRTCStore, DEFAULT_RELAYS } from './store.js';
-export { Peer } from './peer.js';
-export { PeerSelector, peerPrincipal, normalizeDispatchConfig, buildHedgedWavePlan, syncSelectorPeers, } from './peerSelector.js';
-export { PeerId, generateUuid, WEBRTC_KIND, MAX_HTL, HtlMode, type HtlPolicy, BLOB_REQUEST_POLICY, MESH_EVENT_POLICY, MESH_PROTOCOL, MESH_PROTOCOL_VERSION, MESH_DEFAULT_HTL, MESH_MAX_HTL, PEER_METADATA_SNAPSHOT_VERSION, MSG_TYPE_REQUEST, MSG_TYPE_RESPONSE, MSG_TYPE_PUBSUB_INTEREST, MSG_TYPE_PUBSUB_FRAME, MSG_TYPE_PUBSUB_INVENTORY, MSG_TYPE_PUBSUB_WANT, FRAGMENT_SIZE, createMeshNostrEventFrame, validateMeshNostrFrame, parseMeshNostrFrameText, type SignalingMessage, type MeshNostrFrame, type MeshNostrPayload, type WebRTCStoreConfig, type PeerStatus, type WebRTCStoreEvent, type WebRTCStoreEventHandler, type EventSigner, type EventEncrypter, type EventDecrypter, type GiftWrapper, type GiftUnwrapper, type SignedEvent, type PeerPool, type PeerClassifier, type PoolConfig, type SelectionStrategy, type RequestDispatchConfig, type PersistedPeerMetadata, type PeerMetadataSnapshot, type MeshStats, type WebRTCStats, type BandwidthSample, type DataRequest, type DataResponse, type PubsubInterest, type PubsubFrame, type PubsubInventory, type PubsubWant, } from './types.js';
-export { encodeRequest, encodeResponse, encodePubsubInterest, encodePubsubFrame, encodePubsubInventory, encodePubsubWant, parseMessage, createRequest, createResponse, createFragmentResponse, createPubsubInterest, createPubsubFrame, createPubsubInventory, createPubsubWant, hashToKey, verifyHash, generatePeerHTLConfig, decrementHTLWithPolicy, decrementHTL, shouldForwardHTL, shouldForward, type PeerHTLConfig, type PendingRequest, } from './protocol.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/webrtc/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/webrtc/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AACzD,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EACL,YAAY,EACZ,aAAa,EACb,uBAAuB,EACvB,mBAAmB,EACnB,iBAAiB,GAClB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,MAAM,EACN,YAAY,EACZ,WAAW,EACX,OAAO,EACP,OAAO,EACP,KAAK,SAAS,EACd,mBAAmB,EACnB,iBAAiB,EACjB,aAAa,EACb,qBAAqB,EACrB,gBAAgB,EAChB,YAAY,EACZ,8BAA8B,EAC9B,gBAAgB,EAChB,iBAAiB,EACjB,wBAAwB,EACxB,qBAAqB,EACrB,yBAAyB,EACzB,oBAAoB,EACpB,aAAa,EACb,yBAAyB,EACzB,sBAAsB,EACtB,uBAAuB,EACvB,KAAK,gBAAgB,EACrB,KAAK,cAAc,EACnB,KAAK,gBAAgB,EACrB,KAAK,iBAAiB,EACtB,KAAK,UAAU,EACf,KAAK,gBAAgB,EACrB,KAAK,uBAAuB,EAC5B,KAAK,WAAW,EAChB,KAAK,cAAc,EACnB,KAAK,cAAc,EACnB,KAAK,WAAW,EAChB,KAAK,aAAa,EAClB,KAAK,WAAW,EAChB,KAAK,QAAQ,EACb,KAAK,cAAc,EACnB,KAAK,UAAU,EACf,KAAK,iBAAiB,EACtB,KAAK,qBAAqB,EAC1B,KAAK,qBAAqB,EAC1B,KAAK,oBAAoB,EACzB,KAAK,SAAS,EACd,KAAK,WAAW,EAChB,KAAK,eAAe,EACpB,KAAK,WAAW,EAChB,KAAK,YAAY,EACjB,KAAK,cAAc,EACnB,KAAK,WAAW,EAChB,KAAK,eAAe,EACpB,KAAK,UAAU,GAChB,MAAM,YAAY,CAAC;AAGpB,OAAO,EACL,aAAa,EACb,cAAc,EACd,oBAAoB,EACpB,iBAAiB,EACjB,qBAAqB,EACrB,gBAAgB,EAChB,YAAY,EACZ,aAAa,EACb,cAAc,EACd,sBAAsB,EACtB,oBAAoB,EACpB,iBAAiB,EACjB,qBAAqB,EACrB,gBAAgB,EAChB,SAAS,EACT,UAAU,EACV,qBAAqB,EACrB,sBAAsB,EACtB,YAAY,EACZ,gBAAgB,EAChB,aAAa,EACb,KAAK,aAAa,EAClB,KAAK,cAAc,GACpB,MAAM,eAAe,CAAC"}

package/dist/webrtc/index.js

@@ -1,7 +0,0 @@
-export { WebRTCStore, DEFAULT_RELAYS } from './store.js';
-export { Peer } from './peer.js';
-export { PeerSelector, peerPrincipal, normalizeDispatchConfig, buildHedgedWavePlan, syncSelectorPeers, } from './peerSelector.js';
-export { PeerId, generateUuid, WEBRTC_KIND, MAX_HTL, HtlMode, BLOB_REQUEST_POLICY, MESH_EVENT_POLICY, MESH_PROTOCOL, MESH_PROTOCOL_VERSION, MESH_DEFAULT_HTL, MESH_MAX_HTL, PEER_METADATA_SNAPSHOT_VERSION, MSG_TYPE_REQUEST, MSG_TYPE_RESPONSE, MSG_TYPE_PUBSUB_INTEREST, MSG_TYPE_PUBSUB_FRAME, MSG_TYPE_PUBSUB_INVENTORY, MSG_TYPE_PUBSUB_WANT, FRAGMENT_SIZE, createMeshNostrEventFrame, validateMeshNostrFrame, parseMeshNostrFrameText, } from './types.js';
-// Protocol functions
-export { encodeRequest, encodeResponse, encodePubsubInterest, encodePubsubFrame, encodePubsubInventory, encodePubsubWant, parseMessage, createRequest, createResponse, createFragmentResponse, createPubsubInterest, createPubsubFrame, createPubsubInventory, createPubsubWant, hashToKey, verifyHash, generatePeerHTLConfig, decrementHTLWithPolicy, decrementHTL, shouldForwardHTL, shouldForward, } from './protocol.js';
-//# sourceMappingURL=index.js.map

package/dist/webrtc/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/webrtc/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AACzD,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EACL,YAAY,EACZ,aAAa,EACb,uBAAuB,EACvB,mBAAmB,EACnB,iBAAiB,GAClB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,MAAM,EACN,YAAY,EACZ,WAAW,EACX,OAAO,EACP,OAAO,EAEP,mBAAmB,EACnB,iBAAiB,EACjB,aAAa,EACb,qBAAqB,EACrB,gBAAgB,EAChB,YAAY,EACZ,8BAA8B,EAC9B,gBAAgB,EAChB,iBAAiB,EACjB,wBAAwB,EACxB,qBAAqB,EACrB,yBAAyB,EACzB,oBAAoB,EACpB,aAAa,EACb,yBAAyB,EACzB,sBAAsB,EACtB,uBAAuB,GA8BxB,MAAM,YAAY,CAAC;AAEpB,qBAAqB;AACrB,OAAO,EACL,aAAa,EACb,cAAc,EACd,oBAAoB,EACpB,iBAAiB,EACjB,qBAAqB,EACrB,gBAAgB,EAChB,YAAY,EACZ,aAAa,EACb,cAAc,EACd,sBAAsB,EACtB,oBAAoB,EACpB,iBAAiB,EACjB,qBAAqB,EACrB,gBAAgB,EAChB,SAAS,EACT,UAAU,EACV,qBAAqB,EACrB,sBAAsB,EACtB,YAAY,EACZ,gBAAgB,EAChB,aAAa,GAGd,MAAM,eAAe,CAAC"}

package/dist/webrtc/lruCache.d.ts

@@ -1,20 +0,0 @@
-/**
- * Simple LRU Cache implementation
- */
-export declare class LRUCache<K, V> {
-    private cache;
-    private maxSize;
-    constructor(maxSize?: number);
-    get(key: K): V | undefined;
-    set(key: K, value: V): void;
-    has(key: K): boolean;
-    delete(key: K): boolean;
-    clear(): void;
-    get size(): number;
-    keys(): IterableIterator<K>;
-    values(): IterableIterator<V>;
-    entries(): IterableIterator<[K, V]>;
-    forEach(callback: (value: V, key: K) => void): void;
-    [Symbol.iterator](): IterableIterator<[K, V]>;
-}
-//# sourceMappingURL=lruCache.d.ts.map

package/dist/webrtc/lruCache.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"lruCache.d.ts","sourceRoot":"","sources":["../../src/webrtc/lruCache.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,qBAAa,QAAQ,CAAC,CAAC,EAAE,CAAC;IACxB,OAAO,CAAC,KAAK,CAAmB;IAChC,OAAO,CAAC,OAAO,CAAS;gBAEZ,OAAO,GAAE,MAAY;IAIjC,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS;IAU1B,GAAG,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI;IAe3B,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO;IAIpB,MAAM,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO;IAIvB,KAAK,IAAI,IAAI;IAIb,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,IAAI,IAAI,gBAAgB,CAAC,CAAC,CAAC;IAI3B,MAAM,IAAI,gBAAgB,CAAC,CAAC,CAAC;IAI5B,OAAO,IAAI,gBAAgB,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAIpC,OAAO,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,KAAK,IAAI,GAAG,IAAI;IAInD,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,gBAAgB,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;CAG9C"}