@kehto/services 0.6.0 → 0.7.0

package/dist/index.d.ts

@@ -1796,4 +1796,236 @@ interface RelayPoolOutboxRouterOptions {
  */
 declare function createRelayPoolOutboxRouter(options: RelayPoolOutboxRouterOptions): OutboxRouter;
 
-export { type AudioServiceOptions, type AudioSource, type CacheServiceOptions, type ConfigSchemaValidation, type ConfigService, type ConfigServiceOptions, type CoordinatedRelayOptions, type GiftWrapDecryptResult, type HostCacheBridge, type HostDecryptBridge, type HostKeyEvent, type HostKeysBridge, type HostMediaBridge, type IdentityDecryptErrorCode, type IdentityDecryptErrorMessage, type IdentityDecryptMessage, type IdentityDecryptResultMessage, type IdentityServiceOptions, type KeysServiceOptions, type MediaMetadataLike, type MediaPlaybackOwner, type MediaServiceOptions, type MediaSessionCreateOptions, type MediaSessionTarget, type MediaSourceRef, type Notification, type NotificationServiceOptions, type NotifyServiceOptions, type OutboxPublishOptions, type OutboxPublishResult, type OutboxQueryOptions, type OutboxRelayPlan, type OutboxRelayPool, type OutboxResult, type OutboxRouter, type OutboxRouterSubscription, type OutboxServiceOptions, type OutboxStrategy, type OutboxSubscribeOptions, type OutboxSubscriptionSink, type OutboxTarget, type RelayListEntry, type RelayPoolOutboxRouterOptions, type RelayPoolServiceOptions, type ResourceService, type ResourceServiceOptions, type Rumor, type ThemeService, type ThemeServiceOptions, type VerifyEvent, createAudioService, createBrowserMediaBridge, createCacheService, createConfigService, createCoordinatedRelay, createIdentityService, createKeysService, createMediaService, createNotificationService, createNotifyService, createOutboxService, createRelayPoolOutboxRouter, createRelayPoolService, createResourceService, createThemeService };
+/**
+ * upload-service.ts — NAP-UPLOAD (shell-mediated file/blob upload) reference service.
+ *
+ * Shell-side handler for the NAP-UPLOAD wire protocol. It is a pure envelope
+ * router: it validates `upload.*` envelopes, delegates the actual byte transfer
+ * (server selection, rail authorization signing, the HTTP upload) to an injected
+ * {@link Uploader}, and posts the correlated result / status messages back to the
+ * napplet.
+ *
+ * The uploader is injected (options-as-bridge) so this service has no transport
+ * or Nostr dependency and is fully unit-testable. NAP-UPLOAD is deliberately
+ * abstract over the backend — the runtime decides *how* it uploads (NIP-96,
+ * Blossom, …). A concrete HTTP-backed uploader ships alongside as
+ * {@link createHttpUploader}.
+ *
+ * ──────────────────────────── Responsibilities ────────────────────────────
+ *   Inbound:  upload.upload, upload.status
+ *   Outbound: upload.upload.result, upload.status.result, upload.status.changed
+ *
+ * The service owns the `uploadId` (generated per request, scoped to the
+ * requesting napplet), tracks the latest {@link UploadStatus} per upload for
+ * `upload.status` queries, and cleans up on window teardown. The shell owns
+ * consent, policy, server selection, signing, and the HTTP upload — all behind
+ * the {@link Uploader}.
+ *
+ * @example
+ * ```ts
+ * import { createUploadService, createHttpUploader } from '@kehto/services';
+ *
+ * const uploader = createHttpUploader({ rails: { nip96: { servers } }, signEvent });
+ * runtime.registerService('upload', createUploadService({ uploader }));
+ * ```
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Storage rail. `nip96` (NIP-96 HTTP file storage) and `blossom` (Blossom blob
+ * storage) are the first concrete backends; the open string keeps the API
+ * stable as shells add rails (torrents, usenet, …).
+ */
+type UploadRail = 'nip96' | 'blossom' | (string & {});
+/** Lifecycle state of an upload. */
+type UploadState = 'pending' | 'uploading' | 'complete' | 'failed' | 'cancelled';
+/** Pixel dimensions of an uploaded image/video. */
+interface UploadDimensions {
+    width: number;
+    height: number;
+}
+/**
+ * A napplet's upload request. `data` crosses the postMessage boundary by
+ * structured clone — shells never require base64 encoding.
+ */
+interface UploadRequest {
+    /** Storage rail; omit to let the shell pick a configured default. */
+    rail?: UploadRail;
+    /** The bytes to upload. */
+    data: ArrayBuffer | Blob;
+    /** MIME type; inferred from `data` when omitted. */
+    mimeType?: string;
+    /** Suggested filename. */
+    filename?: string;
+    /** Alt text / description for the file event. */
+    caption?: string;
+    /** Request the server not re-encode the file (NIP-96 `no_transform`). */
+    noTransform?: boolean;
+    /** Rail-specific or shell-specific extra metadata. */
+    metadata?: Record<string, unknown>;
+}
+/** A single Nostr tag (NIP-94 / imeta entries are arrays of strings). */
+type NostrTag = string[];
+/** The result of an upload. */
+interface UploadResult {
+    /** Whether the upload succeeded (or is progressing) vs failed/cancelled. */
+    ok: boolean;
+    /** Shell-generated id, scoped to the requesting napplet. */
+    uploadId: string;
+    /** Current lifecycle state. */
+    status: UploadState;
+    /** The rail the shell used. */
+    rail: UploadRail;
+    /** Primary download URL. */
+    url?: string;
+    /** Mirrors / alternative server URLs. */
+    fallbackUrls?: string[];
+    /** Hash of the stored blob (NIP-94 `x`). */
+    sha256?: string;
+    /** Hash before server transforms (NIP-94 `ox`). */
+    originalSha256?: string;
+    /** Size in bytes. */
+    size?: number;
+    /** Stored MIME type. */
+    mimeType?: string;
+    /** Image/video dimensions when known. */
+    dimensions?: UploadDimensions;
+    /** Blurhash placeholder when known. */
+    blurhash?: string;
+    /** Ready-to-attach NIP-94 / imeta tags. */
+    nip94?: NostrTag[];
+    /** Error reason when the upload failed or was cancelled. */
+    error?: string;
+}
+/** A status snapshot for an upload, including progress counters. */
+interface UploadStatus extends UploadResult {
+    /** Bytes sent so far (while uploading). */
+    bytesSent?: number;
+    /** Total bytes to send. */
+    bytesTotal?: number;
+    /** Unix ms timestamp of this status. */
+    updatedAt: number;
+}
+/**
+ * Context handed to an {@link Uploader} for a single upload. Carries the
+ * service-owned `uploadId` and a sink for streaming progress / state changes.
+ */
+interface UploaderContext {
+    /** The service-generated upload id (authoritative; scoped to the napplet). */
+    uploadId: string;
+    /** The napplet window that requested the upload. */
+    windowId: string;
+    /**
+     * Push a status update (progress, or a transition to complete/failed). The
+     * service stamps `uploadId` and `updatedAt` before forwarding to the napplet
+     * as `upload.status.changed`, and records it as the latest tracked status.
+     */
+    onStatus(status: UploadStatus): void;
+}
+/**
+ * Abstract upload backend. Implementors own server selection, rail
+ * authorization signing (NIP-98 for NIP-96, kind 24242 for Blossom), the HTTP
+ * upload, and integrity-hash reporting. The service translates wire envelopes
+ * into these calls and back. A concrete reference implementation ships as
+ * {@link createHttpUploader}.
+ */
+interface Uploader {
+    /** Upload `request.data`, streaming progress through `ctx.onStatus`. */
+    upload(request: UploadRequest, ctx: UploaderContext): Promise<UploadResult>;
+    /** Optional: resolve the latest status for an upload the service is not tracking. */
+    status?(uploadId: string): Promise<UploadStatus | undefined>;
+    /** Optional: abort an in-flight upload (called on window teardown). */
+    cancel?(uploadId: string): void;
+}
+/** Options for {@link createUploadService}. */
+interface UploadServiceOptions {
+    /** The upload backend the shell uses. Required. */
+    uploader: Uploader;
+    /** Generate an upload id; defaults to `crypto.randomUUID()`. */
+    generateId?: () => string;
+    /** Current time in unix ms; defaults to `Date.now()`. */
+    now?: () => number;
+}
+/**
+ * Create the NAP-UPLOAD service handler.
+ *
+ * @param options - Must provide an {@link Uploader}.
+ * @returns A `ServiceHandler` ready for `runtime.registerService('upload', handler)`.
+ * @throws If `options.uploader` is missing.
+ */
+declare function createUploadService(options: UploadServiceOptions): ServiceHandler;
+
+/**
+ * http-uploader.ts — NAP-UPLOAD concrete HTTP-backed {@link Uploader}.
+ *
+ * The reference upload backend for {@link createUploadService}. Implements two
+ * storage rails over HTTP:
+ *
+ * - **NIP-96** — signs a NIP-98 (kind 27235) HTTP-auth event, POSTs the file as
+ *   `multipart/form-data`, and maps the returned NIP-94 event tags into an
+ *   {@link UploadResult}.
+ * - **Blossom** — signs a kind 24242 authorization event, PUTs the raw bytes to
+ *   `<server>/upload`, and maps the returned blob descriptor.
+ *
+ * Signing (`signEvent`) and transport (`fetch`) are injected so the uploader
+ * carries no Nostr or network dependency and is fully unit-testable. The shell
+ * holds the signing key and never exposes it to napplets — the uploader only
+ * receives a signing callback. Server URLs are shell configuration, not napplet
+ * input: a napplet may *hint* a rail, but never a server.
+ *
+ * The configured server URL is used directly as the upload endpoint (the
+ * NIP-96 `api_url` / Blossom base). Hosts that need `.well-known` discovery can
+ * resolve it before constructing the uploader.
+ *
+ * @example
+ * ```ts
+ * const uploader = createHttpUploader({
+ *   rails: { nip96: { servers: ['https://nostr.build/api/v2/nip96/upload'] } },
+ *   signEvent: (tmpl) => signer.signEvent(tmpl),
+ * });
+ * runtime.registerService('upload', createUploadService({ uploader }));
+ * ```
+ *
+ * @packageDocumentation
+ */
+
+/** Per-rail server configuration. The first server is the primary endpoint. */
+interface RailServerConfig {
+    /** Ordered server endpoint URLs; index 0 is primary. */
+    servers: string[];
+}
+/** Storage rails this uploader can serve. */
+interface HttpUploaderRails {
+    /** NIP-96 HTTP file storage. */
+    nip96?: RailServerConfig;
+    /** Blossom blob storage. */
+    blossom?: RailServerConfig;
+}
+/** Signs an event template on the user's behalf (shell holds the key). */
+type SignEvent = (template: EventTemplate) => Promise<NostrEvent>;
+/** Options for {@link createHttpUploader}. */
+interface HttpUploaderOptions {
+    /** Configured rails + their servers. */
+    rails: HttpUploaderRails;
+    /** Rail to use when a request omits one; defaults to the first configured rail. */
+    defaultRail?: UploadRail;
+    /** Signs NIP-98 / Blossom auth events. Required. */
+    signEvent: SignEvent;
+    /** Fetch implementation; defaults to the global `fetch`. */
+    fetch?: typeof fetch;
+    /** Hex SHA-256 of the payload bytes; defaults to Web Crypto. */
+    digestSha256?: (bytes: Uint8Array) => Promise<string>;
+    /** Unix *seconds* clock for event timestamps; defaults to `Date.now()/1000`. */
+    now?: () => number;
+}
+/**
+ * Create the reference HTTP {@link Uploader} (NIP-96 + Blossom rails).
+ *
+ * @param options - Rails, server config, and the injected `signEvent`.
+ * @returns An {@link Uploader} for `createUploadService({ uploader })`.
+ * @throws If `options.signEvent` is missing.
+ */
+declare function createHttpUploader(options: HttpUploaderOptions): Uploader;
+
+export { type AudioServiceOptions, type AudioSource, type CacheServiceOptions, type ConfigSchemaValidation, type ConfigService, type ConfigServiceOptions, type CoordinatedRelayOptions, type GiftWrapDecryptResult, type HostCacheBridge, type HostDecryptBridge, type HostKeyEvent, type HostKeysBridge, type HostMediaBridge, type HttpUploaderOptions, type HttpUploaderRails, type IdentityDecryptErrorCode, type IdentityDecryptErrorMessage, type IdentityDecryptMessage, type IdentityDecryptResultMessage, type IdentityServiceOptions, type KeysServiceOptions, type MediaMetadataLike, type MediaPlaybackOwner, type MediaServiceOptions, type MediaSessionCreateOptions, type MediaSessionTarget, type MediaSourceRef, type NostrTag, type Notification, type NotificationServiceOptions, type NotifyServiceOptions, type OutboxPublishOptions, type OutboxPublishResult, type OutboxQueryOptions, type OutboxRelayPlan, type OutboxRelayPool, type OutboxResult, type OutboxRouter, type OutboxRouterSubscription, type OutboxServiceOptions, type OutboxStrategy, type OutboxSubscribeOptions, type OutboxSubscriptionSink, type OutboxTarget, type RailServerConfig, type RelayListEntry, type RelayPoolOutboxRouterOptions, type RelayPoolServiceOptions, type ResourceService, type ResourceServiceOptions, type Rumor, type SignEvent, type ThemeService, type ThemeServiceOptions, type UploadDimensions, type UploadRail, type UploadRequest, type UploadResult, type UploadServiceOptions, type UploadState, type UploadStatus, type Uploader, type UploaderContext, type VerifyEvent, createAudioService, createBrowserMediaBridge, createCacheService, createConfigService, createCoordinatedRelay, createHttpUploader, createIdentityService, createKeysService, createMediaService, createNotificationService, createNotifyService, createOutboxService, createRelayPoolOutboxRouter, createRelayPoolService, createResourceService, createThemeService, createUploadService };

package/dist/index.js

@@ -2278,6 +2278,278 @@ function normalizePublishResult(res, relayUrls) {
   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 = {
@@ -2320,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: toErrorMessage2(err) })
+      (err) => send({ type: "cvm.discover.result", id, servers: [], error: toErrorMessage4(err) })
     );
   }
   function handleRequest(windowId, msg, send) {
@@ -2336,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: toErrorMessage2(err) })
+      (err) => send({ type: "cvm.request.result", id, error: toErrorMessage4(err) })
     );
   }
   function handleClose(windowId, msg, send) {
@@ -2347,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: toErrorMessage2(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,
@@ -2378,7 +2650,7 @@ function createCvmService(options) {
     }
   };
 }
-function toErrorMessage2(err) {
+function toErrorMessage4(err) {
   if (err instanceof Error) return err.message;
   if (typeof err === "string") return err;
   return "cvm request failed";
@@ -2390,6 +2662,7 @@ export {
   createConfigService,
   createCoordinatedRelay,
   createCvmService,
+  createHttpUploader,
   createIdentityService,
   createKeysService,
   createMediaService,
@@ -2399,6 +2672,7 @@ export {
   createRelayPoolOutboxRouter,
   createRelayPoolService,
   createResourceService,
-  createThemeService
+  createThemeService,
+  createUploadService
 };
 //# sourceMappingURL=index.js.map