@kehto/services 0.12.3 → 0.13.2

package/dist/index.js

@@ -231,10 +231,10 @@ function createNotificationService(options) {
 
 // src/identity-service.ts
 var IDENTITY_SERVICE_VERSION = "1.0.0";
-function sendProviderError(send, result, fallback, err) {
+function sendProviderError(send, result, fallback, err2) {
   send({
     ...result,
-    error: err?.message ?? fallback
+    error: err2?.message ?? fallback
   });
 }
 async function getCurrentPubkey(options) {
@@ -251,13 +251,13 @@ function sendOptionalProviderResult(options, send, fallbackResult, errorFallback
     send(fallbackResult);
     return;
   }
-  Promise.resolve(getCurrentPubkey(options)).then((pubkey) => buildResult(pubkey)).then((result) => send(result)).catch((err) => sendProviderError(send, fallbackResult, errorFallback, err));
+  Promise.resolve(getCurrentPubkey(options)).then((pubkey) => buildResult(pubkey)).then((result) => send(result)).catch((err2) => sendProviderError(send, fallbackResult, errorFallback, err2));
 }
 function sendIdentityError(send, id, typeBase, error) {
   send({ type: `${typeBase}.error`, id, error });
 }
-function sendSignerError(send, id, typeBase, fallback, err) {
-  sendIdentityError(send, id, typeBase, err?.message ?? fallback);
+function sendSignerError(send, id, typeBase, fallback, err2) {
+  sendIdentityError(send, id, typeBase, err2?.message ?? fallback);
 }
 function handleGetPublicKey(options, id, send) {
   const signer = options.getSigner();
@@ -277,7 +277,7 @@ function handleGetPublicKey(options, id, send) {
       pubkey: pubkey ?? ""
     };
     send(result);
-  }).catch((err) => sendSignerError(send, id, "identity.getPublicKey", "getPublicKey failed", err));
+  }).catch((err2) => sendSignerError(send, id, "identity.getPublicKey", "getPublicKey failed", err2));
 }
 function handleGetRelays(options, id, send) {
   const signer = options.getSigner();
@@ -292,7 +292,7 @@ function handleGetRelays(options, id, send) {
       relays
     };
     send(result);
-  }).catch((err) => sendSignerError(send, id, "identity.getRelays", "getRelays failed", err));
+  }).catch((err2) => sendSignerError(send, id, "identity.getRelays", "getRelays failed", err2));
 }
 function handleReadProvider(options, id, message, send) {
   switch (message.type) {
@@ -453,7 +453,7 @@ function createRelayPoolService(options) {
           return;
         }
         const relayHint = typeof relayMessage.relay === "string" && relayMessage.relay.length > 0 ? relayMessage.relay : void 0;
-        const relayUrls = relayHint ? [relayHint] : options.selectRelayTier(filters);
+        const relayUrls2 = relayHint ? [relayHint] : options.selectRelayTier(filters);
         let eoseSent = false;
         const eoseTimer = setTimeout(() => {
           if (!eoseSent) {
@@ -471,7 +471,7 @@ function createRelayPoolService(options) {
             return;
           }
           send({ type: "relay.event", subId, event: item });
-        }, relayUrls);
+        }, relayUrls2);
         tracked.set(subKey, { handle, eoseTimer });
         return;
       }
@@ -634,7 +634,7 @@ function createCoordinatedRelay(options) {
             }
           }, timeoutMs);
           const relayHint = typeof relayMessage.relay === "string" && relayMessage.relay.length > 0 ? relayMessage.relay : void 0;
-          const relayUrls = relayHint ? [relayHint] : options.relayPool.selectRelayTier(filters);
+          const relayUrls2 = relayHint ? [relayHint] : options.relayPool.selectRelayTier(filters);
           tracked.relayHandle = options.relayPool.subscribe(filters, (item) => {
             if (item === "EOSE") {
               clearTimeout(tracked.eoseTimer);
@@ -649,7 +649,7 @@ function createCoordinatedRelay(options) {
               } catch {
               }
             }
-          }, relayUrls);
+          }, relayUrls2);
         }
         return;
       }
@@ -797,12 +797,12 @@ function createKeysService(options = {}) {
                 unsubscribeHandles.set(m.action.id, unsubscribe);
                 if (!bridgeWindowActions.has(windowId)) bridgeWindowActions.set(windowId, /* @__PURE__ */ new Set());
                 bridgeWindowActions.get(windowId).add(m.action.id);
-              } catch (err) {
+              } catch (err2) {
                 const id = m.id ?? "";
                 send({
                   type: "keys.registerAction.error",
                   id,
-                  error: `bridge subscribe failed: ${err.message}`
+                  error: `bridge subscribe failed: ${err2.message}`
                 });
                 return;
               }
@@ -944,12 +944,12 @@ function createKeysService(options = {}) {
               });
               if (!windowActions.has(windowId)) windowActions.set(windowId, /* @__PURE__ */ new Set());
               windowActions.get(windowId).add(m.action.id);
-            } catch (err) {
+            } catch (err2) {
               const id = m.id ?? "";
               send({
                 type: "keys.registerAction.error",
                 id,
-                error: `invalid chord: ${err.message}`
+                error: `invalid chord: ${err2.message}`
               });
               return;
             }
@@ -1629,6 +1629,9 @@ function arrayBufferToBase64(buf) {
   }
   return btoa(binary);
 }
+var DEFAULT_RESOURCE_INFO = {
+  schemes: [{ scheme: "https", enabled: true }]
+};
 function assertResourceOptions(options) {
   if (typeof options?.fetch !== "function" || typeof options?.isOriginGranted !== "function" || typeof options?.getConnectGrants !== "function" || typeof options?.resolveIdentity !== "function") {
     throw new Error(
@@ -1700,6 +1703,35 @@ function requestIdFromMessage(message) {
   if (typeof message.requestId === "string" && message.requestId.length > 0) return message.requestId;
   return null;
 }
+function normalizeResourceInfo(info) {
+  return {
+    schemes: Array.isArray(info.schemes) ? info.schemes.filter((scheme) => typeof scheme?.scheme === "string").map((scheme) => ({ scheme: scheme.scheme, enabled: scheme.enabled !== false })) : [],
+    ...typeof info.maxBytes === "number" ? { maxBytes: info.maxBytes } : {},
+    ...typeof info.maxUrls === "number" ? { maxUrls: info.maxUrls } : {}
+  };
+}
+async function resolveResourceInfo(options, windowId) {
+  const configured = options.resourceInfo ?? DEFAULT_RESOURCE_INFO;
+  const info = typeof configured === "function" ? await configured({ windowId, identity: options.resolveIdentity(windowId) }) : configured;
+  return normalizeResourceInfo(info);
+}
+async function handleInfo(options, windowId, requestId, send) {
+  try {
+    const info = await resolveResourceInfo(options, windowId);
+    send({
+      type: "resource.info.result",
+      id: requestId,
+      info
+    });
+  } catch (err2) {
+    send({
+      type: "resource.info.error",
+      id: requestId,
+      error: "unavailable",
+      message: err2 instanceof Error ? err2.message : String(err2)
+    });
+  }
+}
 function resourceInvalidRequest(url, message) {
   return {
     ok: false,
@@ -1741,14 +1773,14 @@ async function fetchResourceItem(options, identity, url, init, signal) {
       headers,
       bodyBase64: arrayBufferToBase64(buffer)
     };
-  } catch (err) {
-    const isAbort = signal.aborted || err instanceof Error && (err.name === "AbortError" || err.name === "DOMException");
+  } catch (err2) {
+    const isAbort = signal.aborted || err2 instanceof Error && (err2.name === "AbortError" || err2.name === "DOMException");
     return {
       ok: false,
       url,
       error: isAbort ? "timeout" : "network-error",
       code: isAbort ? "canceled" : "network-error",
-      message: err instanceof Error ? err.message : String(err)
+      message: err2 instanceof Error ? err2.message : String(err2)
     };
   }
 }
@@ -1866,6 +1898,14 @@ function createResourceService(options) {
           });
           return;
         }
+        case "resource.info": {
+          const m = message;
+          const requestId = requestIdFromMessage(m);
+          if (!requestId) return;
+          handleInfo(options, windowId, requestId, send).catch(() => {
+          });
+          return;
+        }
         case "resource.bytesMany": {
           const m = message;
           const requestId = requestIdFromMessage(m);
@@ -1896,7 +1936,7 @@ var OUTBOX_SERVICE_VERSION = "1.0.0";
 var OUTBOX_DESCRIPTOR = {
   name: "outbox",
   version: OUTBOX_SERVICE_VERSION,
-  description: "NAP-OUTBOX outbox-aware relay routing \u2014 query/subscribe/publish/resolveRelays"
+  description: "NAP-OUTBOX outbox-aware relay routing \u2014 getEvent/query/subscribe/publish/resolveRelays"
 };
 function normalizeFilters(raw) {
   if (Array.isArray(raw)) {
@@ -1906,6 +1946,59 @@ function normalizeFilters(raw) {
   if (typeof raw === "object" && raw !== null) return [raw];
   return null;
 }
+function buildEventQuery(eventId, eventOptions) {
+  const filter = { ids: [eventId] };
+  const queryOptions = { limit: 1 };
+  if (typeof eventOptions?.author === "string" && eventOptions.author.length > 0) {
+    filter.authors = [eventOptions.author];
+    queryOptions.authors = [eventOptions.author];
+  }
+  if (Array.isArray(eventOptions?.relays)) queryOptions.relays = eventOptions.relays;
+  if (eventOptions?.strategy !== void 0) queryOptions.strategy = eventOptions.strategy;
+  if (eventOptions?.timeoutMs !== void 0) queryOptions.timeoutMs = eventOptions.timeoutMs;
+  return { filter, queryOptions };
+}
+function eventResultFromQuery(eventId, result) {
+  const event = result.events.find((candidate) => candidate.id === eventId);
+  const eventResult = {
+    relays: event ? result.relays[eventId] ?? [] : []
+  };
+  if (event) eventResult.event = event;
+  if (!event) eventResult.error = result.error ?? "not found";
+  else if (result.error !== void 0) eventResult.error = result.error;
+  if (result.incomplete !== void 0) eventResult.incomplete = result.incomplete;
+  return eventResult;
+}
+function fallbackGetEvent(router, eventId, eventOptions) {
+  const { filter, queryOptions } = buildEventQuery(eventId, eventOptions);
+  return router.query([filter], queryOptions).then((result) => eventResultFromQuery(eventId, result));
+}
+function sendEventResult(id, eventId, result, send) {
+  if (result.event && result.event.id !== eventId) {
+    send({ type: "outbox.getEvent.result", id, relays: [], error: "not found" });
+    return;
+  }
+  send({
+    type: "outbox.getEvent.result",
+    id,
+    ...result.event === void 0 ? {} : { event: result.event },
+    relays: result.relays,
+    ...result.incomplete === void 0 ? {} : { incomplete: result.incomplete },
+    ...result.error === void 0 ? {} : { error: result.error }
+  });
+}
+function handleGetEvent(router, msg, send) {
+  const m = msg;
+  const id = m.id ?? "";
+  if (typeof m.eventId !== "string" || m.eventId.length === 0) {
+    send({ type: "outbox.getEvent.result", id, relays: [], error: "invalid filter" });
+    return;
+  }
+  const getEvent = router.getEvent ?? ((eventId, eventOptions) => fallbackGetEvent(router, eventId, eventOptions));
+  void getEvent(m.eventId, m.options).then((result) => sendEventResult(id, m.eventId, result, send)).catch(
+    (err2) => send({ type: "outbox.getEvent.result", id, relays: [], error: toErrorMessage(err2) })
+  );
+}
 function createOutboxService(options) {
   if (!options || typeof options.router !== "object" || options.router === null) {
     throw new Error("createOutboxService: options.router is required");
@@ -1930,7 +2023,7 @@ function createOutboxService(options) {
         ...result.error === void 0 ? {} : { error: result.error }
       })
     ).catch(
-      (err) => send({ type: "outbox.query.result", id, events: [], relays: {}, error: toErrorMessage(err) })
+      (err2) => send({ type: "outbox.query.result", id, events: [], relays: {}, error: toErrorMessage(err2) })
     );
   }
   function handleSubscribe(windowId, msg, send) {
@@ -1982,7 +2075,7 @@ function createOutboxService(options) {
         ...result.error === void 0 ? {} : { error: result.error }
       })
     ).catch(
-      (err) => send({ type: "outbox.publish.result", id, ok: false, error: toErrorMessage(err) })
+      (err2) => send({ type: "outbox.publish.result", id, ok: false, error: toErrorMessage(err2) })
     );
   }
   function handleResolveRelays(msg, send) {
@@ -1993,13 +2086,16 @@ function createOutboxService(options) {
       return;
     }
     void router.resolveRelays(m.target).then((plan) => send({ type: "outbox.resolveRelays.result", id, plan })).catch(
-      (err) => send({ type: "outbox.resolveRelays.result", id, error: toErrorMessage(err) })
+      (err2) => send({ type: "outbox.resolveRelays.result", id, error: toErrorMessage(err2) })
     );
   }
   return {
     descriptor: OUTBOX_DESCRIPTOR,
     handleMessage(windowId, message, send) {
       switch (message.type) {
+        case "outbox.getEvent":
+          handleGetEvent(router, message, send);
+          return;
         case "outbox.query":
           handleQuery(message, send);
           return;
@@ -2030,9 +2126,9 @@ function createOutboxService(options) {
     }
   };
 }
-function toErrorMessage(err) {
-  if (err instanceof Error) return err.message;
-  if (typeof err === "string") return err;
+function toErrorMessage(err2) {
+  if (err2 instanceof Error) return err2.message;
+  if (typeof err2 === "string") return err2;
   return "outbox request failed";
 }
 
@@ -2115,7 +2211,7 @@ function buildCollectResult(collector, timedOut) {
   for (const event of events) relayObj[event.id] = [...collector.relayMap.get(event.id) ?? []];
   return { events, relayMap: relayObj, incomplete: timedOut };
 }
-function collectFromRelays(ctx, filters, relayUrls, timeoutMs) {
+function collectFromRelays(ctx, filters, relayUrls2, timeoutMs) {
   return new Promise((resolve) => {
     const collector = { seen: /* @__PURE__ */ new Map(), relayMap: /* @__PURE__ */ new Map(), verifications: [] };
     const handles = [];
@@ -2138,19 +2234,19 @@ function collectFromRelays(ctx, filters, relayUrls, timeoutMs) {
       timedOut = true;
       finalize();
     }, timeoutMs);
-    for (const relayUrl of relayUrls) {
+    for (const relayUrl of relayUrls2) {
       handles.push(relayPoolSubscribe(ctx, filters, relayUrl, (item) => {
         if (finished) return;
         if (item === "EOSE") {
           eoseCount += 1;
-          if (eoseCount >= relayUrls.length) finalize();
+          if (eoseCount >= relayUrls2.length) finalize();
           return;
         }
         recordRelay(collector, item.id, relayUrl);
         admitEvent(ctx, collector, item);
       }));
     }
-    if (relayUrls.length === 0) finalize();
+    if (relayUrls2.length === 0) finalize();
   });
 }
 function relayPoolSubscribe(ctx, filters, relayUrl, cb) {
@@ -2177,6 +2273,30 @@ async function queryImpl(ctx, filters, options) {
   if (incomplete) result.incomplete = true;
   return result;
 }
+async function getEventImpl(ctx, eventId, options) {
+  if (typeof eventId !== "string" || eventId.length === 0) {
+    return { relays: [], error: "invalid filter" };
+  }
+  const filter = { ids: [eventId] };
+  const queryOptions = { limit: 1 };
+  if (typeof options?.author === "string" && options.author.length > 0) {
+    filter.authors = [options.author];
+    queryOptions.authors = [options.author];
+  }
+  if (Array.isArray(options?.relays)) queryOptions.relays = options.relays;
+  if (options?.strategy !== void 0) queryOptions.strategy = options.strategy;
+  if (options?.timeoutMs !== void 0) queryOptions.timeoutMs = options.timeoutMs;
+  const queryResult = await queryImpl(ctx, [filter], queryOptions);
+  const event = queryResult.events.find((candidate) => candidate.id === eventId);
+  const result = {
+    relays: event ? queryResult.relays[eventId] ?? [] : []
+  };
+  if (event) result.event = event;
+  if (!event) result.error = queryResult.error ?? "not found";
+  else if (queryResult.error !== void 0) result.error = queryResult.error;
+  if (queryResult.incomplete !== void 0) result.incomplete = queryResult.incomplete;
+  return result;
+}
 function closeLiveSub(sub) {
   for (const handle of sub.handles) {
     try {
@@ -2223,8 +2343,8 @@ function startSubscription(ctx, filters, options, sink) {
     }
     sub.relayCount = plan.relays.length;
     for (const relayUrl of plan.relays) attachLiveRelay(ctx, sub, filters, relayUrl, live, sink);
-  }).catch((err) => {
-    if (!sub.closed) sink.closed(err instanceof Error ? err.message : "subscribe failed");
+  }).catch((err2) => {
+    if (!sub.closed) sink.closed(err2 instanceof Error ? err2.message : "subscribe failed");
   });
   return {
     close() {
@@ -2252,16 +2372,16 @@ async function publishImpl(ctx, template, options) {
   let signed;
   try {
     signed = await ctx.signEvent(template);
-  } catch (err) {
-    return { ok: false, error: err instanceof Error ? err.message : "sign failed" };
+  } catch (err2) {
+    return { ok: false, error: err2 instanceof Error ? err2.message : "sign failed" };
   }
-  const relayUrls = await resolvePublishTargets(ctx, signed, options);
-  if (relayUrls.length === 0) return { ok: false, event: signed, eventId: signed.id, error: "relay list unavailable" };
+  const relayUrls2 = await resolvePublishTargets(ctx, signed, options);
+  if (relayUrls2.length === 0) return { ok: false, event: signed, eventId: signed.id, error: "relay list unavailable" };
   let relays;
   try {
-    relays = normalizePublishResult(await ctx.relayPool.publish(signed, relayUrls), relayUrls);
-  } catch (err) {
-    return { ok: false, event: signed, eventId: signed.id, error: err instanceof Error ? err.message : "publish failed" };
+    relays = normalizePublishResult(await ctx.relayPool.publish(signed, relayUrls2), relayUrls2);
+  } catch (err2) {
+    return { ok: false, event: signed, eventId: signed.id, error: err2 instanceof Error ? err2.message : "publish failed" };
   }
   const ok = Object.values(relays).some(Boolean);
   const result = { ok, event: signed, eventId: signed.id, relays };
@@ -2296,6 +2416,7 @@ function createRelayPoolOutboxRouter(options) {
     }
   };
   return {
+    getEvent: (eventId, eventOptions) => getEventImpl(ctx, eventId, eventOptions),
     query: (filters, queryOptions) => queryImpl(ctx, filters, queryOptions),
     subscribe: (filters, subscribeOptions, sink) => startSubscription(ctx, filters, subscribeOptions, sink),
     publish: (template, publishOptions) => publishImpl(ctx, template, publishOptions),
@@ -2305,12 +2426,12 @@ function createRelayPoolOutboxRouter(options) {
     }
   };
 }
-function normalizePublishResult(res, relayUrls) {
+function normalizePublishResult(res, relayUrls2) {
   const out = {};
   if (res && typeof res === "object") {
-    for (const url of relayUrls) out[url] = res[url] ?? false;
+    for (const url of relayUrls2) out[url] = res[url] ?? false;
   } else {
-    for (const url of relayUrls) out[url] = true;
+    for (const url of relayUrls2) out[url] = true;
   }
   return out;
 }
@@ -2322,14 +2443,38 @@ var UPLOAD_DESCRIPTOR = {
   version: UPLOAD_SERVICE_VERSION,
   description: "NAP-UPLOAD shell-mediated file/blob upload \u2014 upload/status with progress pushes"
 };
+var DEFAULT_UPLOAD_INFO = {
+  rails: []
+};
 function createUploadService(options) {
   if (!options || typeof options.uploader !== "object" || options.uploader === null) {
     throw new Error("createUploadService: options.uploader is required");
   }
   const { uploader } = options;
+  const uploadInfo = options.uploadInfo ?? DEFAULT_UPLOAD_INFO;
   const generateId2 = options.generateId ?? (() => crypto.randomUUID());
   const now = options.now ?? (() => Date.now());
   const entries = /* @__PURE__ */ new Map();
+  function normalizeUploadInfo(info) {
+    return {
+      rails: Array.isArray(info.rails) ? info.rails.filter((rail) => typeof rail?.rail === "string").map((rail) => ({
+        rail: rail.rail,
+        enabled: rail.enabled !== false,
+        ...Array.isArray(rail.returns) ? { returns: rail.returns.filter((value) => typeof value === "string") } : {}
+      })) : [],
+      ...typeof info.maxBytes === "number" ? { maxBytes: info.maxBytes } : {},
+      ...Array.isArray(info.mimeTypes) ? { mimeTypes: info.mimeTypes.filter((value) => typeof value === "string") } : {}
+    };
+  }
+  function handleInfo2(windowId, msg, send) {
+    const m = msg;
+    const id = m.id ?? "";
+    void Promise.resolve().then(() => typeof uploadInfo === "function" ? uploadInfo({ windowId }) : uploadInfo).then((info) => {
+      send({ type: "upload.info.result", id, info: normalizeUploadInfo(info) });
+    }).catch((err2) => {
+      send({ type: "upload.info.result", id, error: toErrorMessage2(err2) });
+    });
+  }
   function handleUpload(windowId, msg, send) {
     const m = msg;
     const id = m.id ?? "";
@@ -2356,9 +2501,9 @@ function createUploadService(options) {
       const entry = entries.get(key);
       if (entry) entry.status = { ...stamped, updatedAt: now() };
       send({ type: "upload.upload.result", id, result: stamped });
-    }).catch((err) => {
+    }).catch((err2) => {
       entries.delete(key);
-      send({ type: "upload.upload.result", id, error: toErrorMessage2(err) });
+      send({ type: "upload.upload.result", id, error: toErrorMessage2(err2) });
     });
   }
   function handleStatus(windowId, msg, send) {
@@ -2380,7 +2525,7 @@ function createUploadService(options) {
           status ? { type: "upload.status.result", id, status } : { type: "upload.status.result", id, error: "unknown upload" }
         )
       ).catch(
-        (err) => send({ type: "upload.status.result", id, error: toErrorMessage2(err) })
+        (err2) => send({ type: "upload.status.result", id, error: toErrorMessage2(err2) })
       );
       return;
     }
@@ -2390,6 +2535,9 @@ function createUploadService(options) {
     descriptor: UPLOAD_DESCRIPTOR,
     handleMessage(windowId, message, send) {
       switch (message.type) {
+        case "upload.info":
+          handleInfo2(windowId, message, send);
+          return;
         case "upload.upload":
           handleUpload(windowId, message, send);
           return;
@@ -2411,9 +2559,9 @@ function createUploadService(options) {
     }
   };
 }
-function toErrorMessage2(err) {
-  if (err instanceof Error) return err.message;
-  if (typeof err === "string") return err;
+function toErrorMessage2(err2) {
+  if (err2 instanceof Error) return err2.message;
+  if (typeof err2 === "string") return err2;
   return "upload request failed";
 }
 
@@ -2445,8 +2593,8 @@ function createHttpUploader(options) {
     const sha256 = await digest(bytes);
     try {
       return rail === "nip96" ? await uploadNip96({ request, ctx, server, bytes, sha256, signEvent, fetchFn, nowS }) : await uploadBlossom({ request, ctx, server, bytes, sha256, signEvent, fetchFn, nowS });
-    } catch (err) {
-      return failed(ctx.uploadId, rail, toErrorMessage3(err), sha256);
+    } catch (err2) {
+      return failed(ctx.uploadId, rail, toErrorMessage3(err2), sha256);
     }
   }
   return { upload };
@@ -2581,9 +2729,9 @@ async function defaultDigestSha256(bytes) {
   const buf = await crypto.subtle.digest("SHA-256", bytesToArrayBuffer(bytes));
   return Array.from(new Uint8Array(buf)).map((b) => b.toString(16).padStart(2, "0")).join("");
 }
-function toErrorMessage3(err) {
-  if (err instanceof Error) return err.message;
-  if (typeof err === "string") return err;
+function toErrorMessage3(err2) {
+  if (err2 instanceof Error) return err2.message;
+  if (typeof err2 === "string") return err2;
   return "upload failed";
 }
 
@@ -2594,9 +2742,9 @@ var INTENT_DESCRIPTOR = {
   version: INTENT_SERVICE_VERSION,
   description: "NAP-INTENT archetype intent dispatch \u2014 invoke/available/handlers"
 };
-function toErrorMessage4(err) {
-  if (err instanceof Error) return err.message;
-  if (typeof err === "string") return err;
+function toErrorMessage4(err2) {
+  if (err2 instanceof Error) return err2.message;
+  if (typeof err2 === "string") return err2;
   return "intent request failed";
 }
 function createIntentService(options) {
@@ -2614,11 +2762,11 @@ function createIntentService(options) {
     let pending;
     try {
       pending = Promise.resolve(call());
-    } catch (err) {
-      send({ type: resultType, id, error: toErrorMessage4(err) });
+    } catch (err2) {
+      send({ type: resultType, id, error: toErrorMessage4(err2) });
       return;
     }
-    pending.then((value) => send(onValue(value))).catch((err) => send({ type: resultType, id, error: toErrorMessage4(err) }));
+    pending.then((value) => send(onValue(value))).catch((err2) => send({ type: resultType, id, error: toErrorMessage4(err2) }));
   }
   function handleInvoke(windowId, msg, send) {
     const m = msg;
@@ -2867,7 +3015,7 @@ function createCvmService(options) {
     const m = msg;
     const id = m.id ?? "";
     void transport.discover(m.query).then((servers) => send({ type: "cvm.discover.result", id, servers })).catch(
-      (err) => send({ type: "cvm.discover.result", id, servers: [], error: toErrorMessage5(err) })
+      (err2) => send({ type: "cvm.discover.result", id, servers: [], error: toErrorMessage5(err2) })
     );
   }
   function handleRequest(windowId, msg, send) {
@@ -2883,7 +3031,7 @@ function createCvmService(options) {
     }
     openSession(windowId, m.server, send);
     void transport.request(m.server, m.message, m.options).then((message) => send({ type: "cvm.request.result", id, message })).catch(
-      (err) => send({ type: "cvm.request.result", id, error: toErrorMessage5(err) })
+      (err2) => send({ type: "cvm.request.result", id, error: toErrorMessage5(err2) })
     );
   }
   function handleClose(windowId, msg, send) {
@@ -2894,7 +3042,7 @@ function createCvmService(options) {
       return;
     }
     closeSession(windowId, m.server.pubkey);
-    void transport.close(m.server).then(() => send({ type: "cvm.close.result", id })).catch((err) => send({ type: "cvm.close.result", id, error: toErrorMessage5(err) }));
+    void transport.close(m.server).then(() => send({ type: "cvm.close.result", id })).catch((err2) => send({ type: "cvm.close.result", id, error: toErrorMessage5(err2) }));
   }
   return {
     descriptor: CVM_DESCRIPTOR,
@@ -2925,9 +3073,9 @@ function createCvmService(options) {
     }
   };
 }
-function toErrorMessage5(err) {
-  if (err instanceof Error) return err.message;
-  if (typeof err === "string") return err;
+function toErrorMessage5(err2) {
+  if (err2 instanceof Error) return err2.message;
+  if (typeof err2 === "string") return err2;
   return "cvm request failed";
 }
 
@@ -3006,20 +3154,20 @@ var LISTS_DESCRIPTOR = {
   version: LISTS_SERVICE_VERSION,
   description: "NAP-LISTS reference handler for shell-mediated NIP-51 list mutations"
 };
-function errorMessage(err, fallback) {
-  if (err instanceof Error) return err.message;
-  if (typeof err === "string") return err;
+function errorMessage(err2, fallback) {
+  if (err2 instanceof Error) return err2.message;
+  if (typeof err2 === "string") return err2;
   return fallback;
 }
 function settle(call, send, okFalse, onValue) {
   let pending;
   try {
     pending = Promise.resolve(call());
-  } catch (err) {
-    send(okFalse(errorMessage(err, "lists request failed")));
+  } catch (err2) {
+    send(okFalse(errorMessage(err2, "lists request failed")));
     return;
   }
-  pending.then((value) => send(onValue(value))).catch((err) => send(okFalse(errorMessage(err, "lists request failed"))));
+  pending.then((value) => send(onValue(value))).catch((err2) => send(okFalse(errorMessage(err2, "lists request failed"))));
 }
 function unsupportedMutation(resultType, id) {
   return {
@@ -3088,20 +3236,20 @@ var SERIAL_DESCRIPTOR = {
   version: SERIAL_SERVICE_VERSION,
   description: "NAP-SERIAL reference handler for shell-mediated serial sessions"
 };
-function errorMessage2(err, fallback) {
-  if (err instanceof Error) return err.message;
-  if (typeof err === "string") return err;
+function errorMessage2(err2, fallback) {
+  if (err2 instanceof Error) return err2.message;
+  if (typeof err2 === "string") return err2;
   return fallback;
 }
 function settle2(call, send, okFalse, onValue) {
   let pending;
   try {
     pending = Promise.resolve(call());
-  } catch (err) {
-    send(okFalse(errorMessage2(err, "serial request failed")));
+  } catch (err2) {
+    send(okFalse(errorMessage2(err2, "serial request failed")));
     return;
   }
-  pending.then((value) => send(onValue(value))).catch((err) => send(okFalse(errorMessage2(err, "serial request failed"))));
+  pending.then((value) => send(onValue(value))).catch((err2) => send(okFalse(errorMessage2(err2, "serial request failed"))));
 }
 function unsupported(resultType, id) {
   return {
@@ -3177,20 +3325,20 @@ var BLE_DESCRIPTOR = {
   version: BLE_SERVICE_VERSION,
   description: "NAP-BLE reference handler for shell-mediated BLE/GATT sessions"
 };
-function errorMessage3(err, fallback) {
-  if (err instanceof Error) return err.message;
-  if (typeof err === "string") return err;
+function errorMessage3(err2, fallback) {
+  if (err2 instanceof Error) return err2.message;
+  if (typeof err2 === "string") return err2;
   return fallback;
 }
 function settle3(call, send, okFalse, onValue) {
   let pending;
   try {
     pending = Promise.resolve(call());
-  } catch (err) {
-    send(okFalse(errorMessage3(err, "ble request failed")));
+  } catch (err2) {
+    send(okFalse(errorMessage3(err2, "ble request failed")));
     return;
   }
-  pending.then((value) => send(onValue(value))).catch((err) => send(okFalse(errorMessage3(err, "ble request failed"))));
+  pending.then((value) => send(onValue(value))).catch((err2) => send(okFalse(errorMessage3(err2, "ble request failed"))));
 }
 function unsupported2(resultType, id) {
   return {
@@ -3330,20 +3478,20 @@ var WEBRTC_DESCRIPTOR = {
   version: WEBRTC_SERVICE_VERSION,
   description: "NAP-WEBRTC reference handler for shell-mediated WebRTC sessions"
 };
-function errorMessage4(err, fallback) {
-  if (err instanceof Error) return err.message;
-  if (typeof err === "string") return err;
+function errorMessage4(err2, fallback) {
+  if (err2 instanceof Error) return err2.message;
+  if (typeof err2 === "string") return err2;
   return fallback;
 }
 function settle4(call, send, okFalse, onValue) {
   let pending;
   try {
     pending = Promise.resolve(call());
-  } catch (err) {
-    send(okFalse(errorMessage4(err, "webrtc request failed")));
+  } catch (err2) {
+    send(okFalse(errorMessage4(err2, "webrtc request failed")));
     return;
   }
-  pending.then((value) => send(onValue(value))).catch((err) => send(okFalse(errorMessage4(err, "webrtc request failed"))));
+  pending.then((value) => send(onValue(value))).catch((err2) => send(okFalse(errorMessage4(err2, "webrtc request failed"))));
 }
 function unsupported3(resultType, id) {
   return {
@@ -3437,9 +3585,9 @@ var COMMON_DESCRIPTOR = {
   version: COMMON_SERVICE_VERSION,
   description: "NAP-COMMON reference handler for shell-mediated social helpers"
 };
-function errorMessage5(err, fallback) {
-  if (err instanceof Error) return err.message;
-  if (typeof err === "string") return err;
+function errorMessage5(err2, fallback) {
+  if (err2 instanceof Error) return err2.message;
+  if (typeof err2 === "string") return err2;
   return fallback;
 }
 function encodeNip19(input) {
@@ -3468,8 +3616,8 @@ function encodeNip19(input) {
       default:
         return { ok: false, error: "unsupported NIP-19 type" };
     }
-  } catch (err) {
-    return { ok: false, error: errorMessage5(err, "NIP-19 encode failed") };
+  } catch (err2) {
+    return { ok: false, error: errorMessage5(err2, "NIP-19 encode failed") };
   }
 }
 function decodeNip19Value(value) {
@@ -3502,9 +3650,9 @@ function decodeNip19Value(value) {
       default:
         return { ok: false, error: "unsupported NIP-19 type" };
     }
-  } catch (err) {
+  } catch (err2) {
     if (value.startsWith("nrelay1")) return decodeNrelay(value);
-    return { ok: false, error: errorMessage5(err, "NIP-19 decode failed") };
+    return { ok: false, error: errorMessage5(err2, "NIP-19 decode failed") };
   }
 }
 function decodeNrelay(value) {
@@ -3520,8 +3668,8 @@ function decodeNrelay(value) {
     const payloadWords = words.slice(0, -6);
     const bytes = convertBits(payloadWords, 5, 8, false);
     return { ok: true, nip19Type: "nrelay", relay: new TextDecoder().decode(Uint8Array.from(bytes)) };
-  } catch (err) {
-    return { ok: false, error: errorMessage5(err, "invalid nrelay value") };
+  } catch (err2) {
+    return { ok: false, error: errorMessage5(err2, "invalid nrelay value") };
   }
 }
 function convertBits(data, fromBits, toBits, pad) {
@@ -3550,11 +3698,11 @@ function settle5(call, send, okFalse, onValue) {
   let pending;
   try {
     pending = Promise.resolve(call());
-  } catch (err) {
-    send(okFalse(errorMessage5(err, "common request failed")));
+  } catch (err2) {
+    send(okFalse(errorMessage5(err2, "common request failed")));
     return;
   }
-  pending.then((value) => send(onValue(value))).catch((err) => send(okFalse(errorMessage5(err, "common request failed"))));
+  pending.then((value) => send(onValue(value))).catch((err2) => send(okFalse(errorMessage5(err2, "common request failed"))));
 }
 function createCommonService(options = {}) {
   return {
@@ -3661,7 +3809,650 @@ function settleAction(action, pubkeys, context, send, resultType, id, unavailabl
     (result) => ({ type: resultType, id, ...result })
   );
 }
+
+// src/dm-service.ts
+var DM_DESCRIPTOR = {
+  name: "dm",
+  version: "1.0.0",
+  description: "NAP-DM runtime-mediated direct messages"
+};
+function err(error, fallback = "dm request failed") {
+  if (error instanceof Error) return error.message;
+  if (typeof error === "string") return error;
+  return fallback;
+}
+function createDmService(options) {
+  if (!options || typeof options.adapter !== "object" || options.adapter === null) {
+    throw new Error("createDmService: options.adapter is required");
+  }
+  const { adapter } = options;
+  const ownedSubscriptions = /* @__PURE__ */ new Map();
+  function remember(windowId, subscriptionId) {
+    let subs = ownedSubscriptions.get(windowId);
+    if (!subs) {
+      subs = /* @__PURE__ */ new Set();
+      ownedSubscriptions.set(windowId, subs);
+    }
+    subs.add(subscriptionId);
+  }
+  function forget(windowId, subscriptionId) {
+    const subs = ownedSubscriptions.get(windowId);
+    if (!subs) return;
+    subs.delete(subscriptionId);
+    if (subs.size === 0) ownedSubscriptions.delete(windowId);
+  }
+  return {
+    descriptor: DM_DESCRIPTOR,
+    handleMessage(windowId, message, send) {
+      const id = message.id;
+      const requestId = typeof id === "string" ? id : "";
+      switch (message.type) {
+        case "dm.status":
+          void Promise.resolve(adapter.status()).then((status) => send({ type: "dm.status.result", id: requestId, ...status })).catch((error) => send({ type: "dm.status.result", id: requestId, error: err(error) }));
+          return;
+        case "dm.conversations":
+          void Promise.resolve(adapter.conversations(message)).then((page) => send({ type: "dm.conversations.result", id: requestId, ...page })).catch(
+            (error) => send({ type: "dm.conversations.result", id: requestId, conversations: [], error: err(error) })
+          );
+          return;
+        case "dm.messages":
+          void Promise.resolve(adapter.messages(message)).then((page) => send({ type: "dm.messages.result", id: requestId, ...page })).catch(
+            (error) => send({ type: "dm.messages.result", id: requestId, messages: [], error: err(error) })
+          );
+          return;
+        case "dm.send":
+          void adapter.send(message).then((result) => send({ type: "dm.send.result", id: requestId, ...result })).catch((error) => send({ type: "dm.send.result", id: requestId, error: err(error) }));
+          return;
+        case "dm.subscribe": {
+          let activeSubscriptionId = "";
+          void Promise.resolve(
+            adapter.subscribe(message, (dmMessage) => {
+              if (activeSubscriptionId.length > 0) {
+                send({ type: "dm.message", subscriptionId: activeSubscriptionId, message: dmMessage });
+              }
+            })
+          ).then((subscription) => {
+            remember(windowId, subscription.subscriptionId);
+            activeSubscriptionId = subscription.subscriptionId;
+            send({ type: "dm.subscribe.result", id: requestId, ...subscription });
+          }).catch((error) => {
+            send({ type: "dm.subscribe.result", id: requestId, error: err(error) });
+          });
+          return;
+        }
+        case "dm.unsubscribe": {
+          const subId = message.subscriptionId;
+          if (typeof subId !== "string" || subId.length === 0) {
+            send({ type: "dm.unsubscribe.result", id: requestId, ok: false, error: "subscription not found" });
+            return;
+          }
+          void Promise.resolve(adapter.unsubscribe(subId)).then((ok) => {
+            forget(windowId, subId);
+            send({ type: "dm.unsubscribe.result", id: requestId, ...ok });
+          }).catch((error) => send({ type: "dm.unsubscribe.result", id: requestId, ok: false, error: err(error) }));
+          return;
+        }
+        default:
+          return;
+      }
+    },
+    onWindowDestroyed(windowId) {
+      const subs = ownedSubscriptions.get(windowId);
+      if (!subs) return;
+      for (const subId of subs) void Promise.resolve(adapter.unsubscribe(subId)).catch(() => void 0);
+      ownedSubscriptions.delete(windowId);
+    },
+    dispose() {
+      adapter.close?.();
+      ownedSubscriptions.clear();
+    }
+  };
+}
+
+// src/dm-nip17-adapter.ts
+import { getPublicKey } from "nostr-tools/pure";
+import * as nip17 from "nostr-tools/nip17";
+
+// src/dm-memory-store.ts
+var DmMemoryStore = class {
+  messagesByConversation = /* @__PURE__ */ new Map();
+  participantsByConversation = /* @__PURE__ */ new Map();
+  conversationIdFor(participants) {
+    return `direct:${[...new Set(participants)].sort().join(",")}`;
+  }
+  upsertMessage(message, participants) {
+    const peers = [...new Set(participants)].sort().map((pubkey) => ({ pubkey }));
+    this.participantsByConversation.set(message.conversationId, peers);
+    const list = this.messagesByConversation.get(message.conversationId) ?? [];
+    const existing = list.findIndex((entry) => entry.id === message.id);
+    if (existing >= 0) list[existing] = message;
+    else list.push(message);
+    list.sort((a, b) => a.createdAt - b.createdAt);
+    this.messagesByConversation.set(message.conversationId, list);
+    return message;
+  }
+  conversations(query = {}) {
+    const offset = query.cursor ? Number.parseInt(query.cursor, 10) || 0 : 0;
+    const limit = query.limit ?? 50;
+    const conversations = [...this.messagesByConversation.entries()].map(([id, messages]) => {
+      const latest = messages[messages.length - 1];
+      return {
+        id,
+        kind: id.startsWith("group:") ? "group" : "direct",
+        participants: this.participantsByConversation.get(id) ?? [],
+        unread: messages.filter((message) => message.status === "received").length,
+        ...latest ? { updatedAt: latest.createdAt } : {}
+      };
+    }).sort((a, b) => (b.updatedAt ?? 0) - (a.updatedAt ?? 0));
+    const page = conversations.slice(offset, offset + limit);
+    const next = offset + page.length < conversations.length ? String(offset + page.length) : void 0;
+    return { conversations: page, ...next ? { cursor: next } : {} };
+  }
+  messages(query) {
+    const offset = query.cursor ? Number.parseInt(query.cursor, 10) || 0 : 0;
+    const limit = query.limit ?? 100;
+    const all = this.messagesByConversation.get(query.conversationId) ?? [];
+    const page = all.slice(offset, offset + limit);
+    const next = offset + page.length < all.length ? String(offset + page.length) : void 0;
+    return { messages: page, ...next ? { cursor: next } : {} };
+  }
+};
+
+// src/dm-nip17-adapter.ts
+var NIP17_GIFT_WRAP_KIND = 1059;
+var subscriptionCounter = 0;
+function tagsFor(tags, name) {
+  return tags.filter((tag) => tag[0] === name && typeof tag[1] === "string").map((tag) => tag[1]);
+}
+function nowSeconds() {
+  return Math.floor(Date.now() / 1e3);
+}
+function createNip17DmAdapter(options) {
+  const ownerPubkey = getPublicKey(options.ownerSecretKey);
+  const store = options.store ?? new DmMemoryStore();
+  const live = /* @__PURE__ */ new Map();
+  function relaysFor2(filters) {
+    return options.relays && options.relays.length > 0 ? options.relays : options.relayPool.selectRelayTier(filters);
+  }
+  function normalizeRumor(rumor, status) {
+    if (rumor.kind !== 14) return null;
+    const participants = [.../* @__PURE__ */ new Set([ownerPubkey, rumor.pubkey, ...tagsFor(rumor.tags, "p")])];
+    const conversationId = store.conversationIdFor(participants);
+    return store.upsertMessage(
+      {
+        id: rumor.id,
+        conversationId,
+        senderPubkey: rumor.pubkey,
+        createdAt: rumor.created_at,
+        content: rumor.content,
+        status
+      },
+      participants
+    );
+  }
+  return {
+    status() {
+      return {
+        available: options.relayPool.isAvailable(),
+        ownerPubkey,
+        implementations: ["nip17"],
+        capabilities: ["send", "receive", "subscribe", "history"]
+      };
+    },
+    conversations(query) {
+      return store.conversations(query);
+    },
+    messages(query) {
+      return store.messages(query);
+    },
+    async send(request) {
+      if (!options.relayPool.isAvailable()) throw new Error("relay unavailable");
+      if (!Array.isArray(request.recipients) || request.recipients.length === 0) {
+        throw new Error("recipient required");
+      }
+      if (typeof request.content !== "string" || request.content.length === 0) {
+        throw new Error("content required");
+      }
+      const recipients = [...new Set(request.recipients)];
+      const wraps = nip17.wrapManyEvents(
+        options.ownerSecretKey,
+        recipients.map((publicKey) => ({ publicKey })),
+        request.content
+      );
+      for (const wrap of wraps) await Promise.resolve(options.relayPool.publish(wrap));
+      const conversationId = request.conversationId ?? store.conversationIdFor([ownerPubkey, ...recipients]);
+      const message = store.upsertMessage(
+        {
+          id: request.clientMessageId ?? wraps[0]?.id ?? `dm-${nowSeconds()}`,
+          conversationId,
+          senderPubkey: ownerPubkey,
+          createdAt: nowSeconds(),
+          content: request.content,
+          status: "sent"
+        },
+        [ownerPubkey, ...recipients]
+      );
+      return { ok: true, message };
+    },
+    subscribe(request, onMessage) {
+      if (!options.relayPool.isAvailable()) throw new Error("relay unavailable");
+      const subscriptionId = `dm-nip17-${++subscriptionCounter}`;
+      const filters = [{ kinds: [NIP17_GIFT_WRAP_KIND], "#p": [ownerPubkey] }];
+      const handle = options.relayPool.subscribe(
+        filters,
+        (item) => {
+          if (item === "EOSE") return;
+          let rumor;
+          try {
+            rumor = nip17.unwrapEvent(item, options.ownerSecretKey);
+          } catch {
+            return;
+          }
+          const message = normalizeRumor(rumor, "received");
+          if (!message) return;
+          for (const sub of live.values()) {
+            if (!sub.conversationId || sub.conversationId === message.conversationId) sub.onMessage(message);
+          }
+        },
+        relaysFor2(filters)
+      );
+      live.set(subscriptionId, { handle, conversationId: request.conversationId, onMessage });
+      return { subscriptionId };
+    },
+    unsubscribe(subscriptionId) {
+      const sub = live.get(subscriptionId);
+      if (!sub) return { ok: false };
+      sub.handle.unsubscribe();
+      live.delete(subscriptionId);
+      return { ok: true };
+    },
+    close() {
+      for (const sub of live.values()) sub.handle.unsubscribe();
+      live.clear();
+    }
+  };
+}
+
+// src/dm-ndr-adapter.ts
+import { finalizeEvent } from "nostr-tools/pure";
+var ndrSubCounter = 0;
+function nowSeconds2() {
+  return Math.floor(Date.now() / 1e3);
+}
+function relaysFor(options, filter) {
+  return options.relays && options.relays.length > 0 ? options.relays : options.relayPool.selectRelayTier([filter]);
+}
+function signedEvent(event, secretKey) {
+  if (typeof event.id === "string" && typeof event.pubkey === "string" && typeof event.sig === "string" && typeof event.kind === "number" && typeof event.created_at === "number" && Array.isArray(event.tags) && typeof event.content === "string") {
+    return event;
+  }
+  if (!secretKey) throw new Error("publishSecretKey required for unsigned NDR events");
+  return finalizeEvent(
+    {
+      kind: event.kind ?? 1060,
+      created_at: event.created_at ?? nowSeconds2(),
+      tags: event.tags ?? [],
+      content: event.content ?? ""
+    },
+    secretKey
+  );
+}
+function createNdrRelayTransport(options) {
+  return {
+    nostrSubscribe(filter, onEvent) {
+      const handle = options.relayPool.subscribe(
+        [filter],
+        (item) => {
+          if (item !== "EOSE") onEvent(item);
+        },
+        relaysFor(options, filter)
+      );
+      return () => handle.unsubscribe();
+    },
+    nostrFetch(filter) {
+      const events = [];
+      return new Promise((resolve) => {
+        let done = false;
+        let handle;
+        const finish = () => {
+          if (done) return;
+          done = true;
+          clearTimeout(timer);
+          handle?.unsubscribe();
+          resolve(events);
+        };
+        const timer = setTimeout(finish, options.fetchTimeoutMs ?? 500);
+        handle = options.relayPool.subscribe(
+          [filter],
+          (item) => {
+            if (item === "EOSE") finish();
+            else events.push(item);
+          },
+          relaysFor(options, filter)
+        );
+      });
+    },
+    async nostrPublish(event) {
+      const signed = signedEvent(event, options.publishSecretKey);
+      await Promise.resolve(options.relayPool.publish(signed));
+      return signed;
+    }
+  };
+}
+function createNdrDmAdapter(options) {
+  const store = options.store ?? new DmMemoryStore();
+  const live = /* @__PURE__ */ new Map();
+  const detach = options.runtime.onSessionEvent((event, from) => {
+    const participants = [options.ownerPubkey, from];
+    const conversationId = store.conversationIdFor(participants);
+    const message = store.upsertMessage(
+      {
+        id: event.id,
+        conversationId,
+        senderPubkey: from,
+        createdAt: event.created_at ?? Math.floor(Date.now() / 1e3),
+        content: event.content ?? "",
+        status: "received"
+      },
+      participants
+    );
+    for (const sub of live.values()) {
+      if (!sub.conversationId || sub.conversationId === message.conversationId) sub.onMessage(message);
+    }
+  });
+  return {
+    status() {
+      return {
+        available: options.available ?? true,
+        ownerPubkey: options.ownerPubkey,
+        implementations: ["ndr"],
+        capabilities: ["send", "receive", "subscribe", "history", "double-ratchet"]
+      };
+    },
+    conversations(query) {
+      return store.conversations(query);
+    },
+    messages(query) {
+      return store.messages(query);
+    },
+    async send(request) {
+      const recipient = request.recipients[0];
+      if (!recipient) throw new Error("recipient required");
+      await options.runtime.setupUser?.(recipient, options.ownerPubkey);
+      const rumor = await options.runtime.sendMessage(recipient, request.content, void 0, options.ownerPubkey);
+      const message = store.upsertMessage(
+        {
+          id: request.clientMessageId ?? rumor.id,
+          conversationId: request.conversationId ?? store.conversationIdFor([options.ownerPubkey, recipient]),
+          senderPubkey: options.ownerPubkey,
+          createdAt: rumor.created_at ?? Math.floor(Date.now() / 1e3),
+          content: request.content,
+          status: "sent"
+        },
+        [options.ownerPubkey, recipient]
+      );
+      return { ok: true, message };
+    },
+    subscribe(request, onMessage) {
+      const subscriptionId = `dm-ndr-${++ndrSubCounter}`;
+      live.set(subscriptionId, { conversationId: request.conversationId, onMessage });
+      return { subscriptionId };
+    },
+    unsubscribe(subscriptionId) {
+      return { ok: live.delete(subscriptionId) };
+    },
+    close() {
+      live.clear();
+      detach();
+      options.runtime.close?.();
+    }
+  };
+}
+
+// src/dm-cordn-adapter.ts
+import { finalizeEvent as finalizeEvent2, getPublicKey as getPublicKey2 } from "nostr-tools/pure";
+var CORDN_RELAY_GROUP_MESSAGE_KIND = 30383;
+var cordnSubCounter = 0;
+function nowSeconds3() {
+  return Math.floor(Date.now() / 1e3);
+}
+function encodeBase64(value) {
+  return btoa(String.fromCharCode(...new TextEncoder().encode(value)));
+}
+function decodeBase64(value) {
+  return new TextDecoder().decode(Uint8Array.from(atob(value), (char) => char.charCodeAt(0)));
+}
+function groupIdFor(request, defaultGroupId) {
+  if (request.conversationId?.startsWith("group:")) return request.conversationId.slice("group:".length);
+  if (request.conversationId) return request.conversationId;
+  if (defaultGroupId) return defaultGroupId;
+  const firstRecipient = request.recipients[0];
+  if (firstRecipient) return firstRecipient;
+  throw new Error("group id required");
+}
+function defaultEncodeMessage(request, ownerPubkey, defaultGroupId) {
+  const gid = groupIdFor(request, defaultGroupId);
+  return {
+    gid,
+    msg_64: encodeBase64(JSON.stringify({
+      gid,
+      pubkey: ownerPubkey ?? "",
+      created_at: nowSeconds3(),
+      kind: 9,
+      tags: [],
+      content: request.content
+    }))
+  };
+}
+function defaultDecodeMessage(message, ownerPubkey) {
+  let payload = {};
+  try {
+    payload = JSON.parse(decodeBase64(message.msg_64));
+  } catch {
+    payload = { content: decodeBase64(message.msg_64) };
+  }
+  return {
+    id: `cordn:${message.gid}:${message.cursor}`,
+    conversationId: `group:${message.gid}`,
+    senderPubkey: payload.pubkey || ownerPubkey || "",
+    createdAt: payload.created_at ?? message.at,
+    content: payload.content ?? "",
+    status: payload.pubkey && payload.pubkey === ownerPubkey ? "sent" : "received"
+  };
+}
+function relayUrls(options, filter) {
+  return options.relays && options.relays.length > 0 ? options.relays : options.relayPool.selectRelayTier([filter]);
+}
+function parseRelayGroupMessage(event) {
+  try {
+    const parsed = JSON.parse(event.content);
+    if (typeof parsed.gid !== "string" || typeof parsed.cursor !== "number" || typeof parsed.msg_64 !== "string") return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function createCordnRelayCoordinatorClient(options) {
+  const ownerPubkey = getPublicKey2(options.ownerSecretKey);
+  const kind = options.kind ?? CORDN_RELAY_GROUP_MESSAGE_KIND;
+  const cursors = /* @__PURE__ */ new Map();
+  async function fetchGroup(gid, after = 0) {
+    const filter = { kinds: [kind], "#g": [gid] };
+    const records = [];
+    await new Promise((resolve) => {
+      let done = false;
+      let handle;
+      const finish = () => {
+        if (done) return;
+        done = true;
+        clearTimeout(timer);
+        handle?.unsubscribe();
+        resolve();
+      };
+      const timer = setTimeout(finish, options.fetchTimeoutMs ?? 500);
+      handle = options.relayPool.subscribe(
+        [filter],
+        (item) => {
+          if (item === "EOSE") finish();
+          else {
+            const parsed = parseRelayGroupMessage(item);
+            if (parsed && parsed.cursor > after) records.push(parsed);
+          }
+        },
+        relayUrls(options, filter)
+      );
+    });
+    return records.sort((a, b) => a.cursor - b.cursor);
+  }
+  return {
+    async PostGroupMessage(input) {
+      const decoded = JSON.parse(decodeBase64(input.msg_64));
+      const gid = decoded.gid;
+      if (!gid) throw new Error("group id required");
+      const cursor = (cursors.get(gid) ?? 0) + 1;
+      cursors.set(gid, cursor);
+      const at = nowSeconds3();
+      const record = { cursor, gid, msg_64: input.msg_64, at };
+      const event = finalizeEvent2(
+        {
+          kind,
+          created_at: at,
+          tags: [["g", gid], ["p", ownerPubkey]],
+          content: JSON.stringify(record)
+        },
+        options.ownerSecretKey
+      );
+      await Promise.resolve(options.relayPool.publish(event));
+      return { cursor, gid, at };
+    },
+    async FetchGroupMessages(input) {
+      return { messages: await fetchGroup(input.gid, input.after ?? 0) };
+    },
+    async SubscribeGroupMessages(input) {
+      const filter = { kinds: [kind], "#g": [input.gid] };
+      const queue = [];
+      const waiters = [];
+      let closed = false;
+      const push = (message) => {
+        if (message.cursor <= (input.after ?? 0)) return;
+        const waiter = waiters.shift();
+        if (waiter) waiter({ value: message, done: false });
+        else queue.push(message);
+      };
+      const handle = options.relayPool.subscribe(
+        [filter],
+        (item) => {
+          if (item === "EOSE") return;
+          const message = parseRelayGroupMessage(item);
+          if (message) push(message);
+        },
+        relayUrls(options, filter)
+      );
+      return {
+        result: Promise.resolve({ subscribed: true }),
+        stream: {
+          [Symbol.asyncIterator]() {
+            return {
+              next() {
+                const existing = queue.shift();
+                if (existing) return Promise.resolve({ value: existing, done: false });
+                if (closed) return Promise.resolve({ value: void 0, done: true });
+                return new Promise((resolve) => waiters.push(resolve));
+              }
+            };
+          }
+        },
+        async abort() {
+          closed = true;
+          handle.unsubscribe();
+          for (const waiter of waiters.splice(0)) waiter({ value: void 0, done: true });
+        }
+      };
+    }
+  };
+}
+function createCordnDmAdapter(options) {
+  const store = options.store ?? new DmMemoryStore();
+  const live = /* @__PURE__ */ new Map();
+  const ownerPubkey = options.ownerPubkey;
+  if (!options.client && !options.coordinator) {
+    throw new Error("createCordnDmAdapter: client or coordinator is required");
+  }
+  return {
+    async status() {
+      const status = await options.client?.status?.();
+      return {
+        available: status?.available ?? true,
+        ownerPubkey: status?.ownerPubkey ?? ownerPubkey,
+        implementations: ["cordn", ...status?.implementations ?? []],
+        capabilities: ["send", "receive", "subscribe", "history", "contextvm", ...status?.capabilities ?? []]
+      };
+    },
+    conversations(query) {
+      if (options.client) return options.client.conversations(query);
+      return store.conversations(query);
+    },
+    async messages(query) {
+      if (options.client) return options.client.messages(query);
+      const gid = query.conversationId.startsWith("group:") ? query.conversationId.slice("group:".length) : query.conversationId;
+      const fetched = await options.coordinator.FetchGroupMessages({ gid });
+      for (const record of fetched.messages) store.upsertMessage(
+        (options.decodeMessage ?? defaultDecodeMessage)(record, ownerPubkey),
+        [ownerPubkey ?? "", gid]
+      );
+      return store.messages(query);
+    },
+    async send(request) {
+      if (options.client) return options.client.send(request);
+      const encoded = (options.encodeMessage ?? ((req, pk) => defaultEncodeMessage(req, pk, options.defaultGroupId)))(request, ownerPubkey);
+      const posted = await options.coordinator.PostGroupMessage({ msg_64: encoded.msg_64 });
+      const record = { ...posted, msg_64: encoded.msg_64 };
+      const message = store.upsertMessage((options.decodeMessage ?? defaultDecodeMessage)(record, ownerPubkey), [ownerPubkey ?? "", encoded.gid]);
+      return { ok: true, message: { ...message, status: "sent" } };
+    },
+    async subscribe(request, onMessage) {
+      if (options.client) return options.client.subscribe(request, onMessage);
+      const conversationId = request.conversationId ?? (options.defaultGroupId ? `group:${options.defaultGroupId}` : void 0);
+      if (!conversationId) throw new Error("group id required");
+      const gid = conversationId.startsWith("group:") ? conversationId.slice("group:".length) : conversationId;
+      const fetched = await options.coordinator.FetchGroupMessages({ gid });
+      let after = 0;
+      for (const record of fetched.messages) {
+        after = Math.max(after, record.cursor);
+        const message = store.upsertMessage((options.decodeMessage ?? defaultDecodeMessage)(record, ownerPubkey), [ownerPubkey ?? "", gid]);
+        onMessage(message);
+      }
+      const subscription = await options.coordinator.SubscribeGroupMessages({ gid, after });
+      const subscriptionId = `dm-cordn-${++cordnSubCounter}`;
+      live.set(subscriptionId, { abort: () => subscription.abort("dm.unsubscribe"), conversationId });
+      void (async () => {
+        for await (const record of subscription.stream) {
+          const message = store.upsertMessage((options.decodeMessage ?? defaultDecodeMessage)(record, ownerPubkey), [ownerPubkey ?? "", gid]);
+          onMessage(message);
+        }
+      })();
+      return { subscriptionId };
+    },
+    unsubscribe(subscriptionId) {
+      if (options.client) return options.client.unsubscribe(subscriptionId);
+      const sub = live.get(subscriptionId);
+      if (!sub) return { ok: false };
+      live.delete(subscriptionId);
+      void sub.abort();
+      return { ok: true };
+    },
+    close() {
+      for (const [id, sub] of live) {
+        live.delete(id);
+        void sub.abort();
+      }
+      options.client?.close?.();
+      options.coordinator?.close?.();
+    }
+  };
+}
 export {
+  DmMemoryStore,
   createAudioService,
   createBleService,
   createBrowserMediaBridge,
@@ -3670,7 +4461,10 @@ export {
   createCommonService,
   createConfigService,
   createCoordinatedRelay,
+  createCordnDmAdapter,
+  createCordnRelayCoordinatorClient,
   createCvmService,
+  createDmService,
   createHttpUploader,
   createIdentityService,
   createIntentService,
@@ -3678,6 +4472,9 @@ export {
   createLinkService,
   createListsService,
   createMediaService,
+  createNdrDmAdapter,
+  createNdrRelayTransport,
+  createNip17DmAdapter,
   createNotificationService,
   createNotifyService,
   createOutboxService,