@kehto/paja 0.16.4 → 0.16.5

package/dist/browser-host.js

@@ -15255,15 +15255,35 @@ var KIND_GIFT_WRAP_EPHEMERAL = 21059;
 var KIND_GIFT_WRAP_REGULAR = 1059;
 var KIND_ANNOUNCE_SERVER = 11316;
 var KIND_ANNOUNCE_TOOLS = 11317;
+var SUPPORT_ENCRYPTION = "support_encryption";
+var SUPPORT_ENCRYPTION_EPHEMERAL = "support_encryption_ephemeral";
+var SUPPORT_OVERSIZED_TRANSFER = "support_oversized_transfer";
+var SUPPORT_OPEN_STREAM = "support_open_stream";
 var DEFAULT_TIMEOUT_MS = 3e4;
 var DEFAULT_DISCOVER_TIMEOUT_MS = 6e3;
 var MCP_PROTOCOL_VERSION = "2025-11-25";
 var SEEN_WRAP_LIMIT = 512;
+var DIGEST_PREFIX = "sha256:";
+var MAX_TRANSFER_CHUNKS = 1e4;
+var MAX_TRANSFER_BYTES = 100 * 1024 * 1024;
+var MAX_ACTIVE_TRANSFERS = 8;
+var MAX_TRANSFER_LIFETIME_MS = 12e4;
+var COMPLETION_MODE_RENDER = "render";
+var DEFAULT_STREAM_IDLE_TIMEOUT_MS = 3e4;
+var DEFAULT_STREAM_PROBE_TIMEOUT_MS = 1e4;
+var MAX_STREAM_BUFFERED_CHUNKS = 256;
+var MAX_STREAM_BUFFERED_CODE_UNITS = 8 * 1024 * 1024;
+var MAX_PING_NONCE_BYTES = 64;
 var correlationCounter = 0;
 function nextCorrelationId() {
   correlationCounter += 1;
   return `cvm-${correlationCounter}-${getPublicKey(generateSecretKey()).slice(0, 8)}`;
 }
+var streamNonceCounter = 0;
+function nextStreamNonce() {
+  streamNonceCounter += 1;
+  return `cvm-ping-${streamNonceCounter}-${getPublicKey(generateSecretKey()).slice(0, 8)}`;
+}
 function randomizedPastTimestamp() {
   const jitter = Math.floor(Math.random() * 172800);
   return Math.floor(Date.now() / 1e3) - jitter;
@@ -15271,6 +15291,19 @@ function randomizedPastTimestamp() {
 function tagValue(tags, name) {
   return tags.find((tag) => tag[0] === name)?.[1];
 }
+function progressTokenKey(token) {
+  if (typeof token === "string") return token.length > 0 ? `s:${token}` : null;
+  if (typeof token === "number" && Number.isFinite(token)) return `n:${token}`;
+  return null;
+}
+function isBoundedInteger(value, min, max) {
+  return typeof value === "number" && Number.isInteger(value) && value >= min && value <= max;
+}
+async function sha256Hex(text) {
+  const bytes = new TextEncoder().encode(text);
+  const buf = await crypto.subtle.digest("SHA-256", bytes);
+  return [...new Uint8Array(buf)].map((b) => b.toString(16).padStart(2, "0")).join("");
+}
 function simplePoolAdapter(sp) {
   return {
     subscribe(relays, filter, params) {
@@ -15295,11 +15328,14 @@ function createNostrCvmTransport(options = {}) {
   const clientSecretKey = options.clientSecretKey ?? generateSecretKey();
   const clientPubkey = getPublicKey(clientSecretKey);
   const clientInfo = options.clientInfo ?? { name: "kehto-cvm", version: "1.0.0" };
+  const streamIdleTimeoutMs = options.streamIdleTimeoutMs ?? DEFAULT_STREAM_IDLE_TIMEOUT_MS;
+  const streamProbeTimeoutMs = options.streamProbeTimeoutMs ?? DEFAULT_STREAM_PROBE_TIMEOUT_MS;
   const sessions = /* @__PURE__ */ new Map();
   const pending = /* @__PURE__ */ new Map();
   const eventHandlers = /* @__PURE__ */ new Set();
   const relayRefcount = /* @__PURE__ */ new Map();
   const seenWraps = /* @__PURE__ */ new Set();
+  const issuedTokens = /* @__PURE__ */ new Map();
   let inbound = null;
   let subscribedRelays = "";
   function resolveRelays(server) {
@@ -15361,23 +15397,379 @@ function createNostrCvmTransport(options = {}) {
     } catch {
       return;
     }
+    if (mcp.method === "notifications/progress") {
+      const params = mcp.params ?? {};
+      const cvm = params.cvm;
+      if (cvm && typeof cvm.type === "string") {
+        if (cvm.type === "oversized-transfer") {
+          void handleOversizedFrame(serverPubkey, params, cvm);
+          return;
+        }
+        if (cvm.type === "open-stream") {
+          const entry = admitFrame(serverPubkey, params.progressToken);
+          if (!entry) return;
+          handleOpenStreamFrame(serverPubkey, entry, params, cvm, mcp);
+          return;
+        }
+      }
+    }
+    routeMessage(serverPubkey, mcp);
+  }
+  async function publishStreamFrame(entry, stream, frame) {
+    const session = sessions.get(entry.serverPubkey);
+    if (!session) return;
+    stream.localProgress += 1;
+    await publishMcp(
+      { pubkey: entry.serverPubkey },
+      session.relays,
+      {
+        jsonrpc: "2.0",
+        method: "notifications/progress",
+        params: {
+          progressToken: stream.token,
+          progress: stream.localProgress,
+          cvm: { type: "open-stream", ...frame }
+        }
+      }
+    );
+  }
+  function admitFrame(serverPubkey, token) {
+    const tokenKey = progressTokenKey(token);
+    if (!tokenKey) return null;
+    const correlationId = issuedTokens.get(`${serverPubkey}:${tokenKey}`);
+    if (!correlationId) return null;
+    const entry = pending.get(correlationId);
+    if (!entry || entry.serverPubkey !== serverPubkey) return null;
+    return entry;
+  }
+  function releaseTransfer(entry) {
+    if (!entry.oversized) return;
+    clearTimeout(entry.oversized.expiryTimer);
+    entry.oversized = void 0;
+  }
+  function releaseStream(entry) {
+    if (!entry.stream) return;
+    clearTimeout(entry.stream.idleTimer);
+    if (entry.stream.probeTimer) clearTimeout(entry.stream.probeTimer);
+    entry.stream = void 0;
+  }
+  function endStream(entry) {
+    releaseStream(entry);
+    entry.streamEnded = true;
+  }
+  function failStream(entry, reason) {
+    const stream = entry.stream;
+    if (!stream || entry.streamEnded) return;
+    endStream(entry);
+    void publishStreamFrame(entry, stream, { frameType: "abort", reason }).catch(() => {
+    });
+  }
+  function resetStreamIdleTimer(entry, stream) {
+    clearTimeout(stream.idleTimer);
+    stream.idleTimer = setTimeout(() => onStreamIdle(entry), streamIdleTimeoutMs);
+  }
+  function onStreamIdle(entry) {
+    const stream = entry.stream;
+    if (!stream || entry.streamEnded) return;
+    if (stream.pendingNonce !== null) return;
+    const session = sessions.get(entry.serverPubkey);
+    if (!session) {
+      failStream(entry, "session closed");
+      return;
+    }
+    stream.pendingNonce = nextStreamNonce();
+    stream.probeTimer = setTimeout(() => failStream(entry, "probe timeout"), streamProbeTimeoutMs);
+    void publishStreamFrame(entry, stream, { frameType: "ping", nonce: stream.pendingNonce }).catch(() => failStream(entry, "ping publication failed"));
+  }
+  function releaseFrameState(entry) {
+    releaseTransfer(entry);
+    releaseStream(entry);
+    if (entry.tokenKey && issuedTokens.get(entry.tokenKey) === entry.correlationId) {
+      issuedTokens.delete(entry.tokenKey);
+    }
+    entry.tokenKey = void 0;
+  }
+  function settlePending(correlationId) {
+    const entry = pending.get(correlationId);
+    if (!entry) return null;
+    clearTimeout(entry.timer);
+    pending.delete(correlationId);
+    releaseFrameState(entry);
+    return entry;
+  }
+  function countActiveTransfers() {
+    let active = 0;
+    for (const entry of pending.values()) {
+      if (entry.oversized) active += 1;
+    }
+    return active;
+  }
+  async function handleOversizedFrame(serverPubkey, params, cvm) {
+    const entry = admitFrame(serverPubkey, params.progressToken);
+    if (!entry) return;
+    const progress = Number(params.progress ?? NaN);
+    if (!Number.isSafeInteger(progress) || progress < 0) return;
+    if (cvm.frameType === "start") {
+      const digest = typeof cvm.digest === "string" ? cvm.digest : "";
+      const { totalBytes, totalChunks } = cvm;
+      if (cvm.completionMode !== COMPLETION_MODE_RENDER) return;
+      if (digest === "") return;
+      if (!isBoundedInteger(totalChunks, 1, MAX_TRANSFER_CHUNKS)) return;
+      if (!isBoundedInteger(totalBytes, 1, MAX_TRANSFER_BYTES)) return;
+      if (progress > Number.MAX_SAFE_INTEGER - totalChunks - 1) return;
+      if (!entry.oversized && countActiveTransfers() >= MAX_ACTIVE_TRANSFERS) return;
+      releaseTransfer(entry);
+      entry.oversized = {
+        digest,
+        totalBytes,
+        totalChunks,
+        startProgress: progress,
+        acceptProgress: null,
+        chunks: /* @__PURE__ */ new Map(),
+        codeUnitsReceived: 0,
+        // Hard expiry: progress frames extend the request deadline but never
+        // how long buffers may be held.
+        expiryTimer: setTimeout(() => releaseTransfer(entry), MAX_TRANSFER_LIFETIME_MS)
+      };
+      refreshPendingTimeout(entry);
+      return;
+    }
+    const transfer = entry.oversized;
+    if (!transfer) return;
+    if (cvm.frameType === "accept") {
+      if (progress !== transfer.startProgress + 1) {
+        releaseTransfer(entry);
+        return;
+      }
+      transfer.acceptProgress = progress;
+      refreshPendingTimeout(entry);
+      return;
+    }
+    if (cvm.frameType === "chunk") {
+      if (typeof cvm.data !== "string" || progress <= transfer.startProgress) return;
+      if (transfer.chunks.has(progress)) return;
+      if (transfer.chunks.size >= transfer.totalChunks) {
+        releaseTransfer(entry);
+        return;
+      }
+      transfer.codeUnitsReceived += cvm.data.length;
+      if (transfer.codeUnitsReceived > MAX_TRANSFER_BYTES) {
+        releaseTransfer(entry);
+        return;
+      }
+      transfer.chunks.set(progress, cvm.data);
+      refreshPendingTimeout(entry);
+      return;
+    }
+    if (cvm.frameType === "abort") {
+      releaseTransfer(entry);
+      return;
+    }
+    if (cvm.frameType === "end") {
+      const message = await assembleTransfer(transfer, progress);
+      releaseTransfer(entry);
+      if (message) routeMessage(serverPubkey, message);
+      return;
+    }
+  }
+  async function assembleTransfer(transfer, endProgress) {
+    const { startProgress, acceptProgress, totalChunks } = transfer;
+    const hasCompleteRange = (first) => {
+      for (let i4 = 0; i4 < totalChunks; i4++) {
+        if (!transfer.chunks.has(first + i4)) return false;
+      }
+      return true;
+    };
+    const directStart = startProgress + 1;
+    const acceptGatedStart = startProgress + 2;
+    const firstProgress = hasCompleteRange(directStart) && endProgress === directStart + totalChunks ? directStart : acceptProgress === startProgress + 1 && hasCompleteRange(acceptGatedStart) && endProgress === acceptGatedStart + totalChunks ? acceptGatedStart : null;
+    if (firstProgress === null) return null;
+    let payload = "";
+    for (let i4 = 0; i4 < totalChunks; i4++) {
+      payload += transfer.chunks.get(firstProgress + i4);
+    }
+    if (new TextEncoder().encode(payload).byteLength !== transfer.totalBytes) return null;
+    const expected = transfer.digest.startsWith(DIGEST_PREFIX) ? transfer.digest.slice(DIGEST_PREFIX.length) : transfer.digest;
+    if (await sha256Hex(payload) !== expected) return null;
+    try {
+      return JSON.parse(payload);
+    } catch {
+      return null;
+    }
+  }
+  function handleOpenStreamFrame(serverPubkey, entry, params, cvm, mcp) {
+    const progress = Number(params.progress ?? NaN);
+    if (!Number.isSafeInteger(progress) || progress < 0) return;
+    if (entry.streamEnded) return;
+    const stream = entry.stream;
+    if (!stream) {
+      if (cvm.frameType !== "start") return;
+      entry.stream = {
+        token: params.progressToken,
+        lastProgress: progress,
+        localProgress: 0,
+        nextChunkIndex: 0,
+        outOfOrder: /* @__PURE__ */ new Map(),
+        outOfOrderCodeUnits: 0,
+        pendingNonce: null,
+        idleTimer: setTimeout(() => onStreamIdle(entry), streamIdleTimeoutMs),
+        probeTimer: null
+      };
+      refreshPendingTimeout(entry);
+      routeEvent(serverPubkey, mcp);
+      return;
+    }
+    const admitOrderedActivity = () => {
+      if (progress <= stream.lastProgress) {
+        failStream(entry, "non-monotonic progress");
+        return false;
+      }
+      stream.lastProgress = progress;
+      resetStreamIdleTimer(entry, stream);
+      refreshPendingTimeout(entry);
+      return true;
+    };
+    switch (cvm.frameType) {
+      case "start":
+        failStream(entry, "duplicate start");
+        return;
+      case "accept":
+        if (!admitOrderedActivity()) return;
+        routeEvent(serverPubkey, mcp);
+        return;
+      case "chunk": {
+        if (typeof cvm.data !== "string" || !isBoundedInteger(cvm.chunkIndex, 0, Number.MAX_SAFE_INTEGER)) {
+          failStream(entry, "malformed chunk");
+          return;
+        }
+        const index = cvm.chunkIndex;
+        if (index < stream.nextChunkIndex) return;
+        if (index > stream.nextChunkIndex) {
+          const existing = stream.outOfOrder.get(index);
+          if (existing) {
+            if (existing.progress !== progress || JSON.stringify(existing.message) !== JSON.stringify(mcp)) {
+              failStream(entry, "conflicting duplicate chunk");
+            }
+            return;
+          }
+          if (progress <= stream.lastProgress || stream.outOfOrder.size >= MAX_STREAM_BUFFERED_CHUNKS || stream.outOfOrderCodeUnits + cvm.data.length > MAX_STREAM_BUFFERED_CODE_UNITS) {
+            failStream(entry, progress <= stream.lastProgress ? "non-monotonic progress" : "gap buffer exhausted");
+            return;
+          }
+          stream.outOfOrder.set(index, { message: mcp, progress, codeUnits: cvm.data.length });
+          stream.outOfOrderCodeUnits += cvm.data.length;
+          resetStreamIdleTimer(entry, stream);
+          refreshPendingTimeout(entry);
+          return;
+        }
+        const ready = [
+          { message: mcp, progress, codeUnits: 0 }
+        ];
+        let nextIndex = index + 1;
+        while (stream.outOfOrder.has(nextIndex)) {
+          ready.push(stream.outOfOrder.get(nextIndex));
+          nextIndex += 1;
+        }
+        let previousProgress = stream.lastProgress;
+        for (const item of ready) {
+          if (item.progress <= previousProgress) {
+            failStream(entry, "non-monotonic chunk order");
+            return;
+          }
+          previousProgress = item.progress;
+        }
+        for (let bufferedIndex = index + 1; bufferedIndex < nextIndex; bufferedIndex++) {
+          const buffered = stream.outOfOrder.get(bufferedIndex);
+          stream.outOfOrder.delete(bufferedIndex);
+          stream.outOfOrderCodeUnits -= buffered.codeUnits;
+        }
+        for (const item of ready) {
+          routeEvent(serverPubkey, item.message);
+          stream.nextChunkIndex += 1;
+        }
+        stream.lastProgress = previousProgress;
+        resetStreamIdleTimer(entry, stream);
+        refreshPendingTimeout(entry);
+        return;
+      }
+      case "ping": {
+        if (typeof cvm.nonce !== "string") return;
+        if (new TextEncoder().encode(cvm.nonce).byteLength > MAX_PING_NONCE_BYTES) return;
+        if (!admitOrderedActivity()) return;
+        void publishStreamFrame(entry, stream, { frameType: "pong", nonce: cvm.nonce }).catch(() => {
+          failStream(entry, "pong publication failed");
+        });
+        return;
+      }
+      case "pong": {
+        if (stream.pendingNonce === null || cvm.nonce !== stream.pendingNonce) return;
+        if (!admitOrderedActivity()) return;
+        stream.pendingNonce = null;
+        if (stream.probeTimer) clearTimeout(stream.probeTimer);
+        stream.probeTimer = null;
+        return;
+      }
+      case "close": {
+        if (cvm.lastChunkIndex !== void 0) {
+          const bound = cvm.lastChunkIndex;
+          const complete = isBoundedInteger(bound, 0, Number.MAX_SAFE_INTEGER) && stream.nextChunkIndex === bound + 1 && stream.outOfOrder.size === 0;
+          if (!complete) {
+            failStream(entry, "close with unresolved chunk gaps");
+            return;
+          }
+        }
+        if (!admitOrderedActivity()) return;
+        routeEvent(serverPubkey, mcp);
+        endStream(entry);
+        return;
+      }
+      case "abort":
+        if (!admitOrderedActivity()) return;
+        routeEvent(serverPubkey, mcp);
+        endStream(entry);
+        return;
+      default:
+        return;
+    }
+  }
+  function refreshPendingTimeout(entry) {
+    clearTimeout(entry.timer);
+    entry.timer = setTimeout(() => {
+      const settled = settlePending(entry.correlationId);
+      settled?.reject(new Error("relay timeout"));
+    }, entry.timeoutMs);
+  }
+  function routeMessage(serverPubkey, mcp) {
     const id = mcp.id;
     if (id != null && pending.has(String(id))) {
       const entry = pending.get(String(id));
       if (entry.serverPubkey !== serverPubkey) return;
-      pending.delete(String(id));
-      clearTimeout(entry.timer);
-      entry.resolve({ ...mcp, id: entry.originalId });
+      const settled = settlePending(String(id));
+      settled?.resolve({ ...mcp, id: entry.originalId });
       return;
     }
+    routeEvent(serverPubkey, mcp);
+  }
+  function routeEvent(serverPubkey, mcp) {
     if (mcp.method !== void 0 && sessions.has(serverPubkey)) {
       const server = { pubkey: serverPubkey };
       for (const handler of eventHandlers) handler(server, mcp);
     }
   }
   async function publishMcp(server, relays, message) {
+    const capabilityTags = [
+      ...encrypt22 ? [[SUPPORT_ENCRYPTION]] : [],
+      ...encrypt22 && wrapKind === KIND_GIFT_WRAP_EPHEMERAL ? [[SUPPORT_ENCRYPTION_EPHEMERAL]] : [],
+      [SUPPORT_OVERSIZED_TRANSFER],
+      [SUPPORT_OPEN_STREAM]
+    ];
     const inner = finalizeEvent(
-      { kind: KIND_CVM, created_at: Math.floor(Date.now() / 1e3), tags: [["p", server.pubkey]], content: JSON.stringify(message) },
+      {
+        kind: KIND_CVM,
+        created_at: Math.floor(Date.now() / 1e3),
+        tags: [["p", server.pubkey], ...capabilityTags],
+        content: JSON.stringify(message)
+      },
       clientSecretKey
     );
     if (!encrypt22) {
@@ -15401,17 +15793,52 @@ function createNostrCvmTransport(options = {}) {
   function sendCorrelated(server, relays, message, timeout) {
     const correlationId = nextCorrelationId();
     const originalId = message.id;
-    const outgoing = { ...message, id: correlationId };
+    let outgoing = { ...message, id: correlationId };
+    let issuedToken;
+    const params = message.params && typeof message.params === "object" ? message.params : void 0;
+    const meta = params?._meta && typeof params._meta === "object" ? params._meta : void 0;
+    const explicit = meta?.progressToken;
+    if (message.method === "tools/call") {
+      issuedToken = typeof explicit === "string" || typeof explicit === "number" ? explicit : correlationId;
+      outgoing = {
+        ...outgoing,
+        params: {
+          ...params,
+          _meta: {
+            ...meta,
+            progressToken: issuedToken
+          }
+        }
+      };
+    } else if (typeof explicit === "string" || typeof explicit === "number") {
+      issuedToken = explicit;
+    }
+    const tokenKey = progressTokenKey(issuedToken);
+    const issuedKey = tokenKey ? `${server.pubkey}:${tokenKey}` : null;
+    if (issuedKey && issuedTokens.has(issuedKey)) {
+      return Promise.reject(new Error("duplicate progress token"));
+    }
     return new Promise((resolve, reject2) => {
-      const timer = setTimeout(() => {
-        pending.delete(correlationId);
-        reject2(new Error("relay timeout"));
-      }, timeout);
-      pending.set(correlationId, { resolve, reject: reject2, timer, originalId, serverPubkey: server.pubkey });
+      const entry = {
+        resolve,
+        reject: reject2,
+        timer: setTimeout(() => {
+          const settled = settlePending(correlationId);
+          settled?.reject(new Error("relay timeout"));
+        }, timeout),
+        timeoutMs: timeout,
+        originalId,
+        serverPubkey: server.pubkey,
+        correlationId
+      };
+      if (issuedKey) {
+        entry.tokenKey = issuedKey;
+        issuedTokens.set(issuedKey, correlationId);
+      }
+      pending.set(correlationId, entry);
       void publishMcp(server, relays, outgoing).catch((err2) => {
-        pending.delete(correlationId);
-        clearTimeout(timer);
-        reject2(err2 instanceof Error ? err2 : new Error("publish failed"));
+        const settled = settlePending(correlationId);
+        settled?.reject(err2 instanceof Error ? err2 : new Error("publish failed"));
       });
     });
   }
@@ -15509,6 +15936,10 @@ function createNostrCvmTransport(options = {}) {
       if (!session) return;
       sessions.delete(server.pubkey);
       releaseRelays(session.relays);
+      for (const [correlationId, entry] of pending) {
+        if (entry.serverPubkey !== server.pubkey) continue;
+        settlePending(correlationId)?.reject(new Error("server closed"));
+      }
     },
     onEvent(handler) {
       eventHandlers.add(handler);
@@ -15523,9 +15954,12 @@ function createNostrCvmTransport(options = {}) {
       inbound = null;
       for (const entry of pending.values()) {
         clearTimeout(entry.timer);
+        releaseTransfer(entry);
+        releaseStream(entry);
         entry.reject(new Error("transport disposed"));
       }
       pending.clear();
+      issuedTokens.clear();
       sessions.clear();
       relayRefcount.clear();
       eventHandlers.clear();
@@ -16430,14 +16864,14 @@ var CacheStorageNappletArtifactCache = class {
     this.softCeilingBytes = options.softCeilingBytes ?? DEFAULT_SOFT_CEILING_BYTES;
     this.hardCeilingBytes = options.hardCeilingBytes ?? DEFAULT_HARD_CEILING_BYTES;
   }
-  async readBlob(sha256Hex) {
+  async readBlob(sha256Hex2) {
     try {
       const cache2 = await this.open();
-      const response = await cache2.match(this.blobUrl(sha256Hex));
+      const response = await cache2.match(this.blobUrl(sha256Hex2));
       if (!response) return void 0;
       const bytes = await responseBytes(response);
       const index = await this.readIndex(cache2);
-      const entry = index.blobs[sha256Hex];
+      const entry = index.blobs[sha256Hex2];
       if (entry) {
         entry.lastAccessed = this.now();
         index.updatedAt = entry.lastAccessed;
@@ -16445,20 +16879,20 @@ var CacheStorageNappletArtifactCache = class {
       }
       return bytes;
     } catch (cause) {
-      this.diagnostic({ type: "cache-read-failed", message: `failed to read blob ${sha256Hex}`, cause });
+      this.diagnostic({ type: "cache-read-failed", message: `failed to read blob ${sha256Hex2}`, cause });
       return void 0;
     }
   }
-  async deleteBlob(sha256Hex) {
+  async deleteBlob(sha256Hex2) {
     try {
       const cache2 = await this.open();
-      await cache2.delete(this.blobUrl(sha256Hex));
+      await cache2.delete(this.blobUrl(sha256Hex2));
       const index = await this.readIndex(cache2);
-      delete index.blobs[sha256Hex];
+      delete index.blobs[sha256Hex2];
       index.updatedAt = this.now();
       await this.writeIndex(cache2, index);
     } catch (cause) {
-      this.diagnostic({ type: "cache-delete-failed", message: `failed to delete blob ${sha256Hex}`, cause });
+      this.diagnostic({ type: "cache-delete-failed", message: `failed to delete blob ${sha256Hex2}`, cause });
     }
   }
   async writeVerifiedResolution(input) {
@@ -16839,22 +17273,22 @@ function verifyManifestSignature(event) {
     return false;
   }
 }
-function verifyBlobHash(bytes, sha256Hex) {
-  return bytesToHex2(sha256(bytes)) === sha256Hex;
+function verifyBlobHash(bytes, sha256Hex2) {
+  return bytesToHex2(sha256(bytes)) === sha256Hex2;
 }
 function stripTrailingSlash(url) {
   return url.endsWith("/") ? url.slice(0, -1) : url;
 }
-async function fetchBlob(servers, sha256Hex, fetchBytes) {
+async function fetchBlob(servers, sha256Hex2, fetchBytes) {
   for (const server of servers) {
-    const url = `${stripTrailingSlash(server)}/${sha256Hex}`;
+    const url = `${stripTrailingSlash(server)}/${sha256Hex2}`;
     try {
       const bytes = await fetchBytes(url);
-      if (verifyBlobHash(bytes, sha256Hex)) return bytes;
+      if (verifyBlobHash(bytes, sha256Hex2)) return bytes;
     } catch {
     }
   }
-  throw new NappletResolutionError("blob-unavailable", `no server served blob ${sha256Hex}`);
+  throw new NappletResolutionError("blob-unavailable", `no server served blob ${sha256Hex2}`);
 }
 var INDEX_PATHS = ["/index.html", "index.html", "/"];
 function defaultDecode(bytes) {
@@ -20466,7 +20900,7 @@ async function resolvePajaPointer(value, options = {}) {
     const resolved = await resolveNapplet({
       event,
       cache: await openNappletArtifactCache({ requireStorageEstimate: false }),
-      fetchBlob: (sha256Hex, servers) => fetchBlob([...servers, ...blossomServers], sha256Hex, async (url) => {
+      fetchBlob: (sha256Hex2, servers) => fetchBlob([...servers, ...blossomServers], sha256Hex2, async (url) => {
         const response = await (options.fetcher ?? fetch)(url);
         if (!response.ok) throw new Error(`[paja-runtime] blob ${url}: ${response.status}`);
         return new Uint8Array(await response.arrayBuffer());