@kehto/services 0.5.0 → 0.7.0

package/dist/index.js

@@ -1854,6 +1854,702 @@ function createResourceService(options) {
   return handler;
 }
 
+// src/outbox-service.ts
+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"
+};
+function normalizeFilters(raw) {
+  if (Array.isArray(raw)) {
+    const filters = raw.filter((f) => typeof f === "object" && f !== null);
+    return filters.length > 0 ? filters : null;
+  }
+  if (typeof raw === "object" && raw !== null) return [raw];
+  return null;
+}
+function createOutboxService(options) {
+  if (!options || typeof options.router !== "object" || options.router === null) {
+    throw new Error("createOutboxService: options.router is required");
+  }
+  const { router } = options;
+  const subscriptions = /* @__PURE__ */ new Map();
+  function handleQuery(msg, send) {
+    const m = msg;
+    const id = m.id ?? "";
+    const filters = normalizeFilters(m.filters);
+    if (!filters) {
+      send({ type: "outbox.query.result", id, events: [], relays: {}, error: "invalid filter" });
+      return;
+    }
+    void router.query(filters, m.options).then(
+      (result) => send({
+        type: "outbox.query.result",
+        id,
+        events: result.events,
+        relays: result.relays,
+        ...result.incomplete === void 0 ? {} : { incomplete: result.incomplete },
+        ...result.error === void 0 ? {} : { error: result.error }
+      })
+    ).catch(
+      (err) => send({ type: "outbox.query.result", id, events: [], relays: {}, error: toErrorMessage(err) })
+    );
+  }
+  function handleSubscribe(windowId, msg, send) {
+    const m = msg;
+    const subId = m.subId;
+    if (typeof subId !== "string" || subId.length === 0) return;
+    const subKey = `${windowId}:${subId}`;
+    subscriptions.get(subKey)?.close();
+    subscriptions.delete(subKey);
+    const filters = normalizeFilters(m.filters);
+    if (!filters) {
+      send({ type: "outbox.closed", subId, reason: "invalid filter" });
+      return;
+    }
+    const sink = {
+      event: (event, relay) => send({ type: "outbox.event", subId, event, ...relay === void 0 ? {} : { relay } }),
+      eose: () => send({ type: "outbox.eose", subId }),
+      closed: (reason) => {
+        subscriptions.delete(subKey);
+        send({ type: "outbox.closed", subId, ...reason === void 0 ? {} : { reason } });
+      }
+    };
+    subscriptions.set(subKey, router.subscribe(filters, m.options, sink));
+  }
+  function handleClose(windowId, msg, send) {
+    const m = msg;
+    const subId = m.subId;
+    if (typeof subId !== "string") return;
+    const subKey = `${windowId}:${subId}`;
+    subscriptions.get(subKey)?.close();
+    subscriptions.delete(subKey);
+    send({ type: "outbox.closed", subId });
+  }
+  function handlePublish(msg, send) {
+    const m = msg;
+    const id = m.id ?? "";
+    if (!m.event || typeof m.event !== "object") {
+      send({ type: "outbox.publish.result", id, ok: false, error: "invalid filter" });
+      return;
+    }
+    void router.publish(m.event, m.options).then(
+      (result) => send({
+        type: "outbox.publish.result",
+        id,
+        ok: result.ok,
+        ...result.event === void 0 ? {} : { event: result.event },
+        ...result.eventId === void 0 ? {} : { eventId: result.eventId },
+        ...result.relays === void 0 ? {} : { relays: result.relays },
+        ...result.error === void 0 ? {} : { error: result.error }
+      })
+    ).catch(
+      (err) => send({ type: "outbox.publish.result", id, ok: false, error: toErrorMessage(err) })
+    );
+  }
+  function handleResolveRelays(msg, send) {
+    const m = msg;
+    const id = m.id ?? "";
+    if (!m.target || typeof m.target !== "object") {
+      send({ type: "outbox.resolveRelays.result", id, error: "invalid filter" });
+      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) })
+    );
+  }
+  return {
+    descriptor: OUTBOX_DESCRIPTOR,
+    handleMessage(windowId, message, send) {
+      switch (message.type) {
+        case "outbox.query":
+          handleQuery(message, send);
+          return;
+        case "outbox.subscribe":
+          handleSubscribe(windowId, message, send);
+          return;
+        case "outbox.close":
+          handleClose(windowId, message, send);
+          return;
+        case "outbox.publish":
+          handlePublish(message, send);
+          return;
+        case "outbox.resolveRelays":
+          handleResolveRelays(message, send);
+          return;
+        default:
+          return;
+      }
+    },
+    onWindowDestroyed(windowId) {
+      const prefix = `${windowId}:`;
+      for (const [key, sub] of subscriptions) {
+        if (key.startsWith(prefix)) {
+          sub.close();
+          subscriptions.delete(key);
+        }
+      }
+    }
+  };
+}
+function toErrorMessage(err) {
+  if (err instanceof Error) return err.message;
+  if (typeof err === "string") return err;
+  return "outbox request failed";
+}
+
+// src/relay-pool-outbox-router.ts
+var DEFAULT_QUERY_TIMEOUT_MS = 4e3;
+function defaultRelayAllowed(url) {
+  return typeof url === "string" && (url.startsWith("wss://") || url.startsWith("ws://"));
+}
+function deriveAuthors(filters, optionAuthors) {
+  const authors = /* @__PURE__ */ new Set();
+  for (const filter of filters) {
+    for (const author of filter.authors ?? []) authors.add(author);
+  }
+  for (const author of optionAuthors ?? []) authors.add(author);
+  return [...authors];
+}
+function wantsWriteRelays(direction, strategy) {
+  if (strategy === "outbox") return true;
+  if (strategy === "inbox") return false;
+  return direction === "read";
+}
+function allowed(ctx, urls) {
+  const out = /* @__PURE__ */ new Set();
+  for (const url of urls) {
+    if (ctx.isRelayAllowed(url)) out.add(url);
+  }
+  return [...out];
+}
+async function resolvePlan(ctx, pubkeys, direction, strategy, relayHints) {
+  const useWrite = wantsWriteRelays(direction, strategy);
+  const collected = /* @__PURE__ */ new Set();
+  const missingAuthors = [];
+  let sawNip65 = false;
+  if (pubkeys.length > 0) {
+    const lists = await ctx.loadRelayLists(pubkeys);
+    for (const pubkey of pubkeys) {
+      const entry = lists.get(pubkey);
+      const relays2 = entry ? useWrite ? entry.write : entry.read : void 0;
+      if (relays2 && relays2.length > 0) {
+        sawNip65 = true;
+        for (const url of relays2) collected.add(url);
+      } else {
+        missingAuthors.push(pubkey);
+      }
+    }
+  }
+  for (const url of relayHints ?? []) collected.add(url);
+  let relays = allowed(ctx, collected);
+  let source;
+  if (relays.length === 0) {
+    relays = allowed(ctx, ctx.fallbackRelays);
+    source = "fallback";
+  } else {
+    source = sawNip65 ? "nip65" : "policy";
+  }
+  const plan = { relays, source };
+  if (missingAuthors.length > 0) plan.missingAuthors = missingAuthors;
+  return plan;
+}
+function recordRelay(collector, id, relayUrl) {
+  let set = collector.relayMap.get(id);
+  if (!set) {
+    set = /* @__PURE__ */ new Set();
+    collector.relayMap.set(id, set);
+  }
+  set.add(relayUrl);
+}
+function admitEvent(ctx, collector, event) {
+  if (collector.seen.has(event.id)) return;
+  collector.verifications.push(
+    ctx.verify(event).then((ok) => {
+      if (ok && !collector.seen.has(event.id)) collector.seen.set(event.id, event);
+      else if (!ok) collector.relayMap.delete(event.id);
+    })
+  );
+}
+function buildCollectResult(collector, timedOut) {
+  const events = [...collector.seen.values()];
+  const relayObj = {};
+  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) {
+  return new Promise((resolve) => {
+    const collector = { seen: /* @__PURE__ */ new Map(), relayMap: /* @__PURE__ */ new Map(), verifications: [] };
+    const handles = [];
+    let eoseCount = 0;
+    let finished = false;
+    let timedOut = false;
+    function finalize() {
+      if (finished) return;
+      finished = true;
+      clearTimeout(timer);
+      for (const handle of handles) {
+        try {
+          handle.unsubscribe();
+        } catch {
+        }
+      }
+      void Promise.all(collector.verifications).then(() => resolve(buildCollectResult(collector, timedOut)));
+    }
+    const timer = setTimeout(() => {
+      timedOut = true;
+      finalize();
+    }, timeoutMs);
+    for (const relayUrl of relayUrls) {
+      handles.push(relayPoolSubscribe(ctx, filters, relayUrl, (item) => {
+        if (finished) return;
+        if (item === "EOSE") {
+          eoseCount += 1;
+          if (eoseCount >= relayUrls.length) finalize();
+          return;
+        }
+        recordRelay(collector, item.id, relayUrl);
+        admitEvent(ctx, collector, item);
+      }));
+    }
+    if (relayUrls.length === 0) finalize();
+  });
+}
+function relayPoolSubscribe(ctx, filters, relayUrl, cb) {
+  return ctx.relayPool.subscribe(filters, [relayUrl], cb);
+}
+async function queryImpl(ctx, filters, options) {
+  if (!ctx.relayPool.isAvailable()) {
+    return { events: [], relays: {}, incomplete: true, error: "relay list unavailable" };
+  }
+  const strategy = options?.strategy ?? "auto";
+  const authors = deriveAuthors(filters, options?.authors);
+  const plan = await resolvePlan(ctx, authors, "read", strategy, options?.relays);
+  if (plan.relays.length === 0) {
+    return { events: [], relays: {}, incomplete: true, error: "relay list unavailable" };
+  }
+  const timeoutMs = options?.timeoutMs ?? ctx.defaultTimeoutMs;
+  const collected = await collectFromRelays(ctx, filters, plan.relays, timeoutMs);
+  const incomplete = collected.incomplete || (plan.missingAuthors?.length ?? 0) > 0;
+  let events = collected.events;
+  if (options?.limit !== void 0 && events.length > options.limit) {
+    events = [...events].sort((a, b) => b.created_at - a.created_at).slice(0, options.limit);
+  }
+  const result = { events, relays: collected.relayMap };
+  if (incomplete) result.incomplete = true;
+  return result;
+}
+function closeLiveSub(sub) {
+  for (const handle of sub.handles) {
+    try {
+      handle.unsubscribe();
+    } catch {
+    }
+  }
+  sub.handles.length = 0;
+}
+function attachLiveRelay(ctx, sub, filters, relayUrl, live, sink) {
+  sub.handles.push(relayPoolSubscribe(ctx, filters, relayUrl, (item) => {
+    if (sub.closed) return;
+    if (item === "EOSE") {
+      sub.eoseCount += 1;
+      if (!sub.eoseSent && sub.eoseCount >= sub.relayCount) {
+        sub.eoseSent = true;
+        sink.eose();
+        if (!live) {
+          sub.closed = true;
+          closeLiveSub(sub);
+          sink.closed();
+        }
+      }
+      return;
+    }
+    if (sub.seen.has(item.id)) return;
+    void ctx.verify(item).then((ok) => {
+      if (!ok || sub.closed || sub.seen.has(item.id)) return;
+      sub.seen.add(item.id);
+      sink.event(item, relayUrl);
+    });
+  }));
+}
+function startSubscription(ctx, filters, options, sink) {
+  const live = options?.live ?? true;
+  const strategy = options?.strategy ?? "auto";
+  const authors = deriveAuthors(filters, options?.authors);
+  const sub = { handles: [], seen: /* @__PURE__ */ new Set(), closed: false, eoseCount: 0, relayCount: 0, eoseSent: false };
+  void resolvePlan(ctx, authors, "read", strategy, options?.relays).then((plan) => {
+    if (sub.closed) return;
+    if (plan.relays.length === 0) {
+      sink.closed("relay list unavailable");
+      return;
+    }
+    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");
+  });
+  return {
+    close() {
+      if (sub.closed) return;
+      sub.closed = true;
+      closeLiveSub(sub);
+    }
+  };
+}
+async function resolvePublishTargets(ctx, signed, options) {
+  const strategy = options?.strategy ?? "auto";
+  const targets = /* @__PURE__ */ new Set();
+  const authorPlan = await resolvePlan(ctx, [signed.pubkey], "read", strategy === "inbox" ? "auto" : "outbox");
+  for (const url of authorPlan.relays) targets.add(url);
+  if (options?.targetAuthors && options.targetAuthors.length > 0) {
+    const inboxPlan = await resolvePlan(ctx, options.targetAuthors, "write", "inbox");
+    for (const url of inboxPlan.relays) targets.add(url);
+  }
+  for (const url of options?.relays ?? []) targets.add(url);
+  return allowed(ctx, targets);
+}
+async function publishImpl(ctx, template, options) {
+  if (!ctx.signEvent) return { ok: false, error: "publish denied" };
+  if (!ctx.relayPool.isAvailable()) return { ok: false, error: "relay list unavailable" };
+  let signed;
+  try {
+    signed = await ctx.signEvent(template);
+  } catch (err) {
+    return { ok: false, error: err instanceof Error ? err.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" };
+  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" };
+  }
+  const ok = Object.values(relays).some(Boolean);
+  const result = { ok, event: signed, eventId: signed.id, relays };
+  if (!ok) result.error = "publish denied";
+  return result;
+}
+function createRelayPoolOutboxRouter(options) {
+  if (!options || typeof options.relayPool !== "object" || options.relayPool === null) {
+    throw new Error("createRelayPoolOutboxRouter: options.relayPool is required");
+  }
+  if (typeof options.loadRelayLists !== "function") {
+    throw new Error("createRelayPoolOutboxRouter: options.loadRelayLists is required");
+  }
+  if (!Array.isArray(options.fallbackRelays)) {
+    throw new Error("createRelayPoolOutboxRouter: options.fallbackRelays is required");
+  }
+  const verifyEvent = options.verifyEvent;
+  const ctx = {
+    relayPool: options.relayPool,
+    loadRelayLists: options.loadRelayLists,
+    fallbackRelays: options.fallbackRelays,
+    signEvent: options.signEvent,
+    isRelayAllowed: options.isRelayAllowed ?? defaultRelayAllowed,
+    defaultTimeoutMs: options.defaultTimeoutMs ?? DEFAULT_QUERY_TIMEOUT_MS,
+    async verify(event) {
+      if (!verifyEvent) return true;
+      try {
+        return await verifyEvent(event);
+      } catch {
+        return false;
+      }
+    }
+  };
+  return {
+    query: (filters, queryOptions) => queryImpl(ctx, filters, queryOptions),
+    subscribe: (filters, subscribeOptions, sink) => startSubscription(ctx, filters, subscribeOptions, sink),
+    publish: (template, publishOptions) => publishImpl(ctx, template, publishOptions),
+    resolveRelays: (target) => {
+      const pubkeys = target.authors ?? (target.pubkey ? [target.pubkey] : []);
+      return resolvePlan(ctx, pubkeys, target.direction ?? "read", target.strategy ?? "auto");
+    }
+  };
+}
+function normalizePublishResult(res, relayUrls) {
+  const out = {};
+  if (res && typeof res === "object") {
+    for (const url of relayUrls) out[url] = res[url] ?? false;
+  } else {
+    for (const url of relayUrls) out[url] = true;
+  }
+  return out;
+}
+
+// src/upload-service.ts
+var UPLOAD_SERVICE_VERSION = "1.0.0";
+var UPLOAD_DESCRIPTOR = {
+  name: "upload",
+  version: UPLOAD_SERVICE_VERSION,
+  description: "NAP-UPLOAD shell-mediated file/blob upload \u2014 upload/status with progress pushes"
+};
+function createUploadService(options) {
+  if (!options || typeof options.uploader !== "object" || options.uploader === null) {
+    throw new Error("createUploadService: options.uploader is required");
+  }
+  const { uploader } = options;
+  const generateId2 = options.generateId ?? (() => crypto.randomUUID());
+  const now = options.now ?? (() => Date.now());
+  const entries = /* @__PURE__ */ new Map();
+  function handleUpload(windowId, msg, send) {
+    const m = msg;
+    const id = m.id ?? "";
+    const request = m.request;
+    if (!request || typeof request !== "object" || request.data == null) {
+      send({ type: "upload.upload.result", id, error: "invalid request" });
+      return;
+    }
+    const uploadId = generateId2();
+    const key = `${windowId}:${uploadId}`;
+    entries.set(key, { uploadId });
+    const ctx = {
+      uploadId,
+      windowId,
+      onStatus: (status) => {
+        const stamped = { ...status, uploadId, updatedAt: status.updatedAt || now() };
+        const entry = entries.get(key);
+        if (entry) entry.status = stamped;
+        send({ type: "upload.status.changed", status: stamped });
+      }
+    };
+    void uploader.upload(request, ctx).then((result) => {
+      const stamped = { ...result, uploadId };
+      const entry = entries.get(key);
+      if (entry) entry.status = { ...stamped, updatedAt: now() };
+      send({ type: "upload.upload.result", id, result: stamped });
+    }).catch((err) => {
+      entries.delete(key);
+      send({ type: "upload.upload.result", id, error: toErrorMessage2(err) });
+    });
+  }
+  function handleStatus(windowId, msg, send) {
+    const m = msg;
+    const id = m.id ?? "";
+    const uploadId = m.uploadId;
+    if (typeof uploadId !== "string" || uploadId.length === 0) {
+      send({ type: "upload.status.result", id, error: "invalid uploadId" });
+      return;
+    }
+    const tracked = entries.get(`${windowId}:${uploadId}`)?.status;
+    if (tracked) {
+      send({ type: "upload.status.result", id, status: tracked });
+      return;
+    }
+    if (uploader.status) {
+      void uploader.status(uploadId).then(
+        (status) => send(
+          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) })
+      );
+      return;
+    }
+    send({ type: "upload.status.result", id, error: "unknown upload" });
+  }
+  return {
+    descriptor: UPLOAD_DESCRIPTOR,
+    handleMessage(windowId, message, send) {
+      switch (message.type) {
+        case "upload.upload":
+          handleUpload(windowId, message, send);
+          return;
+        case "upload.status":
+          handleStatus(windowId, message, send);
+          return;
+        default:
+          return;
+      }
+    },
+    onWindowDestroyed(windowId) {
+      const prefix = `${windowId}:`;
+      for (const [key, entry] of entries) {
+        if (key.startsWith(prefix)) {
+          uploader.cancel?.(entry.uploadId);
+          entries.delete(key);
+        }
+      }
+    }
+  };
+}
+function toErrorMessage2(err) {
+  if (err instanceof Error) return err.message;
+  if (typeof err === "string") return err;
+  return "upload request failed";
+}
+
+// src/http-uploader.ts
+var KIND_NIP98 = 27235;
+var KIND_BLOSSOM_AUTH = 24242;
+var BLOSSOM_AUTH_TTL_S = 3600;
+function createHttpUploader(options) {
+  if (!options || typeof options.signEvent !== "function") {
+    throw new Error("createHttpUploader: options.signEvent is required");
+  }
+  const rails = options.rails ?? {};
+  const signEvent = options.signEvent;
+  const fetchFn = options.fetch ?? fetch;
+  const digest = options.digestSha256 ?? defaultDigestSha256;
+  const nowS = options.now ?? (() => Math.floor(Date.now() / 1e3));
+  const defaultRail = options.defaultRail ?? firstConfiguredRail(rails);
+  async function upload(request, ctx) {
+    const rail = request.rail ?? defaultRail;
+    const config = rail === "nip96" ? rails.nip96 : rail === "blossom" ? rails.blossom : void 0;
+    if (rail !== "nip96" && rail !== "blossom") {
+      return failed(ctx.uploadId, rail ?? "unknown", "unsupported rail");
+    }
+    const server = config?.servers?.[0];
+    if (!server) {
+      return failed(ctx.uploadId, rail, "no server configured");
+    }
+    const bytes = await toBytes(request.data);
+    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);
+    }
+  }
+  return { upload };
+}
+async function uploadNip96(args) {
+  const { request, ctx, server, bytes, sha256, signEvent, fetchFn, nowS } = args;
+  const auth = await signEvent({
+    kind: KIND_NIP98,
+    created_at: nowS(),
+    content: "",
+    tags: [
+      ["u", server],
+      ["method", "POST"],
+      ["payload", sha256]
+    ]
+  });
+  const form = new FormData();
+  form.append("file", new Blob([bytesToArrayBuffer(bytes)], { type: request.mimeType }), request.filename ?? "file");
+  if (request.caption !== void 0) form.append("caption", request.caption);
+  if (request.mimeType !== void 0) form.append("content_type", request.mimeType);
+  if (request.noTransform) form.append("no_transform", "true");
+  const res = await fetchFn(server, {
+    method: "POST",
+    headers: { Authorization: nostrAuthHeader(auth) },
+    body: form
+  });
+  if (!res.ok) {
+    return failed(ctx.uploadId, "nip96", `server rejected (HTTP ${res.status})`, sha256);
+  }
+  const body = await res.json();
+  if (body.status === "error") {
+    return failed(ctx.uploadId, "nip96", body.message ?? "upload failed", sha256);
+  }
+  const tags = body.nip94_event?.tags ?? [];
+  return fromNip94Tags(ctx.uploadId, "nip96", tags, bytes.byteLength, sha256);
+}
+function fromNip94Tags(uploadId, rail, tags, fallbackSize, fallbackSha) {
+  const get = (name) => tags.find((t) => t[0] === name)?.[1];
+  const url = get("url");
+  const result = {
+    ok: Boolean(url),
+    uploadId,
+    status: url ? "complete" : "failed",
+    rail,
+    sha256: get("x") ?? fallbackSha,
+    nip94: tags
+  };
+  if (url) result.url = url;
+  const ox = get("ox");
+  if (ox) result.originalSha256 = ox;
+  const size = get("size");
+  result.size = size ? Number(size) : fallbackSize;
+  const m = get("m");
+  if (m) result.mimeType = m;
+  const dim = parseDimensions(get("dim"));
+  if (dim) result.dimensions = dim;
+  const blurhash = get("blurhash");
+  if (blurhash) result.blurhash = blurhash;
+  if (!url) result.error = "server returned no url";
+  return result;
+}
+async function uploadBlossom(args) {
+  const { request, ctx, server, bytes, sha256, signEvent, fetchFn, nowS } = args;
+  const auth = await signEvent({
+    kind: KIND_BLOSSOM_AUTH,
+    created_at: nowS(),
+    content: `Upload ${request.filename ?? "file"}`,
+    tags: [
+      ["t", "upload"],
+      ["x", sha256],
+      ["expiration", String(nowS() + BLOSSOM_AUTH_TTL_S)]
+    ]
+  });
+  const endpoint = `${trimTrailingSlash(server)}/upload`;
+  const headers = { Authorization: nostrAuthHeader(auth) };
+  if (request.mimeType) headers["Content-Type"] = request.mimeType;
+  const res = await fetchFn(endpoint, {
+    method: "PUT",
+    headers,
+    body: bytesToArrayBuffer(bytes)
+  });
+  if (!res.ok) {
+    return failed(ctx.uploadId, "blossom", `server rejected (HTTP ${res.status})`, sha256);
+  }
+  const blob = await res.json();
+  if (!blob.url) {
+    return failed(ctx.uploadId, "blossom", "server returned no url", sha256);
+  }
+  const result = {
+    ok: true,
+    uploadId: ctx.uploadId,
+    status: "complete",
+    rail: "blossom",
+    url: blob.url,
+    sha256: blob.sha256 ?? sha256,
+    size: blob.size ?? bytes.byteLength
+  };
+  if (blob.type) result.mimeType = blob.type;
+  return result;
+}
+function failed(uploadId, rail, error, sha256) {
+  return { ok: false, uploadId, status: "failed", rail, error, ...sha256 ? { sha256 } : {} };
+}
+function firstConfiguredRail(rails) {
+  if (rails.nip96?.servers?.length) return "nip96";
+  if (rails.blossom?.servers?.length) return "blossom";
+  return void 0;
+}
+function nostrAuthHeader(event) {
+  return `Nostr ${base64Utf8(JSON.stringify(event))}`;
+}
+function base64Utf8(s) {
+  return btoa(String.fromCharCode(...new TextEncoder().encode(s)));
+}
+function parseDimensions(dim) {
+  if (!dim) return void 0;
+  const m = /^(\d+)x(\d+)$/.exec(dim);
+  if (!m) return void 0;
+  return { width: Number(m[1]), height: Number(m[2]) };
+}
+async function toBytes(data) {
+  if (data instanceof ArrayBuffer) return new Uint8Array(data);
+  return new Uint8Array(await data.arrayBuffer());
+}
+function bytesToArrayBuffer(bytes) {
+  return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+}
+function trimTrailingSlash(url) {
+  return url.endsWith("/") ? url.slice(0, -1) : url;
+}
+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;
+  return "upload failed";
+}
+
 // src/cvm-service.ts
 var CVM_SERVICE_VERSION = "1.0.0";
 var CVM_DESCRIPTOR = {
@@ -1896,7 +2592,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: toErrorMessage(err) })
+      (err) => send({ type: "cvm.discover.result", id, servers: [], error: toErrorMessage4(err) })
     );
   }
   function handleRequest(windowId, msg, send) {
@@ -1912,7 +2608,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: toErrorMessage(err) })
+      (err) => send({ type: "cvm.request.result", id, error: toErrorMessage4(err) })
     );
   }
   function handleClose(windowId, msg, send) {
@@ -1923,7 +2619,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: toErrorMessage(err) }));
+    void transport.close(m.server).then(() => send({ type: "cvm.close.result", id })).catch((err) => send({ type: "cvm.close.result", id, error: toErrorMessage4(err) }));
   }
   return {
     descriptor: CVM_DESCRIPTOR,
@@ -1954,7 +2650,7 @@ function createCvmService(options) {
     }
   };
 }
-function toErrorMessage(err) {
+function toErrorMessage4(err) {
   if (err instanceof Error) return err.message;
   if (typeof err === "string") return err;
   return "cvm request failed";
@@ -1966,13 +2662,17 @@ export {
   createConfigService,
   createCoordinatedRelay,
   createCvmService,
+  createHttpUploader,
   createIdentityService,
   createKeysService,
   createMediaService,
   createNotificationService,
   createNotifyService,
+  createOutboxService,
+  createRelayPoolOutboxRouter,
   createRelayPoolService,
   createResourceService,
-  createThemeService
+  createThemeService,
+  createUploadService
 };
 //# sourceMappingURL=index.js.map