@kehto/nip 0.1.0 → 0.4.0

package/dist/chunk-BCTIL523.js

@@ -0,0 +1,83 @@
+// src/89/index.ts
+var HANDLER_INFORMATION_KIND = 31990;
+var HANDLER_RECOMMENDATION_KIND = 31989;
+var HANDLER_PLATFORMS = ["web", "ios", "android", "macos", "windows", "linux"];
+var PLATFORM_SET = new Set(HANDLER_PLATFORMS);
+function parseHandlerInformation(event) {
+  let identifier = "";
+  const kinds = [];
+  const seenKinds = /* @__PURE__ */ new Set();
+  const platforms = {};
+  for (const tag of event.tags) {
+    const name = tag[0];
+    if (name === "d") {
+      identifier = tag[1] ?? "";
+    } else if (name === "k") {
+      const k = Number(tag[1]);
+      if (Number.isInteger(k) && !seenKinds.has(k)) {
+        seenKinds.add(k);
+        kinds.push(k);
+      }
+    } else if (PLATFORM_SET.has(name) && typeof tag[1] === "string" && tag[1].length > 0) {
+      const platform = name;
+      (platforms[platform] ??= []).push({ url: tag[1], entity: tag[2] });
+    }
+  }
+  return {
+    pubkey: event.pubkey,
+    identifier,
+    address: `${HANDLER_INFORMATION_KIND}:${event.pubkey}:${identifier}`,
+    kinds,
+    metadata: parseJsonObject(event.content),
+    platforms
+  };
+}
+function handlesKind(info, kind) {
+  return info.kinds.includes(kind);
+}
+function buildHandlerUrl(target, values) {
+  const template = typeof target === "string" ? target : target.url;
+  if (template.includes("<bech32>") && values.bech32 === void 0) return void 0;
+  if (template.includes("<raw>") && values.raw === void 0) return void 0;
+  return template.replace(/<bech32>/g, values.bech32 ?? "").replace(/<raw>/g, values.raw ?? "");
+}
+function parseHandlerRecommendation(event) {
+  let recommendedKind;
+  const recommendations = [];
+  for (const tag of event.tags) {
+    if (tag[0] === "d") {
+      const k = Number(tag[1]);
+      recommendedKind = Number.isInteger(k) ? k : void 0;
+    } else if (tag[0] === "a" && typeof tag[1] === "string" && tag[1].startsWith(`${HANDLER_INFORMATION_KIND}:`)) {
+      const [, handlerPubkey, identifier] = tag[1].split(":");
+      recommendations.push({
+        address: tag[1],
+        handlerPubkey: handlerPubkey || void 0,
+        identifier: identifier ?? void 0,
+        relay: tag[2] || void 0,
+        platform: tag[3] || void 0
+      });
+    }
+  }
+  return { pubkey: event.pubkey, recommendedKind, recommendations };
+}
+function parseJsonObject(content) {
+  if (!content) return {};
+  try {
+    const parsed = JSON.parse(content);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+export {
+  HANDLER_INFORMATION_KIND,
+  HANDLER_RECOMMENDATION_KIND,
+  HANDLER_PLATFORMS,
+  parseHandlerInformation,
+  handlesKind,
+  buildHandlerUrl,
+  parseHandlerRecommendation
+};
+//# sourceMappingURL=chunk-BCTIL523.js.map

package/dist/chunk-BCTIL523.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/89/index.ts"],"sourcesContent":["import type { NostrEvent } from 'nostr-tools';\n\n/**\n * `@kehto/nip/89` — NIP-89 application-handler discovery.\n *\n * NIP-89 lets clients answer \"who can open an event of kind N?\" without\n * hardcoding app knowledge — essential for any runtime that hosts or launches\n * other apps (the napplet model, \"open with…\" menus, unknown-kind fallbacks).\n *\n * Two event kinds:\n * - **kind 31990 — handler information.** An app advertises which kinds it\n *   handles (`k` tags) and per-platform URL templates to open an entity\n *   (`[\"web\", \"https://app/e/<bech32>\", \"nevent\"]`).\n * - **kind 31989 — handler recommendation.** A user recommends a handler for a\n *   given kind via `a` tags pointing at 31990 addresses.\n *\n * `nostr-tools` ships no NIP-89 helper. This module provides pure parsers for\n * both kinds plus URL-template expansion — no relay, signer, or framework\n * coupling.\n */\n\n/** Kind 31990 — handler information (an app describing what it can open). */\nexport const HANDLER_INFORMATION_KIND = 31990;\n/** Kind 31989 — handler recommendation (a user endorsing a handler for a kind). */\nexport const HANDLER_RECOMMENDATION_KIND = 31989;\n\n/** Platform tag names defined by NIP-89 for handler URL templates. */\nexport const HANDLER_PLATFORMS = ['web', 'ios', 'android', 'macos', 'windows', 'linux'] as const;\n/** One of the NIP-89 platform identifiers. */\nexport type HandlerPlatform = (typeof HANDLER_PLATFORMS)[number];\n\nconst PLATFORM_SET = new Set<string>(HANDLER_PLATFORMS);\n\n/**\n * One platform-specific way to open an entity, from a 31990 platform tag.\n *\n * @example\n * ```ts\n * // tag [\"web\", \"https://app.example/e/<bech32>\", \"nevent\"]\n * const target: HandlerTarget = { url: 'https://app.example/e/<bech32>', entity: 'nevent' };\n * ```\n */\nexport interface HandlerTarget {\n  /** URL template containing a `<bech32>` and/or `<raw>` placeholder. */\n  url: string;\n  /** Optional NIP-19 entity type this template is for (e.g. `'nevent'`, `'naddr'`, `'nprofile'`). */\n  entity: string | undefined;\n}\n\n/**\n * A parsed kind-31990 handler-information event.\n *\n * @example\n * ```ts\n * const info = parseHandlerInformation(event);\n * info.kinds;            // [1, 30023]\n * info.metadata.name;    // 'My Reader'\n * info.platforms.web;    // [{ url: 'https://app/<bech32>', entity: 'nevent' }]\n * ```\n */\nexport interface HandlerInformation {\n  /** Handler author pubkey. */\n  pubkey: string;\n  /** `d`-tag identifier (handler instance id). */\n  identifier: string;\n  /** Addressable coordinate `31990:pubkey:d`. */\n  address: string;\n  /** Event kinds the handler declares support for (from `k` tags, de-duplicated). */\n  kinds: number[];\n  /** Parsed kind-0-style metadata from `content` (name, display_name, picture, about, …). `{}` if absent/invalid. */\n  metadata: Record<string, unknown>;\n  /** Per-platform URL templates, keyed by {@link HandlerPlatform}. Only platforms present in the event appear. */\n  platforms: Partial<Record<HandlerPlatform, HandlerTarget[]>>;\n}\n\n/**\n * Parse a kind-31990 handler-information event.\n *\n * @param event - A kind-31990 event (kind is not re-validated)\n * @returns The structured handler information\n *\n * @example\n * ```ts\n * import { parseHandlerInformation, handlesKind } from '@kehto/nip/89';\n * const info = parseHandlerInformation(event);\n * if (handlesKind(info, 1)) openWith(info);\n * ```\n */\nexport function parseHandlerInformation(event: NostrEvent): HandlerInformation {\n  let identifier = '';\n  const kinds: number[] = [];\n  const seenKinds = new Set<number>();\n  const platforms: Partial<Record<HandlerPlatform, HandlerTarget[]>> = {};\n\n  for (const tag of event.tags) {\n    const name = tag[0];\n    if (name === 'd') {\n      identifier = tag[1] ?? '';\n    } else if (name === 'k') {\n      const k = Number(tag[1]);\n      if (Number.isInteger(k) && !seenKinds.has(k)) {\n        seenKinds.add(k);\n        kinds.push(k);\n      }\n    } else if (PLATFORM_SET.has(name) && typeof tag[1] === 'string' && tag[1].length > 0) {\n      const platform = name as HandlerPlatform;\n      (platforms[platform] ??= []).push({ url: tag[1], entity: tag[2] });\n    }\n  }\n\n  return {\n    pubkey: event.pubkey,\n    identifier,\n    address: `${HANDLER_INFORMATION_KIND}:${event.pubkey}:${identifier}`,\n    kinds,\n    metadata: parseJsonObject(event.content),\n    platforms,\n  };\n}\n\n/**\n * Whether a handler declares support for `kind`.\n *\n * @param info - Parsed handler information\n * @param kind - Event kind to check\n */\nexport function handlesKind(info: HandlerInformation, kind: number): boolean {\n  return info.kinds.includes(kind);\n}\n\n/**\n * Substitution values for {@link buildHandlerUrl}.\n *\n * NIP-89 templates use `<bech32>` (NIP-19 encoded entity) and/or `<raw>`\n * (hex id / address coordinate). Supply whichever the template needs.\n */\nexport interface HandlerEntityValues {\n  /** NIP-19 bech32 entity (e.g. an `nevent…`, `naddr…`, `nprofile…`). */\n  bech32?: string;\n  /** Raw value (hex event id, or `kind:pubkey:d` coordinate). */\n  raw?: string;\n}\n\n/**\n * Expand a handler URL template by substituting its `<bech32>` / `<raw>`\n * placeholders.\n *\n * Returns `undefined` when the template requires a placeholder you didn't\n * supply (e.g. it contains `<bech32>` but `values.bech32` is missing) — so a\n * caller can fall through to the next target instead of producing a broken URL.\n *\n * @param target - A {@link HandlerTarget} or a raw template string\n * @param values - The `<bech32>` / `<raw>` substitutions\n * @returns The expanded URL, or `undefined` if a needed placeholder is absent\n *\n * @example\n * ```ts\n * buildHandlerUrl({ url: 'https://app/e/<bech32>', entity: 'nevent' }, { bech32: 'nevent1…' });\n * // 'https://app/e/nevent1…'\n * ```\n */\nexport function buildHandlerUrl(target: HandlerTarget | string, values: HandlerEntityValues): string | undefined {\n  const template = typeof target === 'string' ? target : target.url;\n  if (template.includes('<bech32>') && values.bech32 === undefined) return undefined;\n  if (template.includes('<raw>') && values.raw === undefined) return undefined;\n  return template\n    .replace(/<bech32>/g, values.bech32 ?? '')\n    .replace(/<raw>/g, values.raw ?? '');\n}\n\n/** One handler endorsement parsed from a 31989 `a` tag. */\nexport interface HandlerRecommendationEntry {\n  /** The recommended handler's 31990 coordinate `31990:pubkey:d`. */\n  address: string;\n  /** Handler author pubkey extracted from the coordinate, if well-formed. */\n  handlerPubkey: string | undefined;\n  /** Handler `d`-tag identifier extracted from the coordinate, if present. */\n  identifier: string | undefined;\n  /** Optional relay-hint where the 31990 event can be found (`a`-tag 3rd element). */\n  relay: string | undefined;\n  /** Optional platform marker the handler is recommended for (`a`-tag 4th element). */\n  platform: string | undefined;\n}\n\n/**\n * A parsed kind-31989 handler-recommendation event.\n *\n * @example\n * ```ts\n * const rec = parseHandlerRecommendation(event);\n * rec.recommendedKind;          // 1\n * rec.recommendations[0].address; // '31990:pubkey:d'\n * ```\n */\nexport interface HandlerRecommendation {\n  /** Recommendation author pubkey. */\n  pubkey: string;\n  /** The kind being recommended for, parsed from the `d` tag; `undefined` if non-numeric/missing. */\n  recommendedKind: number | undefined;\n  /** Endorsed handlers, in tag order. */\n  recommendations: HandlerRecommendationEntry[];\n}\n\n/**\n * Parse a kind-31989 handler-recommendation event.\n *\n * The `d` tag carries the kind being recommended for; each `a` tag (whose\n * coordinate starts with `31990:`) endorses one handler, optionally with a\n * relay hint and platform marker.\n *\n * @param event - A kind-31989 event (kind is not re-validated)\n * @returns The structured recommendation\n */\nexport function parseHandlerRecommendation(event: NostrEvent): HandlerRecommendation {\n  let recommendedKind: number | undefined;\n  const recommendations: HandlerRecommendationEntry[] = [];\n\n  for (const tag of event.tags) {\n    if (tag[0] === 'd') {\n      const k = Number(tag[1]);\n      recommendedKind = Number.isInteger(k) ? k : undefined;\n    } else if (tag[0] === 'a' && typeof tag[1] === 'string' && tag[1].startsWith(`${HANDLER_INFORMATION_KIND}:`)) {\n      const [, handlerPubkey, identifier] = tag[1].split(':');\n      recommendations.push({\n        address: tag[1],\n        handlerPubkey: handlerPubkey || undefined,\n        identifier: identifier ?? undefined,\n        relay: tag[2] || undefined,\n        platform: tag[3] || undefined,\n      });\n    }\n  }\n\n  return { pubkey: event.pubkey, recommendedKind, recommendations };\n}\n\nfunction parseJsonObject(content: string): Record<string, unknown> {\n  if (!content) return {};\n  try {\n    const parsed: unknown = JSON.parse(content);\n    return parsed && typeof parsed === 'object' && !Array.isArray(parsed)\n      ? (parsed as Record<string, unknown>)\n      : {};\n  } catch {\n    return {};\n  }\n}\n"],"mappings":";AAsBO,IAAM,2BAA2B;AAEjC,IAAM,8BAA8B;AAGpC,IAAM,oBAAoB,CAAC,OAAO,OAAO,WAAW,SAAS,WAAW,OAAO;AAItF,IAAM,eAAe,IAAI,IAAY,iBAAiB;AAyD/C,SAAS,wBAAwB,OAAuC;AAC7E,MAAI,aAAa;AACjB,QAAM,QAAkB,CAAC;AACzB,QAAM,YAAY,oBAAI,IAAY;AAClC,QAAM,YAA+D,CAAC;AAEtE,aAAW,OAAO,MAAM,MAAM;AAC5B,UAAM,OAAO,IAAI,CAAC;AAClB,QAAI,SAAS,KAAK;AAChB,mBAAa,IAAI,CAAC,KAAK;AAAA,IACzB,WAAW,SAAS,KAAK;AACvB,YAAM,IAAI,OAAO,IAAI,CAAC,CAAC;AACvB,UAAI,OAAO,UAAU,CAAC,KAAK,CAAC,UAAU,IAAI,CAAC,GAAG;AAC5C,kBAAU,IAAI,CAAC;AACf,cAAM,KAAK,CAAC;AAAA,MACd;AAAA,IACF,WAAW,aAAa,IAAI,IAAI,KAAK,OAAO,IAAI,CAAC,MAAM,YAAY,IAAI,CAAC,EAAE,SAAS,GAAG;AACpF,YAAM,WAAW;AACjB,OAAC,UAAU,QAAQ,MAAM,CAAC,GAAG,KAAK,EAAE,KAAK,IAAI,CAAC,GAAG,QAAQ,IAAI,CAAC,EAAE,CAAC;AAAA,IACnE;AAAA,EACF;AAEA,SAAO;AAAA,IACL,QAAQ,MAAM;AAAA,IACd;AAAA,IACA,SAAS,GAAG,wBAAwB,IAAI,MAAM,MAAM,IAAI,UAAU;AAAA,IAClE;AAAA,IACA,UAAU,gBAAgB,MAAM,OAAO;AAAA,IACvC;AAAA,EACF;AACF;AAQO,SAAS,YAAY,MAA0B,MAAuB;AAC3E,SAAO,KAAK,MAAM,SAAS,IAAI;AACjC;AAiCO,SAAS,gBAAgB,QAAgC,QAAiD;AAC/G,QAAM,WAAW,OAAO,WAAW,WAAW,SAAS,OAAO;AAC9D,MAAI,SAAS,SAAS,UAAU,KAAK,OAAO,WAAW,OAAW,QAAO;AACzE,MAAI,SAAS,SAAS,OAAO,KAAK,OAAO,QAAQ,OAAW,QAAO;AACnE,SAAO,SACJ,QAAQ,aAAa,OAAO,UAAU,EAAE,EACxC,QAAQ,UAAU,OAAO,OAAO,EAAE;AACvC;AA6CO,SAAS,2BAA2B,OAA0C;AACnF,MAAI;AACJ,QAAM,kBAAgD,CAAC;AAEvD,aAAW,OAAO,MAAM,MAAM;AAC5B,QAAI,IAAI,CAAC,MAAM,KAAK;AAClB,YAAM,IAAI,OAAO,IAAI,CAAC,CAAC;AACvB,wBAAkB,OAAO,UAAU,CAAC,IAAI,IAAI;AAAA,IAC9C,WAAW,IAAI,CAAC,MAAM,OAAO,OAAO,IAAI,CAAC,MAAM,YAAY,IAAI,CAAC,EAAE,WAAW,GAAG,wBAAwB,GAAG,GAAG;AAC5G,YAAM,CAAC,EAAE,eAAe,UAAU,IAAI,IAAI,CAAC,EAAE,MAAM,GAAG;AACtD,sBAAgB,KAAK;AAAA,QACnB,SAAS,IAAI,CAAC;AAAA,QACd,eAAe,iBAAiB;AAAA,QAChC,YAAY,cAAc;AAAA,QAC1B,OAAO,IAAI,CAAC,KAAK;AAAA,QACjB,UAAU,IAAI,CAAC,KAAK;AAAA,MACtB,CAAC;AAAA,IACH;AAAA,EACF;AAEA,SAAO,EAAE,QAAQ,MAAM,QAAQ,iBAAiB,gBAAgB;AAClE;AAEA,SAAS,gBAAgB,SAA0C;AACjE,MAAI,CAAC,QAAS,QAAO,CAAC;AACtB,MAAI;AACF,UAAM,SAAkB,KAAK,MAAM,OAAO;AAC1C,WAAO,UAAU,OAAO,WAAW,YAAY,CAAC,MAAM,QAAQ,MAAM,IAC/D,SACD,CAAC;AAAA,EACP,QAAQ;AACN,WAAO,CAAC;AAAA,EACV;AACF;","names":[]}

package/dist/chunk-CDBUCFLP.js

@@ -0,0 +1,572 @@
+import {
+  aggregateTagValue,
+  computeAggregateHash,
+  pathEntriesFromTags
+} from "./chunk-2J3CSGKL.js";
+
+// src/5d/index.ts
+import { verifyEvent } from "nostr-tools/pure";
+import { sha256 } from "@noble/hashes/sha2.js";
+import { bytesToHex } from "@noble/hashes/utils.js";
+
+// src/5d/artifact-cache.ts
+var MIB = 1024 * 1024;
+var NAPPLET_ARTIFACT_CACHE_NAME = "kehto:napplet-artifacts:v1";
+var SCHEMA_VERSION = 1;
+var DEFAULT_BASE_URL = "https://kehto.invalid";
+var DEFAULT_UNKNOWN_BUDGET_BYTES = 32 * MIB;
+var DEFAULT_SOFT_CEILING_BYTES = 128 * MIB;
+var DEFAULT_HARD_CEILING_BYTES = 256 * MIB;
+var DEFAULT_FOREGROUND_TTL_MS = 15 * 60 * 1e3;
+var DEFAULT_BACKGROUND_TTL_MS = 60 * 60 * 1e3;
+function emptyIndex(now) {
+  return {
+    schemaVersion: SCHEMA_VERSION,
+    updatedAt: now,
+    blobs: {},
+    aggregates: {},
+    coordinates: {}
+  };
+}
+function aggregateKey(dTag, aggregateHash) {
+  return `${encodeURIComponent(dTag)}:${aggregateHash}`;
+}
+function coordinateKey(kind, pubkey, dTag) {
+  return `${kind}:${pubkey}:${encodeURIComponent(dTag)}`;
+}
+function isCoordinateFresh(coordinate, options = {}) {
+  const now = options.now ?? Date.now();
+  const ttl = options.background ? coordinate.backgroundTtlMs : coordinate.foregroundTtlMs;
+  return ttl === Number.POSITIVE_INFINITY || now - coordinate.lastResolvedAt <= ttl;
+}
+function byteLength(bytes) {
+  return bytes.byteLength;
+}
+function encodeKeyPart(value) {
+  return encodeURIComponent(value).replaceAll("%2F", "%252F");
+}
+function cloneBytes(bytes) {
+  return new Uint8Array(bytes);
+}
+function responseBody(bytes) {
+  return cloneBytes(bytes).buffer;
+}
+function normalizeBaseUrl(baseUrl) {
+  return baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+}
+function resolveBaseUrl(baseUrl) {
+  if (baseUrl) return normalizeBaseUrl(baseUrl);
+  const maybeLocation = globalThis;
+  if (maybeLocation.location?.origin) return normalizeBaseUrl(maybeLocation.location.origin);
+  return normalizeBaseUrl(DEFAULT_BASE_URL);
+}
+async function responseBytes(response) {
+  return new Uint8Array(await response.arrayBuffer());
+}
+async function responseJson(response) {
+  return response.json();
+}
+function refCounts(index) {
+  const counts = {};
+  for (const aggregate of Object.values(index.aggregates)) {
+    for (const hash of aggregate.blobHashes) counts[hash] = (counts[hash] ?? 0) + 1;
+  }
+  return counts;
+}
+function cachedSize(index) {
+  const blobBytes = Object.values(index.blobs).reduce((sum, entry) => sum + entry.size, 0);
+  const aggregateBytes = Object.values(index.aggregates).reduce((sum, entry) => sum + entry.size, 0);
+  return blobBytes + aggregateBytes;
+}
+var CacheStorageNappletArtifactCache = class {
+  cacheStorage;
+  storage;
+  cacheName;
+  baseUrl;
+  now;
+  activeAggregates = /* @__PURE__ */ new Set();
+  onDiagnostic;
+  unknownBudgetBytes;
+  softCeilingBytes;
+  hardCeilingBytes;
+  cachePromise;
+  constructor(options = {}) {
+    const maybeCacheStorage = options.cacheStorage ?? globalThis.caches;
+    if (!maybeCacheStorage) {
+      throw new Error("Cache Storage is unavailable");
+    }
+    this.cacheStorage = maybeCacheStorage;
+    this.storage = options.storage ?? globalThis.navigator?.storage;
+    this.cacheName = options.cacheName ?? NAPPLET_ARTIFACT_CACHE_NAME;
+    this.baseUrl = resolveBaseUrl(options.baseUrl);
+    this.now = options.now ?? Date.now;
+    this.onDiagnostic = options.onDiagnostic;
+    this.unknownBudgetBytes = options.unknownBudgetBytes ?? DEFAULT_UNKNOWN_BUDGET_BYTES;
+    this.softCeilingBytes = options.softCeilingBytes ?? DEFAULT_SOFT_CEILING_BYTES;
+    this.hardCeilingBytes = options.hardCeilingBytes ?? DEFAULT_HARD_CEILING_BYTES;
+  }
+  async readBlob(sha256Hex) {
+    try {
+      const cache = await this.open();
+      const response = await cache.match(this.blobUrl(sha256Hex));
+      if (!response) return void 0;
+      const bytes = await responseBytes(response);
+      const index = await this.readIndex(cache);
+      const entry = index.blobs[sha256Hex];
+      if (entry) {
+        entry.lastAccessed = this.now();
+        index.updatedAt = entry.lastAccessed;
+        await this.writeIndex(cache, index);
+      }
+      return bytes;
+    } catch (cause) {
+      this.diagnostic({ type: "cache-read-failed", message: `failed to read blob ${sha256Hex}`, cause });
+      return void 0;
+    }
+  }
+  async deleteBlob(sha256Hex) {
+    try {
+      const cache = await this.open();
+      await cache.delete(this.blobUrl(sha256Hex));
+      const index = await this.readIndex(cache);
+      delete index.blobs[sha256Hex];
+      index.updatedAt = this.now();
+      await this.writeIndex(cache, index);
+    } catch (cause) {
+      this.diagnostic({ type: "cache-delete-failed", message: `failed to delete blob ${sha256Hex}`, cause });
+    }
+  }
+  async writeVerifiedResolution(input) {
+    try {
+      await this.writeVerifiedResolutionOnce(input);
+    } catch (firstCause) {
+      try {
+        await this.prune(input.now ?? this.now());
+        await this.writeVerifiedResolutionOnce(input);
+      } catch (cause) {
+        this.diagnostic({
+          type: "cache-write-failed",
+          message: "failed to write verified napplet artifacts after prune retry",
+          cause: cause ?? firstCause
+        });
+      }
+    }
+  }
+  async writeCoordinate(input) {
+    const cache = await this.open();
+    const now = this.now();
+    const index = await this.readIndex(cache);
+    const key = coordinateKey(input.kind, input.pubkey, input.dTag);
+    index.coordinates[key] = {
+      key,
+      kind: input.kind,
+      pubkey: input.pubkey,
+      dTag: input.dTag,
+      aggregateHash: input.aggregateHash,
+      lastResolvedAt: input.lastResolvedAt ?? now,
+      foregroundTtlMs: input.foregroundTtlMs ?? DEFAULT_FOREGROUND_TTL_MS,
+      backgroundTtlMs: input.backgroundTtlMs ?? DEFAULT_BACKGROUND_TTL_MS
+    };
+    index.updatedAt = now;
+    await this.writeIndex(cache, index);
+  }
+  async getCoordinate(input, options = {}) {
+    const cache = await this.open();
+    const index = await this.readIndex(cache);
+    const coordinate = index.coordinates[coordinateKey(input.kind, input.pubkey, input.dTag)];
+    if (!coordinate) return void 0;
+    return { ...coordinate, fresh: isCoordinateFresh(coordinate, options) };
+  }
+  async touchAggregate(dTag, aggregateHash, now = this.now()) {
+    const cache = await this.open();
+    const index = await this.readIndex(cache);
+    const key = aggregateKey(dTag, aggregateHash);
+    const aggregate = index.aggregates[key];
+    if (!aggregate) return;
+    aggregate.lastAccessed = now;
+    for (const hash of aggregate.blobHashes) {
+      if (index.blobs[hash]) index.blobs[hash].lastAccessed = now;
+    }
+    index.updatedAt = now;
+    await this.writeIndex(cache, index);
+  }
+  markAggregateActive(dTag, aggregateHash) {
+    this.activeAggregates.add(aggregateKey(dTag, aggregateHash));
+  }
+  releaseAggregateActive(dTag, aggregateHash) {
+    this.activeAggregates.delete(aggregateKey(dTag, aggregateHash));
+  }
+  async prune(now = this.now()) {
+    try {
+      const cache = await this.open();
+      const index = await this.readIndex(cache);
+      let size = cachedSize(index);
+      const budget = await this.budgetBytes();
+      const hardBudget = await this.hardBudgetBytes();
+      const shouldPrune = size > budget || await this.originPressureHigh();
+      if (!shouldPrune) return;
+      this.rewriteRefCounts(index);
+      for (const [hash, blob] of Object.entries(index.blobs)) {
+        if (size <= budget) break;
+        if (blob.refCount > 0) continue;
+        await cache.delete(this.blobUrl(hash));
+        delete index.blobs[hash];
+        size -= blob.size;
+      }
+      const currentAggregateHashes = new Set(
+        Object.values(index.coordinates).map((coordinate) => coordinate.aggregateHash)
+      );
+      const aggregates = Object.values(index.aggregates).filter((entry) => !this.activeAggregates.has(entry.key)).sort((a, b) => {
+        const currentA = currentAggregateHashes.has(a.aggregateHash) ? 1 : 0;
+        const currentB = currentAggregateHashes.has(b.aggregateHash) ? 1 : 0;
+        if (currentA !== currentB) return currentA - currentB;
+        return a.lastAccessed - b.lastAccessed;
+      });
+      for (const aggregate of aggregates) {
+        if (size <= budget) break;
+        await cache.delete(this.aggregateUrl(aggregate.key));
+        delete index.aggregates[aggregate.key];
+        size -= aggregate.size;
+        this.rewriteRefCounts(index);
+      }
+      if (size > hardBudget) {
+        const active = Object.values(index.aggregates).filter((entry) => this.activeAggregates.has(entry.key)).sort((a, b) => a.lastAccessed - b.lastAccessed);
+        for (const aggregate of active) {
+          if (size <= hardBudget) break;
+          await cache.delete(this.aggregateUrl(aggregate.key));
+          delete index.aggregates[aggregate.key];
+          size -= aggregate.size;
+        }
+      }
+      this.rewriteRefCounts(index);
+      for (const [hash, blob] of Object.entries(index.blobs)) {
+        if (blob.refCount === 0) {
+          await cache.delete(this.blobUrl(hash));
+          delete index.blobs[hash];
+        }
+      }
+      index.updatedAt = now;
+      await this.writeIndex(cache, index);
+    } catch (cause) {
+      this.diagnostic({ type: "cache-prune-failed", message: "failed to prune napplet artifact cache", cause });
+    }
+  }
+  async snapshotIndex() {
+    return this.readIndex(await this.open());
+  }
+  async writeVerifiedResolutionOnce(input) {
+    const cache = await this.open();
+    const now = input.now ?? this.now();
+    const index = await this.readIndex(cache);
+    const blobHashes = [];
+    for (const pathEntry of input.manifest.paths) {
+      const bytes = input.files.get(pathEntry.path);
+      if (!bytes) continue;
+      blobHashes.push(pathEntry.sha256);
+      await cache.put(this.blobUrl(pathEntry.sha256), new Response(responseBody(bytes)));
+      index.blobs[pathEntry.sha256] = {
+        size: byteLength(bytes),
+        lastAccessed: now,
+        refCount: index.blobs[pathEntry.sha256]?.refCount ?? 0
+      };
+    }
+    const key = aggregateKey(input.manifest.dTag, input.manifest.aggregateHash);
+    const record = {
+      schemaVersion: SCHEMA_VERSION,
+      dTag: input.manifest.dTag,
+      aggregateHash: input.manifest.aggregateHash,
+      manifest: {
+        kind: input.manifest.kind,
+        pubkey: input.manifest.pubkey,
+        dTag: input.manifest.dTag,
+        paths: input.manifest.paths.map((entry) => ({ path: entry.path, sha256: entry.sha256 })),
+        requires: [...input.manifest.requires],
+        ...input.manifest.title === void 0 ? {} : { title: input.manifest.title },
+        ...input.manifest.description === void 0 ? {} : { description: input.manifest.description }
+      },
+      indexHtml: input.indexHtml,
+      blobHashes,
+      writtenAt: now
+    };
+    const aggregateBytes = new TextEncoder().encode(JSON.stringify(record));
+    await cache.put(this.aggregateUrl(key), new Response(responseBody(aggregateBytes), {
+      headers: { "content-type": "application/json" }
+    }));
+    const coordKey = coordinateKey(input.manifest.kind, input.manifest.pubkey, input.manifest.dTag);
+    index.aggregates[key] = {
+      dTag: input.manifest.dTag,
+      aggregateHash: input.manifest.aggregateHash,
+      key,
+      blobHashes,
+      size: byteLength(aggregateBytes),
+      lastAccessed: now,
+      coordinateKey: coordKey
+    };
+    index.coordinates[coordKey] = {
+      key: coordKey,
+      kind: input.manifest.kind,
+      pubkey: input.manifest.pubkey,
+      dTag: input.manifest.dTag,
+      aggregateHash: input.manifest.aggregateHash,
+      lastResolvedAt: now,
+      foregroundTtlMs: DEFAULT_FOREGROUND_TTL_MS,
+      backgroundTtlMs: DEFAULT_BACKGROUND_TTL_MS
+    };
+    this.rewriteRefCounts(index);
+    index.updatedAt = now;
+    await this.writeIndex(cache, index);
+    await this.prune(now);
+  }
+  async open() {
+    this.cachePromise ??= this.cacheStorage.open(this.cacheName);
+    return this.cachePromise;
+  }
+  indexUrl() {
+    return new URL("__kehto_napplet_cache/index.json", this.baseUrl).toString();
+  }
+  blobUrl(hash) {
+    return new URL(`__kehto_napplet_cache/blob/${encodeKeyPart(hash)}`, this.baseUrl).toString();
+  }
+  aggregateUrl(key) {
+    return new URL(`__kehto_napplet_cache/aggregate/${encodeKeyPart(key)}.json`, this.baseUrl).toString();
+  }
+  async readIndex(cache) {
+    const response = await cache.match(this.indexUrl());
+    if (!response) return emptyIndex(this.now());
+    try {
+      const index = await responseJson(response);
+      if (index.schemaVersion !== SCHEMA_VERSION) return emptyIndex(this.now());
+      return index;
+    } catch {
+      return emptyIndex(this.now());
+    }
+  }
+  async writeIndex(cache, index) {
+    await cache.put(this.indexUrl(), new Response(JSON.stringify(index), {
+      headers: { "content-type": "application/json" }
+    }));
+  }
+  rewriteRefCounts(index) {
+    const counts = refCounts(index);
+    for (const [hash, blob] of Object.entries(index.blobs)) {
+      blob.refCount = counts[hash] ?? 0;
+    }
+  }
+  async budgetBytes() {
+    const estimate = await this.estimateStorage();
+    if (!estimate?.quota) return this.unknownBudgetBytes;
+    return Math.min(this.softCeilingBytes, Math.floor(estimate.quota * 0.1));
+  }
+  async hardBudgetBytes() {
+    const estimate = await this.estimateStorage();
+    if (!estimate?.quota) return this.unknownBudgetBytes;
+    return Math.min(this.hardCeilingBytes, Math.floor(estimate.quota * 0.2));
+  }
+  async originPressureHigh() {
+    const estimate = await this.estimateStorage();
+    if (!estimate?.quota || estimate.usage === void 0) return false;
+    return estimate.usage / estimate.quota >= 0.8;
+  }
+  async estimateStorage() {
+    if (!this.storage?.estimate) return void 0;
+    try {
+      return this.storage.estimate();
+    } catch (cause) {
+      this.diagnostic({
+        type: "storage-estimate-unavailable",
+        message: "storage estimate failed; using unknown quota cache budget",
+        cause
+      });
+      return void 0;
+    }
+  }
+  diagnostic(diagnostic) {
+    this.onDiagnostic?.(diagnostic);
+  }
+};
+async function openNappletArtifactCache(options = {}) {
+  const cacheStorage = options.cacheStorage ?? globalThis.caches;
+  if (!cacheStorage) return void 0;
+  const storage = options.storage ?? globalThis.navigator?.storage;
+  if (options.requireStorageEstimate && !storage?.estimate) {
+    options.onDiagnostic?.({
+      type: "storage-estimate-unavailable",
+      message: "storage estimates are unavailable; using network-only loading"
+    });
+    return void 0;
+  }
+  try {
+    const cache = new CacheStorageNappletArtifactCache({ ...options, cacheStorage, storage });
+    await cache.snapshotIndex();
+    return cache;
+  } catch (cause) {
+    options.onDiagnostic?.({
+      type: "cache-open-failed",
+      message: "Cache Storage napplet artifact cache could not be opened",
+      cause
+    });
+    return void 0;
+  }
+}
+
+// src/5d/index.ts
+var NAPPLET_KIND_SNAPSHOT = 5129;
+var NAPPLET_KIND_ROOT = 15129;
+var NAPPLET_KIND_NAMED = 35129;
+var NAPPLET_KINDS = [
+  NAPPLET_KIND_SNAPSHOT,
+  NAPPLET_KIND_ROOT,
+  NAPPLET_KIND_NAMED
+];
+function isNappletManifestKind(kind) {
+  return NAPPLET_KINDS.includes(kind);
+}
+var NappletResolutionError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "NappletResolutionError";
+    this.code = code;
+  }
+};
+function firstTagValue(tags, name) {
+  for (const tag of tags) {
+    if (tag[0] === name && typeof tag[1] === "string" && tag[1].length > 0) return tag[1];
+  }
+  return void 0;
+}
+function allTagValues(tags, name) {
+  const out = [];
+  for (const tag of tags) {
+    if (tag[0] === name && typeof tag[1] === "string" && tag[1].length > 0) out.push(tag[1]);
+  }
+  return out;
+}
+function archetypesFromTags(tags) {
+  const out = [];
+  for (const tag of tags) {
+    if (tag[0] !== "archetype") continue;
+    if (typeof tag[1] !== "string" || tag[1].length === 0) continue;
+    out.push(
+      typeof tag[2] === "string" && tag[2].length > 0 ? { slug: tag[1], nap: tag[2] } : { slug: tag[1] }
+    );
+  }
+  return out;
+}
+function parseNappletManifest(event) {
+  if (!isNappletManifestKind(event.kind)) {
+    throw new NappletResolutionError("invalid-manifest", `not a NIP-5D napplet kind: ${event.kind}`);
+  }
+  const paths = pathEntriesFromTags(event.tags);
+  if (paths.length === 0) {
+    throw new NappletResolutionError("invalid-manifest", "manifest has no path tags");
+  }
+  const aggregateHash = aggregateTagValue(event.tags);
+  if (!aggregateHash) {
+    throw new NappletResolutionError("invalid-manifest", "manifest has no aggregate x tag");
+  }
+  return {
+    kind: event.kind,
+    pubkey: event.pubkey,
+    dTag: firstTagValue(event.tags, "d") ?? "",
+    paths,
+    aggregateHash,
+    servers: allTagValues(event.tags, "server"),
+    requires: allTagValues(event.tags, "requires"),
+    archetypes: archetypesFromTags(event.tags),
+    title: firstTagValue(event.tags, "title"),
+    description: firstTagValue(event.tags, "description"),
+    source: firstTagValue(event.tags, "source")
+  };
+}
+function verifyManifestSignature(event) {
+  try {
+    return verifyEvent(event);
+  } catch {
+    return false;
+  }
+}
+function verifyBlobHash(bytes, sha256Hex) {
+  return bytesToHex(sha256(bytes)) === sha256Hex;
+}
+function stripTrailingSlash(url) {
+  return url.endsWith("/") ? url.slice(0, -1) : url;
+}
+async function fetchBlob(servers, sha256Hex, fetchBytes) {
+  for (const server of servers) {
+    const url = `${stripTrailingSlash(server)}/${sha256Hex}`;
+    try {
+      const bytes = await fetchBytes(url);
+      if (verifyBlobHash(bytes, sha256Hex)) return bytes;
+    } catch {
+    }
+  }
+  throw new NappletResolutionError("blob-unavailable", `no server served blob ${sha256Hex}`);
+}
+var INDEX_PATHS = ["/index.html", "index.html", "/"];
+function defaultDecode(bytes) {
+  return new TextDecoder().decode(bytes);
+}
+async function resolveNapplet(options) {
+  const { event, fetchBlob: fetchBlobBytes, textDecode = defaultDecode, cache } = options;
+  if (!verifyManifestSignature(event)) {
+    throw new NappletResolutionError("invalid-signature", "manifest signature is invalid");
+  }
+  const manifest = parseNappletManifest(event);
+  const recomputed = computeAggregateHash(manifest.paths);
+  if (recomputed !== manifest.aggregateHash) {
+    throw new NappletResolutionError(
+      "aggregate-mismatch",
+      `recomputed aggregate ${recomputed} != manifest ${manifest.aggregateHash}`
+    );
+  }
+  const files = /* @__PURE__ */ new Map();
+  for (const entry of manifest.paths) {
+    let bytes = await cache?.readBlob(entry.sha256);
+    if (bytes && !verifyBlobHash(bytes, entry.sha256)) {
+      await cache?.deleteBlob(entry.sha256);
+      bytes = void 0;
+    }
+    bytes ??= await fetchBlobBytes(entry.sha256, manifest.servers);
+    if (!verifyBlobHash(bytes, entry.sha256)) {
+      throw new NappletResolutionError(
+        "blob-hash-mismatch",
+        `blob for ${entry.path} does not match hash ${entry.sha256}`
+      );
+    }
+    files.set(entry.path, bytes);
+  }
+  const indexEntry = manifest.paths.find((e) => INDEX_PATHS.includes(e.path));
+  if (!indexEntry) {
+    throw new NappletResolutionError("missing-index", "manifest has no /index.html entry");
+  }
+  const indexHtml = textDecode(files.get(indexEntry.path));
+  await cache?.writeVerifiedResolution({ event, manifest, files, indexHtml });
+  return {
+    dTag: manifest.dTag,
+    aggregateHash: manifest.aggregateHash,
+    files,
+    indexHtml,
+    manifest
+  };
+}
+
+export {
+  NAPPLET_ARTIFACT_CACHE_NAME,
+  coordinateKey,
+  isCoordinateFresh,
+  CacheStorageNappletArtifactCache,
+  openNappletArtifactCache,
+  NAPPLET_KIND_SNAPSHOT,
+  NAPPLET_KIND_ROOT,
+  NAPPLET_KIND_NAMED,
+  NAPPLET_KINDS,
+  isNappletManifestKind,
+  NappletResolutionError,
+  parseNappletManifest,
+  verifyManifestSignature,
+  verifyBlobHash,
+  fetchBlob,
+  resolveNapplet
+};
+//# sourceMappingURL=chunk-CDBUCFLP.js.map