@kehto/nip 0.1.0 → 0.4.0

package/dist/5d/index.js

@@ -0,0 +1,38 @@
+import {
+  CacheStorageNappletArtifactCache,
+  NAPPLET_ARTIFACT_CACHE_NAME,
+  NAPPLET_KINDS,
+  NAPPLET_KIND_NAMED,
+  NAPPLET_KIND_ROOT,
+  NAPPLET_KIND_SNAPSHOT,
+  NappletResolutionError,
+  coordinateKey,
+  fetchBlob,
+  isCoordinateFresh,
+  isNappletManifestKind,
+  openNappletArtifactCache,
+  parseNappletManifest,
+  resolveNapplet,
+  verifyBlobHash,
+  verifyManifestSignature
+} from "../chunk-CDBUCFLP.js";
+import "../chunk-2J3CSGKL.js";
+export {
+  CacheStorageNappletArtifactCache,
+  NAPPLET_ARTIFACT_CACHE_NAME,
+  NAPPLET_KINDS,
+  NAPPLET_KIND_NAMED,
+  NAPPLET_KIND_ROOT,
+  NAPPLET_KIND_SNAPSHOT,
+  NappletResolutionError,
+  coordinateKey,
+  fetchBlob,
+  isCoordinateFresh,
+  isNappletManifestKind,
+  openNappletArtifactCache,
+  parseNappletManifest,
+  resolveNapplet,
+  verifyBlobHash,
+  verifyManifestSignature
+};
+//# sourceMappingURL=index.js.map

package/dist/5d/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/65/index.d.ts

@@ -0,0 +1,170 @@
+import { NostrEvent } from 'nostr-tools';
+
+/**
+ * `@kehto/nip/65` — NIP-65 relay-list (kind 10002) parsing and outbox-model
+ * relay resolution.
+ *
+ * NIP-65 defines kind-10002 replaceable events whose `r` tags declare which
+ * relays an author reads from and writes to — the "outbox model" (a.k.a.
+ * "gossip"). A client that wants to *reach* an author publishes to (or reads
+ * from) that author's advertised relays instead of a fixed relay set.
+ *
+ * `nostr-tools` ships no NIP-65 helper, so this module fills the gap with a
+ * pure parser plus a closure-scoped registry (no module-global state, so
+ * multiple runtimes in one process never alias each other — same multi-instance
+ * contract as `@kehto/nip/66`).
+ *
+ * Tag grammar:
+ * ```text
+ * ["r", "wss://relay.example.com"]          → read AND write
+ * ["r", "wss://relay.example.com", "read"]  → read-only
+ * ["r", "wss://relay.example.com", "write"] → write-only
+ * ```
+ */
+/**
+ * A single relay entry parsed from a NIP-65 kind-10002 `r` tag.
+ *
+ * @example
+ * ```ts
+ * const entry: RelayEntry = { url: 'wss://relay.example.com', read: true, write: false };
+ * ```
+ */
+interface RelayEntry {
+    /** Relay WebSocket URL from the `r` tag's second element. */
+    url: string;
+    /** Whether the author reads (receives events) from this relay. */
+    read: boolean;
+    /** Whether the author writes (publishes events) to this relay. */
+    write: boolean;
+}
+/**
+ * Parse a NIP-65 kind-10002 relay-list event into structured {@link RelayEntry}
+ * objects.
+ *
+ * Keeps tags where `tag[0] === 'r'` and `tag[1]` is a string URL. The optional
+ * third element is the marker (`'read'`, `'write'`, or absent for both). Any
+ * marker other than the two canonical strings is treated as "unmarked" (read +
+ * write), matching how lenient NIP-65 consumers behave in practice.
+ *
+ * No URL normalization or hostname de-duplication is performed — the relay URL
+ * is preserved verbatim. Normalize with a NIP-66 dataset (`@kehto/nip/66`) or a
+ * dedicated relay-URL normalizer if you need canonical hostnames.
+ *
+ * @param event - A kind-10002 relay-list event (kind is not re-validated; pass the right event)
+ * @returns Array of relay entries in tag order; duplicate URLs are preserved
+ *
+ * @example
+ * ```ts
+ * import { parseNip65RelayList } from '@kehto/nip/65';
+ * const entries = parseNip65RelayList(kind10002Event);
+ * // [{ url: 'wss://a', read: true, write: true }, { url: 'wss://b', read: true, write: false }]
+ * ```
+ */
+declare function parseNip65RelayList(event: NostrEvent): RelayEntry[];
+/**
+ * Select the write (outbox) relay URLs from one author's parsed relay list,
+ * de-duplicated and in first-seen order.
+ *
+ * @param entries - Parsed entries from {@link parseNip65RelayList}
+ * @returns De-duplicated write-relay URLs
+ *
+ * @example
+ * ```ts
+ * const outbox = selectWriteRelays(parseNip65RelayList(event));
+ * ```
+ */
+declare function selectWriteRelays(entries: ReadonlyArray<RelayEntry>): string[];
+/**
+ * Select the read (inbox) relay URLs from one author's parsed relay list,
+ * de-duplicated and in first-seen order.
+ *
+ * @param entries - Parsed entries from {@link parseNip65RelayList}
+ * @returns De-duplicated read-relay URLs
+ */
+declare function selectReadRelays(entries: ReadonlyArray<RelayEntry>): string[];
+/**
+ * A closure-scoped registry of parsed NIP-65 relay lists keyed by author
+ * pubkey. Returned by {@link createNip65Registry}. Each registry owns its own
+ * `Map` — two registries never share state (unlike a module-globals pattern).
+ *
+ * @example
+ * ```ts
+ * const registry = createNip65Registry();
+ * registry.ingest(event);                       // store by event.pubkey
+ * const outbox = registry.resolveOutboxRelays([authorA, authorB]);
+ * ```
+ */
+interface Nip65Registry {
+    /**
+     * Parse and store a kind-10002 event under its own `pubkey`. Overwrites any
+     * previously stored list for that author (kind-10002 is replaceable).
+     *
+     * @param event - A kind-10002 relay-list event
+     * @returns The parsed entries that were stored
+     */
+    ingest(event: NostrEvent): RelayEntry[];
+    /**
+     * Store an already-parsed relay list for an explicit pubkey. Use when you
+     * parsed elsewhere or want to seed the registry without an event object.
+     *
+     * @param pubkey - Author hex public key
+     * @param entries - Parsed relay entries
+     */
+    setRelayList(pubkey: string, entries: ReadonlyArray<RelayEntry>): void;
+    /**
+     * Get the stored relay list for an author, or `undefined` if none seen.
+     *
+     * @param pubkey - Author hex public key
+     */
+    getRelayList(pubkey: string): RelayEntry[] | undefined;
+    /** Whether a relay list has been stored for `pubkey`. */
+    has(pubkey: string): boolean;
+    /**
+     * Resolve write (outbox) relay URLs across the given authors, de-duplicated.
+     * Authors with no stored list contribute nothing. Empty input or all-unknown
+     * authors yield `[]`.
+     *
+     * @param pubkeys - Author hex public keys
+     * @returns De-duplicated outbox relay URLs in first-seen order
+     */
+    resolveOutboxRelays(pubkeys: ReadonlyArray<string>): string[];
+    /**
+     * Resolve read (inbox) relay URLs across the given authors, de-duplicated.
+     *
+     * @param pubkeys - Author hex public keys
+     * @returns De-duplicated inbox relay URLs in first-seen order
+     */
+    resolveReadRelays(pubkeys: ReadonlyArray<string>): string[];
+    /** Drop a single author's stored relay list. Returns `true` if one existed. */
+    delete(pubkey: string): boolean;
+    /** Clear every stored relay list. */
+    clear(): void;
+}
+/**
+ * Create a closure-scoped {@link Nip65Registry} for accumulating kind-10002
+ * relay lists and resolving outbox/inbox relays.
+ *
+ * Framework-agnostic: it knows nothing about relay pools, subscriptions, or
+ * storage. Feed it kind-10002 events (e.g. from your pool's `onevent`
+ * callback) via {@link Nip65Registry.ingest} and query the outbox model with
+ * {@link Nip65Registry.resolveOutboxRelays}.
+ *
+ * @returns A fresh registry with its own state
+ *
+ * @example
+ * ```ts
+ * import { createNip65Registry } from '@kehto/nip/65';
+ * import { SimplePool } from 'nostr-tools/pool';
+ *
+ * const registry = createNip65Registry();
+ * const pool = new SimplePool();
+ * pool.subscribeMany(discoveryRelays, [{ kinds: [10002], authors }], {
+ *   onevent: (e) => registry.ingest(e),
+ * });
+ * // Later, before publishing on behalf of `author`:
+ * const outbox = registry.resolveOutboxRelays([author]);
+ * ```
+ */
+declare function createNip65Registry(): Nip65Registry;
+
+export { type Nip65Registry, type RelayEntry, createNip65Registry, parseNip65RelayList, selectReadRelays, selectWriteRelays };

package/dist/65/index.js

@@ -0,0 +1,13 @@
+import {
+  createNip65Registry,
+  parseNip65RelayList,
+  selectReadRelays,
+  selectWriteRelays
+} from "../chunk-UUMBCHTA.js";
+export {
+  createNip65Registry,
+  parseNip65RelayList,
+  selectReadRelays,
+  selectWriteRelays
+};
+//# sourceMappingURL=index.js.map

package/dist/65/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/{66.js → 66/index.js}

@@ -1,9 +1,9 @@
 import {
   DEFAULT_RELAY_ATTRIBUTE_GROUPS,
   createNip66Aggregator
-} from "./chunk-N4WPLKIJ.js";
+} from "../chunk-DADZ6NUI.js";
 export {
   DEFAULT_RELAY_ATTRIBUTE_GROUPS,
   createNip66Aggregator
 };
-//# sourceMappingURL=66.js.map
+//# sourceMappingURL=index.js.map

package/dist/66/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/89/index.d.ts

@@ -0,0 +1,164 @@
+import { NostrEvent } from 'nostr-tools';
+
+/**
+ * `@kehto/nip/89` — NIP-89 application-handler discovery.
+ *
+ * NIP-89 lets clients answer "who can open an event of kind N?" without
+ * hardcoding app knowledge — essential for any runtime that hosts or launches
+ * other apps (the napplet model, "open with…" menus, unknown-kind fallbacks).
+ *
+ * Two event kinds:
+ * - **kind 31990 — handler information.** An app advertises which kinds it
+ *   handles (`k` tags) and per-platform URL templates to open an entity
+ *   (`["web", "https://app/e/<bech32>", "nevent"]`).
+ * - **kind 31989 — handler recommendation.** A user recommends a handler for a
+ *   given kind via `a` tags pointing at 31990 addresses.
+ *
+ * `nostr-tools` ships no NIP-89 helper. This module provides pure parsers for
+ * both kinds plus URL-template expansion — no relay, signer, or framework
+ * coupling.
+ */
+/** Kind 31990 — handler information (an app describing what it can open). */
+declare const HANDLER_INFORMATION_KIND = 31990;
+/** Kind 31989 — handler recommendation (a user endorsing a handler for a kind). */
+declare const HANDLER_RECOMMENDATION_KIND = 31989;
+/** Platform tag names defined by NIP-89 for handler URL templates. */
+declare const HANDLER_PLATFORMS: readonly ["web", "ios", "android", "macos", "windows", "linux"];
+/** One of the NIP-89 platform identifiers. */
+type HandlerPlatform = (typeof HANDLER_PLATFORMS)[number];
+/**
+ * One platform-specific way to open an entity, from a 31990 platform tag.
+ *
+ * @example
+ * ```ts
+ * // tag ["web", "https://app.example/e/<bech32>", "nevent"]
+ * const target: HandlerTarget = { url: 'https://app.example/e/<bech32>', entity: 'nevent' };
+ * ```
+ */
+interface HandlerTarget {
+    /** URL template containing a `<bech32>` and/or `<raw>` placeholder. */
+    url: string;
+    /** Optional NIP-19 entity type this template is for (e.g. `'nevent'`, `'naddr'`, `'nprofile'`). */
+    entity: string | undefined;
+}
+/**
+ * A parsed kind-31990 handler-information event.
+ *
+ * @example
+ * ```ts
+ * const info = parseHandlerInformation(event);
+ * info.kinds;            // [1, 30023]
+ * info.metadata.name;    // 'My Reader'
+ * info.platforms.web;    // [{ url: 'https://app/<bech32>', entity: 'nevent' }]
+ * ```
+ */
+interface HandlerInformation {
+    /** Handler author pubkey. */
+    pubkey: string;
+    /** `d`-tag identifier (handler instance id). */
+    identifier: string;
+    /** Addressable coordinate `31990:pubkey:d`. */
+    address: string;
+    /** Event kinds the handler declares support for (from `k` tags, de-duplicated). */
+    kinds: number[];
+    /** Parsed kind-0-style metadata from `content` (name, display_name, picture, about, …). `{}` if absent/invalid. */
+    metadata: Record<string, unknown>;
+    /** Per-platform URL templates, keyed by {@link HandlerPlatform}. Only platforms present in the event appear. */
+    platforms: Partial<Record<HandlerPlatform, HandlerTarget[]>>;
+}
+/**
+ * Parse a kind-31990 handler-information event.
+ *
+ * @param event - A kind-31990 event (kind is not re-validated)
+ * @returns The structured handler information
+ *
+ * @example
+ * ```ts
+ * import { parseHandlerInformation, handlesKind } from '@kehto/nip/89';
+ * const info = parseHandlerInformation(event);
+ * if (handlesKind(info, 1)) openWith(info);
+ * ```
+ */
+declare function parseHandlerInformation(event: NostrEvent): HandlerInformation;
+/**
+ * Whether a handler declares support for `kind`.
+ *
+ * @param info - Parsed handler information
+ * @param kind - Event kind to check
+ */
+declare function handlesKind(info: HandlerInformation, kind: number): boolean;
+/**
+ * Substitution values for {@link buildHandlerUrl}.
+ *
+ * NIP-89 templates use `<bech32>` (NIP-19 encoded entity) and/or `<raw>`
+ * (hex id / address coordinate). Supply whichever the template needs.
+ */
+interface HandlerEntityValues {
+    /** NIP-19 bech32 entity (e.g. an `nevent…`, `naddr…`, `nprofile…`). */
+    bech32?: string;
+    /** Raw value (hex event id, or `kind:pubkey:d` coordinate). */
+    raw?: string;
+}
+/**
+ * Expand a handler URL template by substituting its `<bech32>` / `<raw>`
+ * placeholders.
+ *
+ * Returns `undefined` when the template requires a placeholder you didn't
+ * supply (e.g. it contains `<bech32>` but `values.bech32` is missing) — so a
+ * caller can fall through to the next target instead of producing a broken URL.
+ *
+ * @param target - A {@link HandlerTarget} or a raw template string
+ * @param values - The `<bech32>` / `<raw>` substitutions
+ * @returns The expanded URL, or `undefined` if a needed placeholder is absent
+ *
+ * @example
+ * ```ts
+ * buildHandlerUrl({ url: 'https://app/e/<bech32>', entity: 'nevent' }, { bech32: 'nevent1…' });
+ * // 'https://app/e/nevent1…'
+ * ```
+ */
+declare function buildHandlerUrl(target: HandlerTarget | string, values: HandlerEntityValues): string | undefined;
+/** One handler endorsement parsed from a 31989 `a` tag. */
+interface HandlerRecommendationEntry {
+    /** The recommended handler's 31990 coordinate `31990:pubkey:d`. */
+    address: string;
+    /** Handler author pubkey extracted from the coordinate, if well-formed. */
+    handlerPubkey: string | undefined;
+    /** Handler `d`-tag identifier extracted from the coordinate, if present. */
+    identifier: string | undefined;
+    /** Optional relay-hint where the 31990 event can be found (`a`-tag 3rd element). */
+    relay: string | undefined;
+    /** Optional platform marker the handler is recommended for (`a`-tag 4th element). */
+    platform: string | undefined;
+}
+/**
+ * A parsed kind-31989 handler-recommendation event.
+ *
+ * @example
+ * ```ts
+ * const rec = parseHandlerRecommendation(event);
+ * rec.recommendedKind;          // 1
+ * rec.recommendations[0].address; // '31990:pubkey:d'
+ * ```
+ */
+interface HandlerRecommendation {
+    /** Recommendation author pubkey. */
+    pubkey: string;
+    /** The kind being recommended for, parsed from the `d` tag; `undefined` if non-numeric/missing. */
+    recommendedKind: number | undefined;
+    /** Endorsed handlers, in tag order. */
+    recommendations: HandlerRecommendationEntry[];
+}
+/**
+ * Parse a kind-31989 handler-recommendation event.
+ *
+ * The `d` tag carries the kind being recommended for; each `a` tag (whose
+ * coordinate starts with `31990:`) endorses one handler, optionally with a
+ * relay hint and platform marker.
+ *
+ * @param event - A kind-31989 event (kind is not re-validated)
+ * @returns The structured recommendation
+ */
+declare function parseHandlerRecommendation(event: NostrEvent): HandlerRecommendation;
+
+export { HANDLER_INFORMATION_KIND, HANDLER_PLATFORMS, HANDLER_RECOMMENDATION_KIND, type HandlerEntityValues, type HandlerInformation, type HandlerPlatform, type HandlerRecommendation, type HandlerRecommendationEntry, type HandlerTarget, buildHandlerUrl, handlesKind, parseHandlerInformation, parseHandlerRecommendation };

package/dist/89/index.js

@@ -0,0 +1,19 @@
+import {
+  HANDLER_INFORMATION_KIND,
+  HANDLER_PLATFORMS,
+  HANDLER_RECOMMENDATION_KIND,
+  buildHandlerUrl,
+  handlesKind,
+  parseHandlerInformation,
+  parseHandlerRecommendation
+} from "../chunk-BCTIL523.js";
+export {
+  HANDLER_INFORMATION_KIND,
+  HANDLER_PLATFORMS,
+  HANDLER_RECOMMENDATION_KIND,
+  buildHandlerUrl,
+  handlesKind,
+  parseHandlerInformation,
+  parseHandlerRecommendation
+};
+//# sourceMappingURL=index.js.map

package/dist/89/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/chunk-2J3CSGKL.js

@@ -0,0 +1,39 @@
+// src/5a/index.ts
+import { sha256 } from "@noble/hashes/sha2.js";
+import { bytesToHex } from "@noble/hashes/utils.js";
+function computeAggregateHash(entries) {
+  const lines = entries.map((entry) => `${entry.sha256} ${entry.path}
+`);
+  lines.sort();
+  return bytesToHex(sha256(new TextEncoder().encode(lines.join(""))));
+}
+function pathEntriesFromTags(tags) {
+  const entries = [];
+  for (const tag of tags) {
+    if (tag[0] === "path" && typeof tag[1] === "string" && typeof tag[2] === "string" && tag[1].length > 0 && tag[2].length > 0) {
+      entries.push({ path: tag[1], sha256: tag[2] });
+    }
+  }
+  return entries;
+}
+function aggregateTagValue(tags) {
+  for (const tag of tags) {
+    if (tag[0] === "x" && tag[2] === "aggregate" && typeof tag[1] === "string" && tag[1].length > 0) {
+      return tag[1];
+    }
+  }
+  return void 0;
+}
+function verifyAggregate(tags) {
+  const declared = aggregateTagValue(tags);
+  if (!declared) return false;
+  return computeAggregateHash(pathEntriesFromTags(tags)) === declared;
+}
+
+export {
+  computeAggregateHash,
+  pathEntriesFromTags,
+  aggregateTagValue,
+  verifyAggregate
+};
+//# sourceMappingURL=chunk-2J3CSGKL.js.map

package/dist/chunk-2J3CSGKL.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/5a/index.ts"],"sourcesContent":["import { sha256 } from '@noble/hashes/sha2.js';\nimport { bytesToHex } from '@noble/hashes/utils.js';\n\n/**\n * `@kehto/nip/5a` — NIP-5A \"Aggregate Hash\" computation and verification.\n *\n * NIP-5A (`nostr-protocol/nips` PR #2287) defines a content address for a set\n * of published files. Each file is declared by a `path` tag\n * (`[\"path\", \"<abs-path>\", \"<sha256>\"]`) and the set is summarized by a single\n * aggregate `x` tag (`[\"x\", \"<hex>\", \"aggregate\"]`).\n *\n * The aggregate is computed by:\n * 1. taking every `path` entry as the line `\"<sha256> <abs-path>\\n\"`,\n * 2. sorting the lines in ascending lexicographic order,\n * 3. concatenating them as UTF-8 bytes,\n * 4. hashing with SHA-256, encoded as lowercase hex.\n */\n\n// TextEncoder is available in all JS runtimes but not in the ES2022 lib types.\ndeclare class TextEncoder { encode(input: string): Uint8Array; }\n\n/**\n * One published file: an absolute path and the lowercase-hex SHA-256 of its\n * bytes. Parsed from a NIP-5A `[\"path\", \"<abs-path>\", \"<sha256>\"]` tag.\n *\n * @example\n * ```ts\n * const entry: PathEntry = { path: '/index.html', sha256: '186ea5…1c99' };\n * ```\n */\nexport interface PathEntry {\n  /** Absolute path of the file (the `path` tag's second element). */\n  path: string;\n  /** Lowercase-hex SHA-256 of the file bytes (the `path` tag's third element). */\n  sha256: string;\n}\n\n/**\n * Compute the NIP-5A aggregate hash over a set of {@link PathEntry} files.\n *\n * Lines (`\"<sha256> <abs-path>\\n\"`) are sorted before hashing, so the result is\n * independent of the input order.\n *\n * @param entries - The file path entries (any order)\n * @returns The aggregate hash as lowercase hex\n *\n * @example\n * ```ts\n * import { computeAggregateHash } from '@kehto/nip/5a';\n * const hex = computeAggregateHash([{ path: '/index.html', sha256: 'aa…' }]);\n * ```\n */\nexport function computeAggregateHash(entries: readonly PathEntry[]): string {\n  const lines = entries.map((entry) => `${entry.sha256} ${entry.path}\\n`);\n  lines.sort();\n  return bytesToHex(sha256(new TextEncoder().encode(lines.join(''))));\n}\n\n/**\n * Extract {@link PathEntry} objects from an event's tags, keeping only\n * well-formed `[\"path\", \"<abs-path>\", \"<sha256>\"]` tags in tag order.\n *\n * @param tags - The manifest event's tags\n * @returns Parsed path entries (malformed `path` tags are skipped)\n */\nexport function pathEntriesFromTags(tags: readonly (readonly string[])[]): PathEntry[] {\n  const entries: PathEntry[] = [];\n  for (const tag of tags) {\n    if (tag[0] === 'path' && typeof tag[1] === 'string' && typeof tag[2] === 'string'\n      && tag[1].length > 0 && tag[2].length > 0) {\n      entries.push({ path: tag[1], sha256: tag[2] });\n    }\n  }\n  return entries;\n}\n\n/**\n * Read the aggregate hash declared by an event's `[\"x\", \"<hex>\", \"aggregate\"]`\n * tag.\n *\n * @param tags - The manifest event's tags\n * @returns The declared aggregate hex, or `undefined` if no aggregate `x` tag\n */\nexport function aggregateTagValue(tags: readonly (readonly string[])[]): string | undefined {\n  for (const tag of tags) {\n    if (tag[0] === 'x' && tag[2] === 'aggregate' && typeof tag[1] === 'string' && tag[1].length > 0) {\n      return tag[1];\n    }\n  }\n  return undefined;\n}\n\n/**\n * Verify that an event's declared aggregate `x` tag equals the aggregate\n * recomputed from its `path` tags.\n *\n * @param tags - The manifest event's tags\n * @returns `true` only when an aggregate `x` tag is present and matches the\n *   recomputed value; `false` otherwise (mismatch or missing aggregate tag)\n *\n * @example\n * ```ts\n * import { verifyAggregate } from '@kehto/nip/5a';\n * if (!verifyAggregate(manifestEvent.tags)) throw new Error('aggregate mismatch');\n * ```\n */\nexport function verifyAggregate(tags: readonly (readonly string[])[]): boolean {\n  const declared = aggregateTagValue(tags);\n  if (!declared) return false;\n  return computeAggregateHash(pathEntriesFromTags(tags)) === declared;\n}\n"],"mappings":";AAAA,SAAS,cAAc;AACvB,SAAS,kBAAkB;AAmDpB,SAAS,qBAAqB,SAAuC;AAC1E,QAAM,QAAQ,QAAQ,IAAI,CAAC,UAAU,GAAG,MAAM,MAAM,IAAI,MAAM,IAAI;AAAA,CAAI;AACtE,QAAM,KAAK;AACX,SAAO,WAAW,OAAO,IAAI,YAAY,EAAE,OAAO,MAAM,KAAK,EAAE,CAAC,CAAC,CAAC;AACpE;AASO,SAAS,oBAAoB,MAAmD;AACrF,QAAM,UAAuB,CAAC;AAC9B,aAAW,OAAO,MAAM;AACtB,QAAI,IAAI,CAAC,MAAM,UAAU,OAAO,IAAI,CAAC,MAAM,YAAY,OAAO,IAAI,CAAC,MAAM,YACpE,IAAI,CAAC,EAAE,SAAS,KAAK,IAAI,CAAC,EAAE,SAAS,GAAG;AAC3C,cAAQ,KAAK,EAAE,MAAM,IAAI,CAAC,GAAG,QAAQ,IAAI,CAAC,EAAE,CAAC;AAAA,IAC/C;AAAA,EACF;AACA,SAAO;AACT;AASO,SAAS,kBAAkB,MAA0D;AAC1F,aAAW,OAAO,MAAM;AACtB,QAAI,IAAI,CAAC,MAAM,OAAO,IAAI,CAAC,MAAM,eAAe,OAAO,IAAI,CAAC,MAAM,YAAY,IAAI,CAAC,EAAE,SAAS,GAAG;AAC/F,aAAO,IAAI,CAAC;AAAA,IACd;AAAA,EACF;AACA,SAAO;AACT;AAgBO,SAAS,gBAAgB,MAA+C;AAC7E,QAAM,WAAW,kBAAkB,IAAI;AACvC,MAAI,CAAC,SAAU,QAAO;AACtB,SAAO,qBAAqB,oBAAoB,IAAI,CAAC,MAAM;AAC7D;","names":[]}

package/dist/chunk-2XYRP2S6.js

@@ -0,0 +1,108 @@
+// src/51/index.ts
+var LIST_KINDS = {
+  1e4: "mute",
+  10001: "pinned-notes",
+  10003: "bookmarks",
+  10004: "communities",
+  10005: "public-chats",
+  10006: "blocked-relays",
+  10007: "search-relays",
+  10009: "simple-groups",
+  10012: "relay-feeds",
+  10015: "interests",
+  10020: "media-follows",
+  10030: "emojis",
+  10050: "dm-relays",
+  10101: "good-wiki-authors",
+  10102: "good-wiki-relays"
+};
+var SET_KINDS = {
+  3e4: "follow-sets",
+  30002: "relay-sets",
+  30003: "bookmark-sets",
+  30004: "curation-sets",
+  30005: "video-curation-sets",
+  30007: "kind-mute-sets",
+  30015: "interest-sets",
+  30019: "release-sets",
+  30020: "release-artifact-sets",
+  30030: "emoji-sets",
+  30063: "release-artifact-sets",
+  30267: "app-curation-sets"
+};
+var ITEM_TAGS = ["e", "p", "a", "t", "r", "word", "emoji", "relay", "g", "i", "k"];
+function isListKind(kind) {
+  return Object.prototype.hasOwnProperty.call(LIST_KINDS, kind);
+}
+function isSetKind(kind) {
+  return Object.prototype.hasOwnProperty.call(SET_KINDS, kind);
+}
+function listKindName(kind) {
+  return LIST_KINDS[kind] ?? SET_KINDS[kind];
+}
+var META_TAGS = /* @__PURE__ */ new Set(["d", "title", "image", "description", "name", "summary", "alt"]);
+function parseList(event) {
+  const family = isListKind(event.kind) ? "list" : isSetKind(event.kind) ? "set" : "unknown";
+  const itemTagSet = new Set(ITEM_TAGS);
+  const publicItems = [];
+  let identifier = "";
+  let title;
+  let image;
+  let description;
+  for (const tag of event.tags) {
+    const name = tag[0];
+    if (name === "d") identifier = tag[1] ?? "";
+    else if (name === "title") title = tag[1];
+    else if (name === "image") image = tag[1];
+    else if (name === "description") description = tag[1];
+    else if (itemTagSet.has(name) && !META_TAGS.has(name)) publicItems.push([...tag]);
+  }
+  const isSet = family === "set";
+  const address = isSet ? `${event.kind}:${event.pubkey}:${identifier}` : void 0;
+  const encryptedContent = event.content && event.content.length > 0 ? event.content : void 0;
+  return {
+    kind: event.kind,
+    family,
+    type: listKindName(event.kind),
+    pubkey: event.pubkey,
+    identifier,
+    address,
+    title,
+    image,
+    description,
+    publicItems,
+    encryptedContent,
+    privateItems: void 0
+  };
+}
+function getTagValues(items, tagName) {
+  const out = [];
+  for (const tag of items) {
+    if (tag[0] === tagName && typeof tag[1] === "string") out.push(tag[1]);
+  }
+  return out;
+}
+async function decryptPrivateItems(list, decrypt) {
+  if (!list.encryptedContent) {
+    return { ...list, privateItems: [] };
+  }
+  const plaintext = await decrypt(list.encryptedContent, list.pubkey);
+  const parsed = JSON.parse(plaintext);
+  if (!Array.isArray(parsed) || !parsed.every((t) => Array.isArray(t) && t.every((s) => typeof s === "string"))) {
+    throw new Error("NIP-51: decrypted private items are not a string[][] tag array");
+  }
+  return { ...list, privateItems: parsed };
+}
+
+export {
+  LIST_KINDS,
+  SET_KINDS,
+  ITEM_TAGS,
+  isListKind,
+  isSetKind,
+  listKindName,
+  parseList,
+  getTagValues,
+  decryptPrivateItems
+};
+//# sourceMappingURL=chunk-2XYRP2S6.js.map

package/dist/chunk-2XYRP2S6.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/51/index.ts"],"sourcesContent":["import type { NostrEvent } from 'nostr-tools';\n\n/**\n * `@kehto/nip/51` — NIP-51 list & set parsing.\n *\n * NIP-51 organizes user data into two families of events whose items live in\n * tags (public) and, optionally, in NIP-44-encrypted content (private):\n *\n * - **Standard lists** — replaceable, kinds `10000`–`10101`. One per user per\n *   kind (e.g. mute list, bookmarks, blocked relays, DM relays).\n * - **Sets** — addressable / parameterized-replaceable, kinds `30000`–`30030`.\n *   Many per user, distinguished by a `d` identifier (e.g. follow sets, relay\n *   sets, emoji sets, curation sets).\n *\n * `nostr-tools` ships no NIP-51 helper. This module provides a single\n * widely-compatible parser that turns either family into a structured\n * {@link Nip51List}, plus item accessors and an injected-decryptor path for\n * private items (so the package stays crypto-free and framework-agnostic).\n */\n\n/** Canonical NIP-51 **standard list** kinds (replaceable, one per author). */\nexport const LIST_KINDS: Readonly<Record<number, string>> = {\n  10000: 'mute',\n  10001: 'pinned-notes',\n  10003: 'bookmarks',\n  10004: 'communities',\n  10005: 'public-chats',\n  10006: 'blocked-relays',\n  10007: 'search-relays',\n  10009: 'simple-groups',\n  10012: 'relay-feeds',\n  10015: 'interests',\n  10020: 'media-follows',\n  10030: 'emojis',\n  10050: 'dm-relays',\n  10101: 'good-wiki-authors',\n  10102: 'good-wiki-relays',\n};\n\n/** Canonical NIP-51 **set** kinds (addressable, many per author by `d`). */\nexport const SET_KINDS: Readonly<Record<number, string>> = {\n  30000: 'follow-sets',\n  30002: 'relay-sets',\n  30003: 'bookmark-sets',\n  30004: 'curation-sets',\n  30005: 'video-curation-sets',\n  30007: 'kind-mute-sets',\n  30015: 'interest-sets',\n  30019: 'release-sets',\n  30020: 'release-artifact-sets',\n  30030: 'emoji-sets',\n  30063: 'release-artifact-sets',\n  30267: 'app-curation-sets',\n};\n\n/**\n * Item-bearing NIP-51 tag names — the tags that carry list *content* (as\n * opposed to metadata tags like `d`, `title`, `image`, `description`).\n */\nexport const ITEM_TAGS = ['e', 'p', 'a', 't', 'r', 'word', 'emoji', 'relay', 'g', 'i', 'k'] as const;\n\n/** Whether `kind` is a NIP-51 standard list kind (`10000`–`10101`). */\nexport function isListKind(kind: number): boolean {\n  return Object.prototype.hasOwnProperty.call(LIST_KINDS, kind);\n}\n\n/** Whether `kind` is a NIP-51 set kind (`30000`–`30030`). */\nexport function isSetKind(kind: number): boolean {\n  return Object.prototype.hasOwnProperty.call(SET_KINDS, kind);\n}\n\n/**\n * Friendly name for a NIP-51 list/set kind (e.g. `10000` → `'mute'`,\n * `30030` → `'emoji-sets'`), or `undefined` if `kind` is not a known NIP-51 kind.\n */\nexport function listKindName(kind: number): string | undefined {\n  return LIST_KINDS[kind] ?? SET_KINDS[kind];\n}\n\n/**\n * A parsed NIP-51 list or set.\n *\n * `publicItems` holds the item-bearing tags verbatim. `privateItems` is\n * populated only after {@link decryptPrivateItems} runs; until then it is\n * `undefined` (the encrypted payload is left untouched in {@link Nip51List.encryptedContent}).\n *\n * @example\n * ```ts\n * const list = parseList(kind10000MuteEvent);\n * list.kind;        // 10000\n * list.type;        // 'mute'\n * list.family;      // 'list'\n * getTagValues(list.publicItems, 'p'); // muted pubkeys (public portion)\n * ```\n */\nexport interface Nip51List {\n  /** Event kind. */\n  kind: number;\n  /** `'list'` for standard lists (10000–10101), `'set'` for sets (30000–30030), `'unknown'` otherwise. */\n  family: 'list' | 'set' | 'unknown';\n  /** Friendly kind name from {@link listKindName}, or `undefined` for unknown kinds. */\n  type: string | undefined;\n  /** Author pubkey. */\n  pubkey: string;\n  /** Set identifier from the `d` tag (sets only; `''` for standard lists / missing). */\n  identifier: string;\n  /** Addressable coordinate `kind:pubkey:d` for sets; `undefined` for standard lists. */\n  address: string | undefined;\n  /** Optional `title` tag (sets). */\n  title: string | undefined;\n  /** Optional `image` tag (sets). */\n  image: string | undefined;\n  /** Optional `description` tag (sets). */\n  description: string | undefined;\n  /** Item-bearing tags verbatim (the public portion of the list). */\n  publicItems: string[][];\n  /** Raw NIP-44-encrypted content, if any (the private portion). */\n  encryptedContent: string | undefined;\n  /** Decrypted private item tags — `undefined` until {@link decryptPrivateItems} succeeds. */\n  privateItems: string[][] | undefined;\n}\n\nconst META_TAGS = new Set(['d', 'title', 'image', 'description', 'name', 'summary', 'alt']);\n\n/**\n * Parse a NIP-51 list or set event into a structured {@link Nip51List}.\n *\n * Works for any kind: known list/set kinds get a `type` and correct `family`;\n * unknown kinds still parse (`family: 'unknown'`) so forward-compatible callers\n * can handle new list kinds before this table is updated.\n *\n * Item-bearing tags (see {@link ITEM_TAGS}) become {@link Nip51List.publicItems};\n * metadata tags (`d`, `title`, `image`, `description`, …) are lifted into named\n * fields. The encrypted `content` is preserved verbatim in\n * {@link Nip51List.encryptedContent} — call {@link decryptPrivateItems} with a\n * NIP-44 decryptor to populate {@link Nip51List.privateItems}.\n *\n * @param event - A NIP-51 list or set event\n * @returns The structured list/set\n *\n * @example\n * ```ts\n * import { parseList, getTagValues } from '@kehto/nip/51';\n * const bookmarks = parseList(kind10003Event);\n * const notes = getTagValues(bookmarks.publicItems, 'e');\n * ```\n */\nexport function parseList(event: NostrEvent): Nip51List {\n  const family: Nip51List['family'] = isListKind(event.kind)\n    ? 'list'\n    : isSetKind(event.kind)\n      ? 'set'\n      : 'unknown';\n\n  const itemTagSet = new Set<string>(ITEM_TAGS);\n  const publicItems: string[][] = [];\n  let identifier = '';\n  let title: string | undefined;\n  let image: string | undefined;\n  let description: string | undefined;\n\n  for (const tag of event.tags) {\n    const name = tag[0];\n    if (name === 'd') identifier = tag[1] ?? '';\n    else if (name === 'title') title = tag[1];\n    else if (name === 'image') image = tag[1];\n    else if (name === 'description') description = tag[1];\n    else if (itemTagSet.has(name) && !META_TAGS.has(name)) publicItems.push([...tag]);\n  }\n\n  const isSet = family === 'set';\n  const address = isSet ? `${event.kind}:${event.pubkey}:${identifier}` : undefined;\n  const encryptedContent = event.content && event.content.length > 0 ? event.content : undefined;\n\n  return {\n    kind: event.kind,\n    family,\n    type: listKindName(event.kind),\n    pubkey: event.pubkey,\n    identifier,\n    address,\n    title,\n    image,\n    description,\n    publicItems,\n    encryptedContent,\n    privateItems: undefined,\n  };\n}\n\n/**\n * Collect the values (`tag[1]`) of every item tag with the given name.\n *\n * @param items - Item tags ({@link Nip51List.publicItems} or {@link Nip51List.privateItems})\n * @param tagName - Tag name to filter on (e.g. `'p'`, `'e'`, `'a'`, `'t'`, `'word'`)\n * @returns The second element of each matching tag (missing values skipped)\n *\n * @example\n * ```ts\n * const mutedPubkeys = getTagValues(list.publicItems, 'p');\n * const mutedWords = getTagValues(list.publicItems, 'word');\n * ```\n */\nexport function getTagValues(items: ReadonlyArray<ReadonlyArray<string>>, tagName: string): string[] {\n  const out: string[] = [];\n  for (const tag of items) {\n    if (tag[0] === tagName && typeof tag[1] === 'string') out.push(tag[1]);\n  }\n  return out;\n}\n\n/**\n * A NIP-44 decryptor: takes the event's `content` and the author pubkey and\n * returns the plaintext (a JSON array of tags). Inject your signer's\n * `nip44.decrypt` (e.g. a NIP-07 `window.nostr.nip44`, a bunker, or\n * `nostr-tools/nip44`) so this package carries no crypto dependency.\n *\n * @example\n * ```ts\n * const decrypt: Nip44Decryptor = (content, author) =>\n *   window.nostr!.nip44!.decrypt(author, content);\n * ```\n */\nexport type Nip44Decryptor = (content: string, authorPubkey: string) => string | Promise<string>;\n\n/**\n * Decrypt the private portion of a list/set and populate\n * {@link Nip51List.privateItems}.\n *\n * NIP-51 stores private items as a NIP-44-encrypted JSON array of tags in the\n * event `content`, encrypted to the author's own key. This helper runs the\n * injected {@link Nip44Decryptor}, parses the plaintext as `string[][]`, and\n * returns a **new** {@link Nip51List} with `privateItems` set (the input is not\n * mutated). Lists with no encrypted content return a copy with\n * `privateItems: []`.\n *\n * Throws if the decryptor throws or the plaintext is not a JSON tag array — so\n * callers can distinguish \"no private items\" from \"couldn't read private items\".\n *\n * @param list - A parsed list from {@link parseList}\n * @param decrypt - Injected NIP-44 decryptor\n * @returns A copy of `list` with `privateItems` populated\n *\n * @example\n * ```ts\n * const withPrivate = await decryptPrivateItems(list, (c, a) => signer.nip44.decrypt(a, c));\n * const privatelyMuted = getTagValues(withPrivate.privateItems!, 'p');\n * ```\n */\nexport async function decryptPrivateItems(list: Nip51List, decrypt: Nip44Decryptor): Promise<Nip51List> {\n  if (!list.encryptedContent) {\n    return { ...list, privateItems: [] };\n  }\n  const plaintext = await decrypt(list.encryptedContent, list.pubkey);\n  const parsed: unknown = JSON.parse(plaintext);\n  if (!Array.isArray(parsed) || !parsed.every((t) => Array.isArray(t) && t.every((s) => typeof s === 'string'))) {\n    throw new Error('NIP-51: decrypted private items are not a string[][] tag array');\n  }\n  return { ...list, privateItems: parsed as string[][] };\n}\n"],"mappings":"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","names":[]}