@kehto/paja 0.8.0 → 0.9.0

package/dist/{chunk-NFJCS5PG.js → chunk-OWVINAW7.js}

@@ -697,12 +697,12 @@ async function resolvePajaPointer(value, options = {}) {
   const pointer = decodePajaPointer(value);
   const relays = uniqueRelayUrls([...pointer.relays, ...options.relays ?? []]);
   if (relays.length === 0) {
-    throw new Error("Pointer does not include relay hints; add a relay-bearing naddr or nevent.");
+    throw new Error("Pointer has no relay hints or enabled configured live relays.");
   }
   const pool = options.pool ?? new SimplePool();
   const ownsPool = options.pool === void 0;
   try {
-    const event = await resolvePointerEvent(pointer, pool, relays, options.maxWaitMs ?? 5e3);
+    const event = await resolvePointerEvent(pointer, pool, relays, normalizeMaxWaitMs(options.maxWaitMs));
     const blossomServers = [...options.blossomServers ?? []];
     const resolved = await resolveNapplet({
       event,
@@ -731,7 +731,26 @@ async function resolvePajaPointer(value, options = {}) {
   }
 }
 function injectPajaRuntimeCsp(html, origins) {
-  const value = origins.length > 0 ? `connect-src ${[...new Set(origins)].sort().join(" ")}` : "connect-src 'none'";
+  const grantedOrigins = [...new Set(origins)].sort();
+  const connectSrc = grantedOrigins.length > 0 ? `connect-src ${grantedOrigins.join(" ")}` : "connect-src 'none'";
+  const value = [
+    "default-src 'none'",
+    "script-src 'unsafe-inline'",
+    "style-src 'unsafe-inline'",
+    "img-src data: blob:",
+    "font-src data:",
+    connectSrc,
+    "worker-src 'none'",
+    "child-src 'none'",
+    "frame-src 'none'",
+    "media-src 'none'",
+    "object-src 'none'",
+    "manifest-src 'none'",
+    "prefetch-src 'none'",
+    "base-uri 'none'",
+    "form-action 'none'",
+    "frame-ancestors 'self'"
+  ].join("; ");
   const meta = `<meta http-equiv="Content-Security-Policy" content="${escapeAttribute2(value)}">`;
   if (/<head[^>]*>/i.test(html)) {
     return html.replace(/<head[^>]*>/i, (open) => `${open}${meta}`);
@@ -743,19 +762,96 @@ function injectPajaRuntimeCsp(html, origins) {
 }
 async function resolvePointerEvent(pointer, pool, relays, maxWaitMs) {
   const filter = pointer.type === "naddr" ? addressableFilter(pointer) : eventFilter(pointer);
-  const events = await pool.querySync([...relays], filter, {
-    maxWait: maxWaitMs,
-    label: "kehto-paja-runtime"
-  });
-  const event = events.filter((candidate) => matchesPointer(pointer, candidate)).sort((a, b) => b.created_at - a.created_at)[0];
+  const result = await queryPointerRelays(pool, relays, filter, maxWaitMs);
+  const event = result.events.filter((candidate) => matchesPointer(pointer, candidate)).sort((a, b) => b.created_at - a.created_at)[0];
   if (!event) {
-    throw new Error(`No napplet manifest event found for ${pointer.type} pointer.`);
+    if (result.timedOut) {
+      throw new Error(
+        `Relay resolution timed out after ${maxWaitMs}ms for ${pointer.type} pointer across ${relays.length} relays before complete EOSE.`
+      );
+    }
+    const failures = relayFailureReasons(result.reasons);
+    if (result.error || failures.length > 0) {
+      const detail = result.error instanceof Error ? result.error.message : result.error === void 0 ? failures.join("; ") : String(result.error);
+      throw new Error(`Relay query failed for ${pointer.type} pointer before complete EOSE: ${detail}`);
+    }
+    throw new Error(
+      `All ${relays.length} relays reached EOSE without a matching ${pointer.type} napplet manifest event.`
+    );
   }
   if (!isNappletManifestKind(event.kind)) {
     throw new Error(`Pointer resolved kind ${event.kind}; expected ${formatNappletManifestKinds()}.`);
   }
   return event;
 }
+function queryPointerRelays(pool, relays, filter, maxWaitMs) {
+  if (pool.subscribeManyEose) {
+    return queryPointerRelaySubscription(pool, relays, filter, maxWaitMs);
+  }
+  return queryPointerRelaySync(pool, relays, filter, maxWaitMs);
+}
+function queryPointerRelaySubscription(pool, relays, filter, maxWaitMs) {
+  return new Promise((resolve2) => {
+    const events = [];
+    let settled = false;
+    let subscription;
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(deadline);
+      resolve2({ events, ...result });
+    };
+    const deadline = setTimeout(() => {
+      finish({ reasons: [], timedOut: true });
+      void subscription?.close("Paja pointer relay deadline exceeded");
+    }, maxWaitMs);
+    try {
+      subscription = pool.subscribeManyEose([...relays], filter, {
+        maxWait: maxWaitMs,
+        label: "kehto-paja-runtime",
+        onevent(event) {
+          events.push(event);
+        },
+        onclose(reasons) {
+          finish({ reasons, timedOut: false });
+        }
+      });
+    } catch (error) {
+      finish({ reasons: [], timedOut: false, error });
+    }
+  });
+}
+function queryPointerRelaySync(pool, relays, filter, maxWaitMs) {
+  return new Promise((resolve2) => {
+    let settled = false;
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(deadline);
+      resolve2(result);
+    };
+    const deadline = setTimeout(() => {
+      finish({ events: [], reasons: [], timedOut: true });
+    }, maxWaitMs);
+    void pool.querySync([...relays], filter, {
+      maxWait: maxWaitMs,
+      label: "kehto-paja-runtime"
+    }).then(
+      (events) => finish({ events, reasons: [], timedOut: false }),
+      (error) => finish({ events: [], reasons: [], timedOut: false, error })
+    );
+  });
+}
+function relayFailureReasons(reasons) {
+  return [...new Set(reasons.map((reason) => reason.trim()).filter((reason) => reason.length > 0 && reason !== "closed automatically on eose").map((reason) => reason.slice(0, 160)))].slice(0, 3);
+}
+function normalizeMaxWaitMs(value) {
+  if (value === void 0) return 5e3;
+  if (!Number.isFinite(value) || value <= 0) {
+    throw new Error("Pointer relay deadline must be a positive number of milliseconds.");
+  }
+  return Math.floor(value);
+}
 function addressableFilter(pointer) {
   if (pointer.kind !== NAPPLET_KIND_NAMED) {
     throw new Error(`naddr kind ${pointer.kind} is not a named NIP-5D napplet manifest kind.`);
@@ -937,9 +1033,258 @@ function defaultSleep(ms) {
   });
 }
 
+// src/installed-napplet-catalog.ts
+import { manifestToIntentCatalogEntry } from "@kehto/services";
+function matchesInstalledNappletRecord(record, target) {
+  return target.dTag === record.dTag && target.aggregateHash === record.aggregateHash;
+}
+var InstalledNappletCatalog = class {
+  records = /* @__PURE__ */ new Map();
+  listeners = /* @__PURE__ */ new Set();
+  /** Insert or replace a record from an already resolver-verified pointer. */
+  install(resolved) {
+    const record = freezeRecord({
+      dTag: resolved.dTag,
+      aggregateHash: resolved.aggregateHash,
+      pointer: copyPointer(resolved.pointer),
+      ...resolved.manifest.title === void 0 ? {} : { title: resolved.manifest.title },
+      archetypes: resolved.manifest.archetypes.map((archetype) => ({
+        slug: archetype.slug,
+        convention: archetype.convention,
+        ...archetype.eventKinds === void 0 ? {} : { eventKinds: [...archetype.eventKinds] }
+      }))
+    });
+    this.records.set(record.dTag, record);
+    this.notify(record.dTag);
+    return record;
+  }
+  /** Remove an artifact explicitly; frame teardown never calls this method. */
+  remove(dTag) {
+    const removed = this.records.delete(dTag);
+    if (removed) this.notify(dTag);
+    return removed;
+  }
+  /** Return whether a verified installation exists for a d-tag. */
+  has(dTag) {
+    return this.records.has(dTag);
+  }
+  /** Return immutable serializable installed-artifact facts. */
+  installed() {
+    return [...this.records.values()];
+  }
+  /** Return a verified record by d-tag. */
+  get(dTag) {
+    return this.records.get(dTag);
+  }
+  /**
+   * Atomically confirm that a resolved target still belongs to the exact record
+   * selected before an async operation. The record object is the catalog version
+   * token, so even a same-identity replacement cannot pass this check.
+   */
+  validateCurrent(selected, target) {
+    if (this.records.get(selected.dTag) !== selected) return null;
+    return matchesInstalledNappletRecord(selected, target) ? selected : null;
+  }
+  /** Return exact handler candidates derived only from installed manifests. */
+  intentCatalog() {
+    return this.installed().map((record) => manifestToIntentCatalogEntry({
+      dTag: record.dTag,
+      ...record.title === void 0 ? {} : { title: record.title },
+      archetypes: record.archetypes.map((archetype) => ({
+        slug: archetype.slug,
+        convention: archetype.convention,
+        ...archetype.eventKinds === void 0 ? {} : { eventKinds: [...archetype.eventKinds] }
+      }))
+    }));
+  }
+  /** Subscribe to explicit install and artifact-removal changes. */
+  onChanged(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  notify(dTag) {
+    for (const listener of this.listeners) listener(dTag);
+  }
+};
+function copyPointer(pointer) {
+  if (pointer.type === "naddr") {
+    return Object.freeze({
+      type: "naddr",
+      value: pointer.value,
+      identifier: pointer.identifier,
+      pubkey: pointer.pubkey,
+      kind: pointer.kind,
+      relays: Object.freeze([...pointer.relays])
+    });
+  }
+  return Object.freeze({
+    type: "nevent",
+    value: pointer.value,
+    id: pointer.id,
+    ...pointer.author === void 0 ? {} : { author: pointer.author },
+    ...pointer.kind === void 0 ? {} : { kind: pointer.kind },
+    relays: Object.freeze([...pointer.relays])
+  });
+}
+function freezeRecord(record) {
+  return Object.freeze({
+    ...record,
+    archetypes: Object.freeze(record.archetypes.map((archetype) => Object.freeze({
+      ...archetype,
+      ...archetype.eventKinds === void 0 ? {} : { eventKinds: Object.freeze([...archetype.eventKinds]) }
+    })))
+  });
+}
+
+// src/browser-intent-controller.ts
+var MAX_INTENT_DELIVERY_ATTEMPTS = 10;
+var BrowserIntentController = class {
+  constructor(options) {
+    this.options = options;
+    this.maxAttempts = normalizeAttempts(options.maxAttempts);
+  }
+  options;
+  maxAttempts;
+  retain(params) {
+    const retained = freezeRetention(params);
+    let started;
+    let delivered = false;
+    return {
+      start: () => {
+        started ??= this.start(retained, () => delivered, () => {
+          delivered = true;
+        });
+        return started;
+      }
+    };
+  }
+  async start(params, isDelivered, markDelivered) {
+    let reason = "no-current-target";
+    for (let attempt = 1; attempt <= this.maxAttempts; attempt += 1) {
+      let generation;
+      try {
+        generation = await this.options.openOrReuse(params, attempt);
+      } catch {
+        reason = "open-failed";
+        continue;
+      }
+      if (!generation) {
+        reason = "open-failed";
+        continue;
+      }
+      try {
+        await this.options.waitForReady(generation);
+      } catch {
+        reason = "ready-failed";
+        continue;
+      }
+      if (!await this.options.isCurrent(generation)) {
+        reason = "no-current-target";
+        continue;
+      }
+      if (isDelivered()) return;
+      markDelivered();
+      try {
+        await this.options.send(generation, params.delivery);
+        return;
+      } catch {
+        this.options.onTerminal?.(params, "send-failed");
+        return;
+      }
+    }
+    this.options.onTerminal?.(params, reason);
+  }
+};
+function normalizeAttempts(value) {
+  if (value === void 0) return 2;
+  if (!Number.isFinite(value)) throw new TypeError("maxAttempts must be finite");
+  return Math.min(MAX_INTENT_DELIVERY_ATTEMPTS, Math.max(1, Math.floor(value)));
+}
+function freezeRetention(params) {
+  if (!params || typeof params.handler !== "string" || params.handler.length === 0) {
+    throw new TypeError("Intent retention requires a handler");
+  }
+  const delivery = freezeValue({ ...params.delivery });
+  const behavior = params.behavior === void 0 ? void 0 : freezeValue({ ...params.behavior });
+  return Object.freeze({
+    handler: params.handler,
+    delivery,
+    ...behavior === void 0 ? {} : { behavior }
+  });
+}
+function freezeValue(value, seen = /* @__PURE__ */ new WeakMap()) {
+  if (typeof value !== "object" || value === null) return value;
+  const existing = seen.get(value);
+  if (existing !== void 0) return existing;
+  if (Array.isArray(value)) {
+    const copy2 = [];
+    seen.set(value, copy2);
+    for (const item of value) copy2.push(freezeValue(item, seen));
+    return Object.freeze(copy2);
+  }
+  const copy = {};
+  seen.set(value, copy);
+  for (const [key, item] of Object.entries(value)) copy[key] = freezeValue(item, seen);
+  return Object.freeze(copy);
+}
+
 // src/server.ts
 import { createServer } from "http";
 import { readFileSync as readFileSync2 } from "fs";
+
+// src/target-cors.ts
+var PAJA_TARGET_CORS_HINT = "Paja sandboxes the napplet frame without allow-same-origin, so its assets are requested with `Origin: null`. Allow that origin in the napplet dev server, e.g. Vite `server: { cors: { origin: '*' } }`.";
+function classifyTargetCors(targetUrl, allowOrigin) {
+  const value = allowOrigin?.trim() ?? null;
+  if (value === "*" || value === "null") {
+    return {
+      status: "allowed",
+      targetUrl,
+      allowOrigin: value,
+      detail: `Target allows the sandboxed frame's null origin (access-control-allow-origin: ${value}).`,
+      hint: null
+    };
+  }
+  if (value === null || value === "") {
+    return {
+      status: "blocked",
+      targetUrl,
+      allowOrigin: null,
+      detail: "Target sent no access-control-allow-origin for an Origin: null request.",
+      hint: PAJA_TARGET_CORS_HINT
+    };
+  }
+  return {
+    status: "blocked",
+    targetUrl,
+    allowOrigin: value,
+    detail: `Target only allows origin "${value}", not the sandboxed frame's null origin.`,
+    hint: PAJA_TARGET_CORS_HINT
+  };
+}
+var defaultTargetCorsFetch = (input, init) => fetch(input, init);
+async function probeTargetCors(targetUrl, fetchImpl = defaultTargetCorsFetch) {
+  try {
+    const response = await fetchImpl(targetUrl, {
+      method: "GET",
+      headers: {
+        origin: "null",
+        accept: "text/html, application/xhtml+xml;q=0.9, */*;q=0.8"
+      }
+    });
+    return classifyTargetCors(targetUrl, response.headers.get("access-control-allow-origin"));
+  } catch (error) {
+    return {
+      status: "unreachable",
+      targetUrl,
+      allowOrigin: null,
+      detail: `Target CORS probe failed: ${error instanceof Error ? error.message : String(error)}`,
+      hint: "Confirm the napplet dev server is running and --target-url points at it."
+    };
+  }
+}
+
+// src/server.ts
 async function startPajaServer(input) {
   const rawOptions = resolvePajaRawOptions(input.options);
   const options = normalizePajaOptions(rawOptions);
@@ -975,6 +1320,15 @@ async function startPajaServer(input) {
       response.end(targetHtml);
       return;
     }
+    if (requestUrl === "/__kehto/target-cors.json") {
+      const diagnostic = await probeTargetCors(hostConfig.target.url);
+      response.writeHead(200, {
+        "cache-control": "no-store",
+        "content-type": "application/json; charset=utf-8"
+      });
+      response.end(JSON.stringify(diagnostic));
+      return;
+    }
     if (requestUrl === "/__kehto/browser-host.js") {
       const browserScript = readBrowserHostScript();
       response.writeHead(200, { "content-type": "text/javascript; charset=utf-8" });
@@ -1104,6 +1458,11 @@ export {
   getMissingServices,
   ReadinessError,
   waitForTargetUrl,
+  InstalledNappletCatalog,
+  BrowserIntentController,
+  PAJA_TARGET_CORS_HINT,
+  classifyTargetCors,
+  probeTargetCors,
   startPajaServer
 };
-//# sourceMappingURL=chunk-NFJCS5PG.js.map
+//# sourceMappingURL=chunk-OWVINAW7.js.map