@elisym/sdk 0.25.0 → 0.25.3

package/dist/index.cjs

@@ -98,9 +98,16 @@ var DEFAULTS = {
   // default, not a protocol constant - the transfer is resumable and its own
   // budget, decoupled from the result-wait window.
   IROH_FETCH_TIMEOUT_MS: 3e5,
+  // Ceiling for a single iroh SEED (addFromPath/addBytes/share). Seeding is local
+  // (hash + store-copy + ticket mint), so this is a generous backstop: it bounds
+  // the JS await so a wedged native call surfaces as a thrown error (and triggers a
+  // node reset) instead of an indefinite hang that stalls file delivery.
+  IROH_SEED_TIMEOUT_MS: 12e4,
   // Ceiling for a single Blossom blob upload (PUT /upload). Large blobs (up to
   // LIMITS.MAX_FILE_SIZE) need far more than the 30s used for small media images.
-  BLOSSOM_UPLOAD_TIMEOUT_MS: 3e5
+  BLOSSOM_UPLOAD_TIMEOUT_MS: 3e5,
+  // Ceiling for a single encrypted Blossom blob download (GET). Same budget as upload.
+  BLOSSOM_FETCH_TIMEOUT_MS: 3e5
 };
 var LIMITS = {
   MAX_INPUT_LENGTH: 1e5,
@@ -125,6 +132,12 @@ var LIMITS = {
   // providers may lower it per deployment.
   MAX_FILE_SIZE: 1073741824,
   // 1 GiB
+  // Cap for the ENCRYPTED Blossom path (web/SDK). The encrypt-then-upload flow is
+  // whole-buffer in WebCrypto + BlossomService (~3x file-size peak RAM), so this is
+  // deliberately far below MAX_FILE_SIZE to stay safe in a browser tab; larger files
+  // use iroh. The relay enforces a ~128 MiB server-side backstop.
+  MAX_BLOSSOM_ENCRYPTED_BYTES: 104857600,
+  // 100 MiB
   MAX_TIMEOUT_SECS: 600,
   // Upper bound for execution budgets (`max_execution_secs` / `execution_timeout_secs`).
   // Distinct from MAX_TIMEOUT_SECS (the result-wait cap): execution budgets may be
@@ -1211,6 +1224,17 @@ var BlossomService = class {
     this.serverUrl = serverUrl;
     this.fallback = fallback;
   }
+  /**
+   * The content-addressed GET URL for a blob, derivable from its sha256 BEFORE
+   * upload (BUD-01: `<serverUrl>/<sha256>`, no extension for our octet-stream
+   * ciphertext uploads - same form `delete` addresses by). Lets a caller build a
+   * complete attachment descriptor and defer the actual byte upload (the descriptor
+   * is submitted first, the bytes PUT later). `upload()` re-verifies the server
+   * returns this exact url.
+   */
+  contentUrl(sha256) {
+    return `${this.serverUrl}/${sha256}`;
+  }
   /**
    * Upload a file to the Blossom server, returning its descriptor. On any failure, falls
    * back to the configured uploader (if any) and returns a normalized descriptor with
@@ -1262,6 +1286,62 @@ var BlossomService = class {
       clearTimeout(timer);
     }
   }
+  /**
+   * Download a public blob (BUD-01 GET, no auth). Bounds memory on the ACTUAL streamed bytes (never
+   * the declared Content-Length) and verifies the sha256 when `expectedSha256` is given. Browser-safe.
+   */
+  async download(url, opts = {}) {
+    const maxBytes = opts.maxBytes ?? LIMITS.MAX_FILE_SIZE;
+    const controller = new AbortController();
+    const timer = setTimeout(
+      () => controller.abort(),
+      opts.timeoutMs ?? DEFAULTS.BLOSSOM_FETCH_TIMEOUT_MS
+    );
+    try {
+      const res = await fetch(url, { signal: controller.signal });
+      if (!res.ok) {
+        throw new Error(`Download failed: ${res.status} ${res.statusText}`);
+      }
+      const declared = Number(res.headers.get("content-length"));
+      if (Number.isFinite(declared) && declared > maxBytes) {
+        throw new Error(`Blob too large: ${declared} bytes exceeds limit of ${maxBytes}.`);
+      }
+      if (!res.body) {
+        throw new Error("Download response has no body.");
+      }
+      const reader = res.body.getReader();
+      const chunks = [];
+      let total = 0;
+      let chunk = await reader.read();
+      while (!chunk.done) {
+        total += chunk.value.byteLength;
+        if (total > maxBytes) {
+          await reader.cancel();
+          throw new Error(`Blob exceeds limit of ${maxBytes} bytes.`);
+        }
+        chunks.push(chunk.value);
+        chunk = await reader.read();
+      }
+      const bytes = new Uint8Array(total);
+      let offset = 0;
+      for (const c of chunks) {
+        bytes.set(c, offset);
+        offset += c.byteLength;
+      }
+      if (opts.expectedSha256 !== void 0) {
+        const digest = await crypto.subtle.digest("SHA-256", bytes);
+        const hashHex = [...new Uint8Array(digest)].map((b) => b.toString(16).padStart(2, "0")).join("");
+        if (hashHex !== opts.expectedSha256) {
+          throw new Error(
+            `Download integrity check failed: got ${hashHex}, expected ${opts.expectedSha256}.`
+          );
+        }
+      }
+      return bytes;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
   async uploadToBlossom(identity, bytes, hashHex, mime) {
     const contentType = mime || "application/octet-stream";
     const authHeader = this.authHeader(identity, "upload", hashHex);
@@ -1393,6 +1473,9 @@ function parseCapabilityEvent(event, network) {
   if (card.inputMime !== void 0 && (typeof card.inputMime !== "string" || card.inputMime.length > 255) || card.outputMime !== void 0 && (typeof card.outputMime !== "string" || card.outputMime.length > 255)) {
     return null;
   }
+  if (card.inputText !== void 0 && !["required", "optional", "none"].includes(card.inputText)) {
+    card.inputText = void 0;
+  }
   if (card.payment?.job_price !== null && card.payment?.job_price !== void 0 && (!Number.isInteger(card.payment.job_price) || card.payment.job_price < 0)) {
     return null;
   }
@@ -1977,6 +2060,26 @@ var FileTransportSchema = zod.z.discriminatedUnion("kind", [
     kind: zod.z.literal("iroh"),
     /** Opaque iroh `BlobTicket` string. Parsed into a real ticket only at fetch time. */
     ticket: zod.z.string().min(1).max(MAX_TICKET_LENGTH)
+  }),
+  zod.z.object({
+    kind: zod.z.literal("blossom"),
+    /** Public HTTP(S) URL of the CIPHERTEXT blob on a Blossom relay. */
+    url: zod.z.string().url().max(2048),
+    /** sha256 (lowercase hex) of the ciphertext - what the relay stores and addresses. */
+    sha256: zod.z.string().regex(/^[0-9a-f]{64}$/),
+    /**
+     * Hybrid-encryption parameters. The file bytes are AES-256-GCM encrypted with a random
+     * content key; that key is NIP-44-wrapped to the recipient. `name`/`mime`/`size` on the
+     * attachment describe the PLAINTEXT and live only inside the (encrypted) envelope - never
+     * sent to the relay (the relay only ever sees opaque ciphertext).
+     */
+    enc: zod.z.object({
+      alg: zod.z.literal("AES-256-GCM"),
+      /** base64 12-byte GCM IV (non-secret). */
+      iv: zod.z.string().min(1).max(64),
+      /** NIP-44-wrapped content key. */
+      key: zod.z.string().min(1).max(2048)
+    })
   })
 ]);
 var FileAttachmentSchema = zod.z.object({
@@ -1985,22 +2088,76 @@ var FileAttachmentSchema = zod.z.object({
   /** Declared size in bytes (display/hint only; enforcement is on actual streamed bytes). */
   size: zod.z.number().int().nonnegative(),
   mime: zod.z.string().min(1).max(255),
-  /** Ordered by sender preference; at least one. */
-  transports: zod.z.array(FileTransportSchema).min(1),
+  /**
+   * Ordered by sender preference; at least one KNOWN transport. Parsed leniently: unknown
+   * transport `kind`s are dropped (not rejected) so adding a new transport never makes an older
+   * decoder throw away the whole envelope - it just ignores the kinds it doesn't know and uses
+   * the ones it does. At least one known transport must survive, else the attachment is invalid.
+   */
+  transports: zod.z.array(zod.z.unknown()).transform(
+    (arr) => arr.flatMap((t) => {
+      const parsed = FileTransportSchema.safeParse(t);
+      return parsed.success ? [parsed.data] : [];
+    })
+  ).refine((arr) => arr.length >= 1, { message: "attachment has no known transport" }),
   /** Optional provider hint (unix seconds) for when seeding may stop. */
   seedingExpiresAt: zod.z.number().int().nonnegative().optional()
 });
 var JobPayloadEnvelopeSchema = zod.z.object({
   v: zod.z.literal(ENVELOPE_VERSION),
   text: zod.z.string().optional(),
-  attachment: FileAttachmentSchema.optional()
+  // Legacy single attachment - kept (and mirrored from `attachments[0]`) so an old
+  // decoder that doesn't know `attachments` still gets the first file.
+  attachment: FileAttachmentSchema.optional(),
+  // Multiple result/input files. Additive; old decoders strip this unknown key.
+  attachments: zod.z.array(FileAttachmentSchema).optional()
 });
+var ACCEPT_TRANSPORTS_TAG = "accept";
+var KNOWN_TRANSPORT_KINDS = ["iroh", "blossom"];
+function isKnownTransportKind(value) {
+  return KNOWN_TRANSPORT_KINDS.includes(value);
+}
+function buildAcceptTransportsTag(kinds) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [ACCEPT_TRANSPORTS_TAG];
+  for (const kind of kinds) {
+    if (isKnownTransportKind(kind) && !seen.has(kind)) {
+      seen.add(kind);
+      out.push(kind);
+    }
+  }
+  return out;
+}
+function readAcceptedTransports(tags) {
+  const tag = tags.find((t) => t[0] === ACCEPT_TRANSPORTS_TAG);
+  if (tag === void 0) {
+    return void 0;
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const value of tag.slice(1)) {
+    if (isKnownTransportKind(value) && !seen.has(value)) {
+      seen.add(value);
+      out.push(value);
+    }
+  }
+  return out.length > 0 ? out : void 0;
+}
+function attachmentsOf(decoded) {
+  if (decoded.attachments !== void 0 && decoded.attachments.length > 0) {
+    return decoded.attachments;
+  }
+  return decoded.attachment !== void 0 ? [decoded.attachment] : [];
+}
 function encodeJobPayload(payload) {
   const envelope = { v: ENVELOPE_VERSION };
   if (payload.text !== void 0) {
     envelope.text = payload.text;
   }
-  if (payload.attachment !== void 0) {
+  if (payload.attachments !== void 0 && payload.attachments.length > 0) {
+    envelope.attachments = payload.attachments;
+    envelope.attachment = payload.attachments[0];
+  } else if (payload.attachment !== void 0) {
     envelope.attachment = payload.attachment;
   }
   return JSON.stringify(envelope);
@@ -2028,7 +2185,11 @@ function decodeJobPayload(content) {
       `Invalid elisym job payload (v=${JSON.stringify(version)}): ${result.error.message}`
     );
   }
-  return { text: result.data.text, attachment: result.data.attachment };
+  return {
+    text: result.data.text,
+    attachment: result.data.attachment,
+    attachments: result.data.attachments
+  };
 }
 
 // src/services/marketplace.ts
@@ -2097,6 +2258,12 @@ var MarketplaceService = class {
       tags.push(["p", options.providerPubkey]);
       tags.push(["encrypted", "nip44"]);
     }
+    if (options.acceptTransports && options.acceptTransports.length > 0) {
+      const acceptTag = buildAcceptTransportsTag(options.acceptTransports);
+      if (acceptTag.length > 1) {
+        tags.push(acceptTag);
+      }
+    }
     const kind = jobRequestKind(options.kindOffset ?? DEFAULT_KIND_OFFSET);
     const event = nostrTools.finalizeEvent(
       {
@@ -2187,7 +2354,7 @@ var MarketplaceService = class {
       }
       resultDelivered = true;
       try {
-        cb.onResult?.(decoded.text ?? "", ev.id, decoded.attachment);
+        cb.onResult?.(decoded.text ?? "", ev.id, decoded.attachment, attachmentsOf(decoded));
       } catch {
       } finally {
         done();
@@ -2351,8 +2518,8 @@ var MarketplaceService = class {
     );
   }
   /** Submit a job result with NIP-44 encrypted content. Result kind is derived from the request kind. */
-  async submitJobResult(identity, requestEvent, content, amount, attachment) {
-    const hasAttachment = attachment !== void 0;
+  async submitJobResult(identity, requestEvent, content, amount, attachments) {
+    const hasAttachment = attachments !== void 0 && attachments.length > 0;
     if (!content && !hasAttachment) {
       throw new Error("Job result content must not be empty.");
     }
@@ -2366,7 +2533,7 @@ var MarketplaceService = class {
       );
     }
     const shouldEncrypt = isEncrypted(requestEvent);
-    const payload = hasAttachment ? encodeJobPayload({ text: content || void 0, attachment }) : content;
+    const payload = hasAttachment ? encodeJobPayload({ text: content || void 0, attachments }) : content;
     if (shouldEncrypt) {
       const payloadBytes = utf8ByteLength(payload);
       if (payloadBytes > LIMITS.NIP44_MAX_PLAINTEXT_BYTES) {
@@ -2407,11 +2574,11 @@ var MarketplaceService = class {
    * With maxAttempts=3: try, ~1s, try, ~2s, try, throw.
    * Jitter: 0.5x-1.0x of calculated delay.
    */
-  async submitJobResultWithRetry(identity, requestEvent, content, amount, maxAttempts = DEFAULTS.RESULT_RETRY_COUNT, baseDelayMs = DEFAULTS.RESULT_RETRY_BASE_MS, attachment) {
+  async submitJobResultWithRetry(identity, requestEvent, content, amount, maxAttempts = DEFAULTS.RESULT_RETRY_COUNT, baseDelayMs = DEFAULTS.RESULT_RETRY_BASE_MS, attachments) {
     const attempts = Math.max(1, maxAttempts);
     for (let attempt = 0; attempt < attempts; attempt++) {
       try {
-        return await this.submitJobResult(identity, requestEvent, content, amount, attachment);
+        return await this.submitJobResult(identity, requestEvent, content, amount, attachments);
       } catch (e) {
         if (attempt >= attempts - 1) {
           throw e;
@@ -3505,6 +3672,186 @@ var ElisymClient = class {
   }
 };
 
+// src/primitives/file-crypto.ts
+var KEY_BYTES = 32;
+var IV_BYTES = 12;
+function bytesToBase64(bytes) {
+  let bin = "";
+  for (const b of bytes) {
+    bin += String.fromCharCode(b);
+  }
+  return btoa(bin);
+}
+function base64ToBytes(b64) {
+  const bin = atob(b64);
+  const out = new Uint8Array(bin.length);
+  for (let i = 0; i < bin.length; i += 1) {
+    out[i] = bin.charCodeAt(i);
+  }
+  return out;
+}
+async function encryptBytesForRecipient(bytes, senderSk, recipientPubkey) {
+  const rawKey = crypto.getRandomValues(new Uint8Array(KEY_BYTES));
+  const iv = crypto.getRandomValues(new Uint8Array(IV_BYTES));
+  const key = await crypto.subtle.importKey("raw", rawKey, "AES-GCM", false, ["encrypt"]);
+  const ct = await crypto.subtle.encrypt({ name: "AES-GCM", iv, tagLength: 128 }, key, bytes);
+  const wrappedKey = nip44Encrypt(bytesToBase64(rawKey), senderSk, recipientPubkey);
+  return { ciphertext: new Uint8Array(ct), wrappedKey, iv: bytesToBase64(iv) };
+}
+async function decryptBytesFromSender(ciphertext, wrappedKey, iv, receiverSk, senderPubkey) {
+  const rawKey = base64ToBytes(nip44Decrypt(wrappedKey, receiverSk, senderPubkey));
+  const key = await crypto.subtle.importKey("raw", rawKey, "AES-GCM", false, ["decrypt"]);
+  const pt = await crypto.subtle.decrypt(
+    { name: "AES-GCM", iv: base64ToBytes(iv), tagLength: 128 },
+    key,
+    ciphertext
+  );
+  return new Uint8Array(pt);
+}
+
+// src/transport/blossom-transport.ts
+var AES_GCM_TAG_BYTES = 16;
+function createBlossomTransport(opts) {
+  const { blossom, identity } = opts;
+  return {
+    async seedBytes({ bytes, recipientPubkey }) {
+      if (bytes.byteLength > LIMITS.MAX_BLOSSOM_ENCRYPTED_BYTES) {
+        throw new Error(
+          `File too large for encrypted Blossom: ${bytes.byteLength} bytes exceeds ${LIMITS.MAX_BLOSSOM_ENCRYPTED_BYTES}.`
+        );
+      }
+      const { ciphertext, wrappedKey, iv } = await encryptBytesForRecipient(
+        bytes,
+        identity.secretKey,
+        recipientPubkey
+      );
+      const blob = new Blob([ciphertext], { type: "application/octet-stream" });
+      const descriptor = await blossom.upload(identity, blob);
+      if (descriptor.provider !== "blossom") {
+        throw new Error("Blossom upload fell back to a non-content-addressed provider.");
+      }
+      return {
+        kind: "blossom",
+        url: descriptor.url,
+        sha256: descriptor.sha256,
+        enc: { alg: "AES-256-GCM", iv, key: wrappedKey }
+      };
+    },
+    async fetchToBytes({ transport, senderPubkey, maxBytes }) {
+      const plaintextCap = maxBytes ?? LIMITS.MAX_BLOSSOM_ENCRYPTED_BYTES;
+      const ciphertext = await blossom.download(transport.url, {
+        maxBytes: plaintextCap + AES_GCM_TAG_BYTES,
+        expectedSha256: transport.sha256
+      });
+      return decryptBytesFromSender(
+        ciphertext,
+        transport.enc.key,
+        transport.enc.iv,
+        identity.secretKey,
+        senderPubkey
+      );
+    }
+  };
+}
+
+// src/transport/file-jobs.ts
+async function sha256Hex(bytes) {
+  const digest = await crypto.subtle.digest("SHA-256", bytes);
+  return [...new Uint8Array(digest)].map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+var EXECUTABLE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".exe",
+  ".dll",
+  ".bat",
+  ".cmd",
+  ".com",
+  ".msi",
+  ".sh",
+  ".app",
+  ".scr",
+  ".ps1"
+]);
+var EXECUTABLE_MIMES = /* @__PURE__ */ new Set([
+  "application/x-msdownload",
+  "application/x-msdos-program",
+  "application/x-sh",
+  "application/x-executable",
+  "application/vnd.microsoft.portable-executable",
+  "application/x-mach-binary"
+]);
+function looksExecutable(name, type) {
+  const dot = name.lastIndexOf(".");
+  const ext = dot >= 0 ? name.slice(dot).toLowerCase() : "";
+  return EXECUTABLE_EXTENSIONS.has(ext) || EXECUTABLE_MIMES.has(type);
+}
+async function prepareEncryptedFileInput(args) {
+  const { file, providerPubkey, identity, blossom } = args;
+  const name = file.name ?? "upload";
+  if (looksExecutable(name, file.type)) {
+    throw new Error("Refusing to upload an executable file.");
+  }
+  const bytes = new Uint8Array(await file.arrayBuffer());
+  if (bytes.byteLength > LIMITS.MAX_BLOSSOM_ENCRYPTED_BYTES) {
+    throw new Error(
+      `File too large for the encrypted-Blossom transport: ${bytes.byteLength} bytes (max ${LIMITS.MAX_BLOSSOM_ENCRYPTED_BYTES}).`
+    );
+  }
+  const { ciphertext, wrappedKey, iv } = await encryptBytesForRecipient(
+    bytes,
+    identity.secretKey,
+    providerPubkey
+  );
+  const sha256 = await sha256Hex(ciphertext);
+  const member = {
+    kind: "blossom",
+    url: blossom.contentUrl(sha256),
+    sha256,
+    enc: { alg: "AES-256-GCM", iv, key: wrappedKey }
+  };
+  const attachment = {
+    name,
+    size: bytes.byteLength,
+    mime: file.type || "application/octet-stream",
+    transports: [member]
+  };
+  const upload = async () => {
+    const descriptor = await blossom.upload(
+      identity,
+      new Blob([ciphertext], { type: "application/octet-stream" })
+    );
+    if (descriptor.provider !== "blossom") {
+      throw new Error("Blossom upload fell back to a non-content-addressed provider.");
+    }
+    if (descriptor.sha256 !== sha256 || descriptor.url !== member.url) {
+      throw new Error(
+        `Blossom upload descriptor mismatch (expected ${member.url} / ${sha256}, got ${descriptor.url} / ${descriptor.sha256}).`
+      );
+    }
+  };
+  return { attachment, upload };
+}
+async function buildEncryptedFileInput(args) {
+  const prepared = await prepareEncryptedFileInput(args);
+  await prepared.upload();
+  return prepared.attachment;
+}
+async function fetchEncryptedFileOutput(args) {
+  const { attachment, providerPubkey, identity, blossom, maxBytes } = args;
+  const member = attachment.transports.find(
+    (t) => t.kind === "blossom"
+  );
+  if (member === void 0) {
+    throw new Error("Attachment has no blossom transport.");
+  }
+  const transport = createBlossomTransport({ blossom, identity });
+  const bytes = await transport.fetchToBytes({
+    transport: member,
+    senderPubkey: providerPubkey,
+    maxBytes
+  });
+  return { bytes, name: attachment.name, mime: attachment.mime };
+}
+
 // src/services/jobErrors.ts
 var AGENT_UNAVAILABLE_MARKERS = [
   "agent temporarily unavailable",
@@ -4076,6 +4423,7 @@ function makeCensor() {
   };
 }
 
+exports.ACCEPT_TRANSPORTS_TAG = ACCEPT_TRANSPORTS_TAG;
 exports.BlossomService = BlossomService;
 exports.BoundedSet = BoundedSet;
 exports.DEFAULTS = DEFAULTS;
@@ -4122,6 +4470,9 @@ exports.assertExpiry = assertExpiry;
 exports.assertLamports = assertLamports;
 exports.assetByKey = assetByKey;
 exports.assetKey = assetKey;
+exports.attachmentsOf = attachmentsOf;
+exports.buildAcceptTransportsTag = buildAcceptTransportsTag;
+exports.buildEncryptedFileInput = buildEncryptedFileInput;
 exports.buildPaymentInstructions = buildPaymentInstructions;
 exports.calculateProtocolFee = calculateProtocolFee;
 exports.classifyJobError = classifyJobError;
@@ -4130,13 +4481,17 @@ exports.clearProtocolConfigCache = clearProtocolConfigCache;
 exports.clearQuickVerifyCache = clearQuickVerifyCache;
 exports.compareAgentsByRank = compareAgentsByRank;
 exports.computeRankKey = computeRankKey;
+exports.createBlossomTransport = createBlossomTransport;
 exports.createPaymentRequestWithOnchainConfig = createPaymentRequestWithOnchainConfig;
 exports.createSlidingWindowLimiter = createSlidingWindowLimiter;
 exports.decodeJobPayload = decodeJobPayload;
+exports.decryptBytesFromSender = decryptBytesFromSender;
 exports.encodeJobPayload = encodeJobPayload;
+exports.encryptBytesForRecipient = encryptBytesForRecipient;
 exports.estimateNetworkBaseline = estimateNetworkBaseline;
 exports.estimatePriorityFeeMicroLamports = estimatePriorityFeeMicroLamports;
 exports.estimateSolFeeLamports = estimateSolFeeLamports;
+exports.fetchEncryptedFileOutput = fetchEncryptedFileOutput;
 exports.formatAssetAmount = formatAssetAmount;
 exports.formatFeeBreakdown = formatFeeBreakdown;
 exports.formatNetworkBaseline = formatNetworkBaseline;
@@ -4152,6 +4507,8 @@ exports.nip44Encrypt = nip44Encrypt;
 exports.parseAssetAmount = parseAssetAmount;
 exports.parsePaymentRequest = parsePaymentRequest;
 exports.pickPercentileFee = pickPercentileFee;
+exports.prepareEncryptedFileInput = prepareEncryptedFileInput;
+exports.readAcceptedTransports = readAcceptedTransports;
 exports.resolveAssetFromPaymentRequest = resolveAssetFromPaymentRequest;
 exports.resolveKnownAsset = resolveKnownAsset;
 exports.timeAgo = timeAgo;