@wacando/agent 2.1.0 → 2.2.0

package/packages/wacando/omemo.mjs

@@ -1,9 +1,9 @@
-// Embedded from lbframe/wacando@9f82881d4ee6cfd655727a08883877230917c955 by scripts/embed-wacando.mjs. Do not edit; see provenance.json.
+// Embedded from lbframe/wacando@618922ecaf2213da18949a8b27d343c8767b64c5 by scripts/embed-wacando.mjs. Do not edit; see provenance.json.
 import {
   authenticatedMessageOrigin,
   pepFetchItems,
   pepPublish
-} from "./chunks/chunk-GASYW3SG.mjs";
+} from "./chunks/chunk-53E7SSTF.mjs";
 import {
   BODY_MARKER,
   GCM_IV_BYTES,
@@ -37,8 +37,13 @@ import {
   signerJid,
   signerRole,
   utf8Encode
-} from "./chunks/chunk-OI3RF7TS.mjs";
-import "./chunks/chunk-EIGFLZ2Y.mjs";
+} from "./chunks/chunk-PHGOH4AU.mjs";
+import {
+  ALLOWED_MEDIA_TYPES,
+  MAX_FILE_BYTES,
+  MIN_FILE_BYTES,
+  looksLikePlaintext
+} from "./chunks/chunk-PZDQXGA6.mjs";
 
 // packages/omemo/src/libsignal.ts
 import { jid as parseJid2 } from "@xmpp/jid";
@@ -1076,6 +1081,527 @@ var OmemoTranscriptDecryptor = class {
   }
 };
 
+// packages/omemo/src/file-core.ts
+var FILE_KEY_BYTES = 32;
+var FILE_IV_BYTES = 12;
+var FILE_TAG_BYTES = MIN_FILE_BYTES;
+var MAX_FILE_CIPHERTEXT_BYTES = MAX_FILE_BYTES;
+var MAX_FILE_PLAINTEXT_BYTES = MAX_FILE_CIPHERTEXT_BYTES - FILE_TAG_BYTES;
+var PLAINTEXT_GUARD_ATTEMPTS = 4;
+var FileCryptoError = class extends OmemoError {
+  constructor(reason, message) {
+    super(message);
+    this.reason = reason;
+    this.name = "FileCryptoError";
+  }
+  reason;
+};
+function subtle() {
+  const s = globalThis.crypto?.subtle;
+  if (!s) throw new FileCryptoError("unavailable", "WebCrypto is not available");
+  return s;
+}
+function own(bytes) {
+  return new Uint8Array(bytes);
+}
+var HEX = /^[0-9a-f]*$/;
+function toHex(bytes) {
+  let out = "";
+  for (const b of bytes) out += b.toString(16).padStart(2, "0");
+  return out;
+}
+function fromHex(hex) {
+  const h = hex.toLowerCase();
+  if (h.length % 2 !== 0 || !HEX.test(h))
+    throw new FileCryptoError("invalid_descriptor", "invalid hex");
+  const out = new Uint8Array(h.length / 2);
+  for (let i = 0; i < out.length; i++) out[i] = Number.parseInt(h.slice(i * 2, i * 2 + 2), 16);
+  return out;
+}
+async function fileSha256Hex(bytes) {
+  return toHex(new Uint8Array(await subtle().digest("SHA-256", own(bytes))));
+}
+function checkKeyIv(key2, iv) {
+  if (key2.length !== FILE_KEY_BYTES)
+    throw new FileCryptoError("invalid_descriptor", "file key must be 32 bytes");
+  if (iv.length !== FILE_IV_BYTES)
+    throw new FileCryptoError("invalid_descriptor", "file IV must be 12 bytes");
+}
+function importKey(key2, usage) {
+  return subtle().importKey("raw", own(key2), { name: "AES-GCM" }, false, [usage]);
+}
+async function aesGcmSeal(key2, iv, plaintext) {
+  checkKeyIv(key2, iv);
+  const out = await subtle().encrypt(
+    { name: "AES-GCM", iv: own(iv), tagLength: FILE_TAG_BYTES * 8 },
+    await importKey(key2, "encrypt"),
+    own(plaintext)
+  );
+  return new Uint8Array(out);
+}
+async function aesGcmOpen(key2, iv, sealed) {
+  checkKeyIv(key2, iv);
+  if (sealed.length < FILE_TAG_BYTES)
+    throw new FileCryptoError("authentication_failed", "ciphertext shorter than its tag");
+  let out;
+  try {
+    out = await subtle().decrypt(
+      { name: "AES-GCM", iv: own(iv), tagLength: FILE_TAG_BYTES * 8 },
+      await importKey(key2, "decrypt"),
+      own(sealed)
+    );
+  } catch {
+    throw new FileCryptoError("authentication_failed", "file authentication failed");
+  }
+  return new Uint8Array(out);
+}
+var DEFAULT_SEAL_DEPS = { random: randomBytes, guard: looksLikePlaintext };
+async function sealFresh(plaintext, deps = DEFAULT_SEAL_DEPS) {
+  for (let attempt = 0; attempt < PLAINTEXT_GUARD_ATTEMPTS; attempt++) {
+    const key2 = deps.random(FILE_KEY_BYTES);
+    const iv = deps.random(FILE_IV_BYTES);
+    const ciphertext = await aesGcmSeal(key2, iv, plaintext);
+    if (!deps.guard(ciphertext)) return { ciphertext, key: key2, iv };
+  }
+  throw new FileCryptoError("unavailable", "could not produce a depositable ciphertext");
+}
+
+// packages/omemo/src/file-crypto.ts
+var FILE_MEDIA_TYPES = ALLOWED_MEDIA_TYPES;
+var MAX_FILE_NAME_BYTES = 200;
+var FILE_DOWNLOAD_TIMEOUT_MS = 6e4;
+var NAME_INVISIBLE = new RegExp(
+  "[\\u0000-\\u001f\\u007f-\\u009f\\u00ad\\u061c\\u115f\\u1160\\u180e\\u200b-\\u200f\\u2028-\\u202e\\u2060-\\u206f\\u3164\\ufe00-\\ufe0f\\ufeff\\uffa0]",
+  "g"
+);
+var NAME_RESERVED = /[<>:"|?*]/g;
+var WINDOWS_DEVICE = /^(con|prn|aux|nul|conin\$|conout\$|clock\$|com[0-9\u00b9\u00b2\u00b3]|lpt[0-9\u00b9\u00b2\u00b3])\s*(\..*)?$/i;
+function utf8Length(s) {
+  return new TextEncoder().encode(s).length;
+}
+function cutUtf8(s, max) {
+  let out = "";
+  for (const ch of s) {
+    if (utf8Length(out + ch) > max) break;
+    out += ch;
+  }
+  return out;
+}
+function sanitizeFileName(raw) {
+  let name = raw.normalize("NFC").replace(NAME_INVISIBLE, "");
+  name = name.split(/[/\\]/).pop() ?? "";
+  name = name.replace(NAME_RESERVED, "_").trim();
+  name = name.replace(/^[.\s]+/, "").replace(/[.\s]+$/, "");
+  if (WINDOWS_DEVICE.test(name)) name = `_${name}`;
+  if (utf8Length(name) > MAX_FILE_NAME_BYTES) {
+    const ext = fileExtension(name);
+    const keep = ext && utf8Length(ext) < 32 ? ext : "";
+    name = cutUtf8(
+      name.slice(0, name.length - keep.length),
+      MAX_FILE_NAME_BYTES - utf8Length(keep)
+    );
+    name = name.replace(/[.\s]+$/, "") + keep;
+  }
+  return name === "" ? "file" : name;
+}
+function fileExtension(name) {
+  const lower = name.toLowerCase();
+  if (lower.endsWith(".tar.gz")) return ".tar.gz";
+  const dot = lower.lastIndexOf(".");
+  return dot > 0 ? lower.slice(dot) : "";
+}
+var EXTENSION_TYPES = {
+  "": "text/plain",
+  ".txt": "text/plain",
+  ".text": "text/plain",
+  ".log": "text/plain",
+  ".csv": "text/plain",
+  ".tsv": "text/plain",
+  ".json": "text/plain",
+  ".yaml": "text/plain",
+  ".yml": "text/plain",
+  ".md": "text/markdown",
+  ".markdown": "text/markdown",
+  ".pdf": "application/pdf",
+  ".zip": "application/zip",
+  ".tar.gz": "application/gzip",
+  ".tgz": "application/gzip"
+};
+function startsWith(bytes, sig) {
+  return bytes.length >= sig.length && sig.every((b, i) => bytes[i] === b);
+}
+function isGzipContent(bytes) {
+  if (bytes.length < 10 || !startsWith(bytes, [31, 139, 8])) return false;
+  const flg = bytes[3];
+  const os = bytes[9];
+  return (flg & 224) === 0 && (os <= 13 || os === 255);
+}
+function isText(bytes) {
+  let text;
+  try {
+    text = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+  } catch {
+    return false;
+  }
+  return !/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/.test(text);
+}
+function sniffContent(bytes) {
+  if (startsWith(bytes, [37, 80, 68, 70, 45])) return "application/pdf";
+  if (startsWith(bytes, [80, 75, 3, 4]) || startsWith(bytes, [80, 75, 5, 6]))
+    return "application/zip";
+  if (isGzipContent(bytes)) return "application/gzip";
+  return isText(bytes) ? "text" : null;
+}
+function detectFileType(name, bytes) {
+  const expected = EXTENSION_TYPES[fileExtension(name)];
+  if (!expected) throw new FileCryptoError("type_not_allowed", "file extension not allowed");
+  const sniffed = sniffContent(bytes);
+  if (sniffed === null) throw new FileCryptoError("type_not_allowed", "file content not allowed");
+  const actual = sniffed === "text" && (expected === "text/plain" || expected === "text/markdown") ? expected : sniffed;
+  if (actual !== expected)
+    throw new FileCryptoError("type_mismatch", "file content does not match its extension");
+  return expected;
+}
+async function encryptFile(input) {
+  if (input.bytes.length > MAX_FILE_PLAINTEXT_BYTES)
+    throw new FileCryptoError(
+      "too_large",
+      `files are limited to ${MAX_FILE_PLAINTEXT_BYTES} bytes`
+    );
+  const name = sanitizeFileName(input.name);
+  const mediaType = detectFileType(name, input.bytes);
+  if (input.mediaType !== void 0 && input.mediaType !== mediaType)
+    throw new FileCryptoError("type_mismatch", "declared type does not match the file");
+  const plaintextSha256 = await fileSha256Hex(input.bytes);
+  const { ciphertext, key: key2, iv } = await sealFresh(input.bytes);
+  return {
+    ciphertext,
+    approval: {
+      ciphertextSha256: await fileSha256Hex(ciphertext),
+      sizeBytes: ciphertext.length,
+      mediaType
+    },
+    name,
+    mediaType,
+    plaintextSize: input.bytes.length,
+    plaintextSha256,
+    key: key2,
+    iv
+  };
+}
+async function decryptFile(ciphertext, share, opts = {}) {
+  const { key: key2, iv } = aesgcmSecrets(share.url);
+  return openChecked(ciphertext, share, key2, iv, opts);
+}
+async function openChecked(ciphertext, facts, key2, iv, opts) {
+  if (ciphertext.length > MAX_FILE_CIPHERTEXT_BYTES)
+    throw new FileCryptoError("too_large", "ciphertext over the file limit");
+  if (opts.approvedCiphertextSha256 !== void 0 && opts.approvedCiphertextSha256 !== facts.ciphertextSha256)
+    throw new FileCryptoError("integrity", "file share differs from the approved file");
+  if (ciphertext.length !== facts.ciphertextSize || await fileSha256Hex(ciphertext) !== facts.ciphertextSha256)
+    throw new FileCryptoError("integrity", "ciphertext does not match the file share");
+  const bytes = await aesGcmOpen(key2, iv, ciphertext);
+  if (bytes.length !== facts.size || await fileSha256Hex(bytes) !== facts.sha256)
+    throw new FileCryptoError("integrity", "plaintext does not match the file share");
+  const name = sanitizeFileName(facts.name);
+  const mediaType = detectFileType(name, bytes);
+  if (mediaType !== facts.mediaType)
+    throw new FileCryptoError("type_mismatch", "file content does not match its declared type");
+  return { bytes, name, mediaType };
+}
+var LOOPBACK_HOSTS = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "[::1]"]);
+var IPV4_LITERAL = /^\d+(\.\d+){0,3}$/;
+var UPLOAD_PATH = /^\/v1\/uploads\/fil_[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\/[A-Za-z0-9_-]{43}$/;
+function pinnedOrigin(pin) {
+  const bad = (what) => new FileCryptoError("invalid_descriptor", `upload origin: ${what}`);
+  if (!pin || typeof pin.origin !== "string") throw bad("missing");
+  let url;
+  try {
+    url = new URL(pin.origin);
+  } catch {
+    throw bad("invalid");
+  }
+  if (url.origin !== pin.origin.replace(/\/$/, "")) throw bad("must be a bare origin");
+  const host = url.hostname.toLowerCase();
+  const loopback = LOOPBACK_HOSTS.has(host) || host.endsWith(".localhost");
+  if (loopback) {
+    if (!pin.allowLoopbackHttp) throw bad("loopback only in explicit test mode");
+  } else {
+    if (url.protocol !== "https:") throw bad("must be https");
+    if (IPV4_LITERAL.test(host) || host.startsWith("[")) throw bad("no IP literal");
+  }
+  if (url.protocol !== "https:" && url.protocol !== "http:") throw bad("must be http(s)");
+  return url;
+}
+function aesgcmSecrets(raw) {
+  if (typeof raw !== "string" || !raw.startsWith("aesgcm://"))
+    throw new FileCryptoError("invalid_descriptor", "not an aesgcm URL");
+  const hash = raw.indexOf("#");
+  const fragment = hash < 0 ? "" : raw.slice(hash + 1).toLowerCase();
+  if (!/^[0-9a-f]{88}$/.test(fragment))
+    throw new FileCryptoError(
+      "invalid_descriptor",
+      "aesgcm URL needs a 12-byte IV and a 32-byte key"
+    );
+  return {
+    iv: fromHex(fragment.slice(0, FILE_IV_BYTES * 2)),
+    key: fromHex(fragment.slice(FILE_IV_BYTES * 2))
+  };
+}
+function aesgcmUrl(getUrl, key2, iv) {
+  checkKeyIv(key2, iv);
+  let url;
+  try {
+    url = new URL(getUrl);
+  } catch {
+    throw new FileCryptoError("invalid_descriptor", "invalid download URL");
+  }
+  if (url.protocol !== "https:" && url.protocol !== "http:")
+    throw new FileCryptoError("invalid_descriptor", "download URL must be http(s)");
+  if (url.hash !== "" || url.search !== "" || url.username !== "" || url.password !== "")
+    throw new FileCryptoError(
+      "invalid_descriptor",
+      "download URL must not carry a query, fragment or credentials"
+    );
+  if (!UPLOAD_PATH.test(url.pathname))
+    throw new FileCryptoError("invalid_descriptor", "not a file download URL");
+  return `aesgcm://${url.host}${url.pathname}#${toHex(iv)}${toHex(key2)}`;
+}
+function parseAesgcmUrl(raw, pin) {
+  const origin = pinnedOrigin(pin);
+  const { key: key2, iv } = aesgcmSecrets(raw);
+  const rest = raw.slice("aesgcm://".length, raw.indexOf("#"));
+  const slash = rest.indexOf("/");
+  const host = slash < 0 ? rest : rest.slice(0, slash);
+  const path = slash < 0 ? "" : rest.slice(slash);
+  if (host.toLowerCase() !== origin.host.toLowerCase())
+    throw new FileCryptoError("invalid_descriptor", "file is not on the expected upload origin");
+  if (!UPLOAD_PATH.test(path))
+    throw new FileCryptoError("invalid_descriptor", "not a file download path");
+  return { fetchUrl: `${origin.origin}${path}`, key: key2, iv };
+}
+var FILE_SHARE_VERSION = 1;
+var SHARE_KEYS = [
+  "wacandoFile",
+  "url",
+  "name",
+  "mediaType",
+  "size",
+  "sha256",
+  "ciphertextSize",
+  "ciphertextSha256"
+];
+var SHA256 = /^[0-9a-f]{64}$/;
+function fileShareFor(file, getUrl) {
+  return {
+    url: aesgcmUrl(getUrl, file.key, file.iv),
+    name: file.name,
+    mediaType: file.mediaType,
+    size: file.plaintextSize,
+    sha256: file.plaintextSha256,
+    ciphertextSize: file.approval.sizeBytes,
+    ciphertextSha256: file.approval.ciphertextSha256
+  };
+}
+function checkShape(v) {
+  const bad = (what) => new FileCryptoError("invalid_descriptor", `file share: ${what}`);
+  if (typeof v !== "object" || v === null || Array.isArray(v)) throw bad("not an object");
+  const o = v;
+  const keys = Object.keys(o);
+  if (keys.length !== SHARE_KEYS.length || !SHARE_KEYS.every((k) => keys.includes(k)))
+    throw bad("unexpected fields");
+  if (o.wacandoFile !== FILE_SHARE_VERSION) throw bad("unsupported version");
+  if (typeof o.url !== "string") throw bad("url");
+  aesgcmSecrets(o.url);
+  if (typeof o.name !== "string" || o.name.length === 0 || utf8Length(o.name) > 1024)
+    throw bad("name");
+  if (!ALLOWED_MEDIA_TYPES.includes(o.mediaType)) throw bad("media type");
+  const int = (x, min, max) => typeof x === "number" && Number.isSafeInteger(x) && x >= min && x <= max;
+  if (!int(o.size, 0, MAX_FILE_PLAINTEXT_BYTES)) throw bad("size");
+  if (!int(o.ciphertextSize, FILE_TAG_BYTES, MAX_FILE_CIPHERTEXT_BYTES))
+    throw bad("ciphertext size");
+  if (o.ciphertextSize !== o.size + FILE_TAG_BYTES) throw bad("sizes disagree");
+  if (typeof o.sha256 !== "string" || !SHA256.test(o.sha256)) throw bad("sha256");
+  if (typeof o.ciphertextSha256 !== "string" || !SHA256.test(o.ciphertextSha256))
+    throw bad("ciphertext sha256");
+  return {
+    url: o.url,
+    name: o.name,
+    mediaType: o.mediaType,
+    size: o.size,
+    sha256: o.sha256,
+    ciphertextSize: o.ciphertextSize,
+    ciphertextSha256: o.ciphertextSha256
+  };
+}
+function formatFileShare(share) {
+  const checked = checkShape({ wacandoFile: FILE_SHARE_VERSION, ...share });
+  return JSON.stringify({ wacandoFile: FILE_SHARE_VERSION, ...checked });
+}
+function isFileShareBody(body) {
+  return body.startsWith('{"wacandoFile":');
+}
+function parseFileShare(body, pin) {
+  let v;
+  try {
+    v = JSON.parse(body);
+  } catch {
+    throw new FileCryptoError("invalid_descriptor", "file share is not JSON");
+  }
+  const share = checkShape(v);
+  parseAesgcmUrl(share.url, pin);
+  return share;
+}
+var FILE_REVIEW_VERSION = 1;
+var REVIEW_KEYS = [
+  "wacandoFileReview",
+  "fileId",
+  "name",
+  "mediaType",
+  "size",
+  "sha256",
+  "ciphertextSize",
+  "ciphertextSha256",
+  "secret"
+];
+var FILE_ID = /^fil_[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+function fileReviewFor(file, fileId) {
+  checkKeyIv(file.key, file.iv);
+  return checkReview({
+    wacandoFileReview: FILE_REVIEW_VERSION,
+    fileId,
+    name: file.name,
+    mediaType: file.mediaType,
+    size: file.plaintextSize,
+    sha256: file.plaintextSha256,
+    ciphertextSize: file.approval.sizeBytes,
+    ciphertextSha256: file.approval.ciphertextSha256,
+    secret: `${toHex(file.iv)}${toHex(file.key)}`
+  });
+}
+function checkReview(v) {
+  const bad = (what) => new FileCryptoError("invalid_descriptor", `file review: ${what}`);
+  if (typeof v !== "object" || v === null || Array.isArray(v)) throw bad("not an object");
+  const o = v;
+  const keys = Object.keys(o);
+  if (keys.length !== REVIEW_KEYS.length || !REVIEW_KEYS.every((k) => keys.includes(k)))
+    throw bad("unexpected fields");
+  if (o.wacandoFileReview !== FILE_REVIEW_VERSION) throw bad("unsupported version");
+  if (typeof o.fileId !== "string" || !FILE_ID.test(o.fileId)) throw bad("file id");
+  if (typeof o.secret !== "string" || !/^[0-9a-f]{88}$/.test(o.secret)) throw bad("secret");
+  const share = checkShape({
+    wacandoFile: FILE_SHARE_VERSION,
+    url: `aesgcm://review.invalid/#${o.secret}`,
+    name: o.name,
+    mediaType: o.mediaType,
+    size: o.size,
+    sha256: o.sha256,
+    ciphertextSize: o.ciphertextSize,
+    ciphertextSha256: o.ciphertextSha256
+  });
+  return {
+    fileId: o.fileId,
+    name: share.name,
+    mediaType: share.mediaType,
+    size: share.size,
+    sha256: share.sha256,
+    ciphertextSize: share.ciphertextSize,
+    ciphertextSha256: share.ciphertextSha256,
+    secret: o.secret
+  };
+}
+function formatFileReview(review) {
+  const checked = checkReview({ wacandoFileReview: FILE_REVIEW_VERSION, ...review });
+  return JSON.stringify({ wacandoFileReview: FILE_REVIEW_VERSION, ...checked });
+}
+function isFileReviewBody(body) {
+  return body.startsWith('{"wacandoFileReview":');
+}
+function parseFileReview(body) {
+  let v;
+  try {
+    v = JSON.parse(body);
+  } catch {
+    throw new FileCryptoError("invalid_descriptor", "file review is not JSON");
+  }
+  return checkReview(v);
+}
+async function decryptFileReview(ciphertext, review, opts = {}) {
+  const checked = checkReview({ wacandoFileReview: FILE_REVIEW_VERSION, ...review });
+  const iv = fromHex(checked.secret.slice(0, FILE_IV_BYTES * 2));
+  const key2 = fromHex(checked.secret.slice(FILE_IV_BYTES * 2));
+  return openChecked(ciphertext, checked, key2, iv, opts);
+}
+function fileIdOfShare(share) {
+  const match = /^aesgcm:\/\/[^/#]+\/v1\/uploads\/(fil_[0-9a-f-]{36})\/[A-Za-z0-9_-]{43}#/.exec(
+    share.url
+  );
+  return match?.[1] && FILE_ID.test(match[1]) ? match[1] : null;
+}
+async function downloadFile(share, opts) {
+  const { fetchUrl } = parseAesgcmUrl(share.url, opts.pin);
+  const limit = share.ciphertextSize;
+  const doFetch = opts.fetch ?? globalThis.fetch;
+  const signal = AbortSignal.timeout(opts.timeoutMs ?? FILE_DOWNLOAD_TIMEOUT_MS);
+  const failed = (what) => new FileCryptoError("download_failed", `download ${what}`);
+  let res;
+  try {
+    res = await doFetch(fetchUrl, {
+      method: "GET",
+      headers: opts.bearer ? { authorization: `Bearer ${opts.bearer}` } : {},
+      redirect: "error",
+      credentials: "omit",
+      referrerPolicy: "no-referrer",
+      signal
+    });
+  } catch {
+    throw failed(signal.aborted ? "timed out" : "failed (network or redirect)");
+  }
+  if (res.redirected || res.type === "opaqueredirect") {
+    await res.body?.cancel().catch(() => {
+    });
+    throw failed("redirected");
+  }
+  if (res.status !== 200) {
+    await res.body?.cancel().catch(() => {
+    });
+    throw failed(`refused with HTTP ${res.status}`);
+  }
+  const declared = res.headers.get("content-length");
+  if (declared !== null && !(Number(declared) <= limit)) {
+    await res.body?.cancel().catch(() => {
+    });
+    throw new FileCryptoError("too_large", "download larger than the announced file");
+  }
+  if (!res.body) throw failed("has no body");
+  const reader = res.body.getReader();
+  const chunks = [];
+  let total = 0;
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      total += value.length;
+      if (total > limit) {
+        await reader.cancel().catch(() => {
+        });
+        throw new FileCryptoError("too_large", "download larger than the announced file");
+      }
+      chunks.push(value);
+    }
+  } catch (e) {
+    if (e instanceof FileCryptoError) throw e;
+    throw failed(signal.aborted ? "timed out" : "interrupted");
+  }
+  const out = new Uint8Array(total);
+  let at = 0;
+  for (const c of chunks) {
+    out.set(c, at);
+    at += c.length;
+  }
+  return out;
+}
+
 // packages/omemo/src/recovery.ts
 import {
   CiphertextMessageType as CiphertextMessageType2,
@@ -1983,14 +2509,14 @@ var SessionRecovery = class _SessionRecovery {
     if (this.inflight.has(pair)) throw new Refused("resource-constraint", "busy");
     if (!findPendingSend(this.ledger, pair, r.roomJid, r.stanzaId, r.keyDigest, r.consumedPreKeyId))
       throw new Refused("not-acceptable", "stale");
-    const own = activeAttempt(this.ledger, pair);
-    if (own) {
+    const own2 = activeAttempt(this.ledger, pair);
+    if (own2) {
       const weInitiate = { jid: this.o.provider.bareJid, device: this.state.deviceId };
       const theyInitiate = { jid: r.bJid, device: r.bDevice };
-      if (own.role === "B" && own.state === "offered" && compareInitiators(weInitiate, theyInitiate) < 0) {
-        own.state = "failed";
-        own.reason = "stale";
-        delete own.cached;
+      if (own2.role === "B" && own2.state === "offered" && compareInitiators(weInitiate, theyInitiate) < 0) {
+        own2.state = "failed";
+        own2.reason = "stale";
+        delete own2.cached;
         this.persist();
       } else throw new Refused("not-acceptable", "fenced");
     }
@@ -2462,7 +2988,18 @@ function loadNativeOmemoProvider(jid, options = {}) {
 export {
   BODY_MARKER,
   DeviceState,
+  FILE_DOWNLOAD_TIMEOUT_MS,
+  FILE_IV_BYTES,
+  FILE_KEY_BYTES,
+  FILE_MEDIA_TYPES,
+  FILE_REVIEW_VERSION,
+  FILE_SHARE_VERSION,
+  FILE_TAG_BYTES,
+  FileCryptoError,
   LibsignalNodeBackend,
+  MAX_FILE_CIPHERTEXT_BYTES,
+  MAX_FILE_NAME_BYTES,
+  MAX_FILE_PLAINTEXT_BYTES,
   NS_DEVICELIST,
   NS_EME,
   NS_HINTS,
@@ -2478,11 +3015,31 @@ export {
   RECOVERY_LIMITS,
   SessionRecovery,
   UnsupportedSignalFormatError,
+  aesgcmUrl,
   bundleNode,
+  decryptFile,
+  decryptFileReview,
   defaultStateBaseDir,
+  detectFileType,
   deviceListEl,
+  downloadFile,
+  encryptFile,
+  fileExtension,
+  fileIdOfShare,
+  fileReviewFor,
+  fileSha256Hex,
+  fileShareFor,
+  formatFileReview,
+  formatFileShare,
+  isFileReviewBody,
+  isFileShareBody,
   jidStateDirName,
   loadNativeOmemoProvider,
+  parseAesgcmUrl,
   parseDeviceList,
-  parseEncrypted
+  parseEncrypted,
+  parseFileReview,
+  parseFileShare,
+  sanitizeFileName,
+  sniffContent
 };

package/packages/wacando/xmpp.mjs

@@ -1,16 +1,17 @@
-// Embedded from lbframe/wacando@9f82881d4ee6cfd655727a08883877230917c955 by scripts/embed-wacando.mjs. Do not edit; see provenance.json.
+// Embedded from lbframe/wacando@618922ecaf2213da18949a8b27d343c8767b64c5 by scripts/embed-wacando.mjs. Do not edit; see provenance.json.
 import {
   MucJoinError,
   MucOriginTracker,
   authenticatedMessageOrigin,
+  defaultTimeoutMs,
   forwardedStanza,
   joinRoom,
   queryMam,
   refuseSubscriptionRequests,
   unwrapPolicyDelivery,
   waitForStanza
-} from "./chunks/chunk-GASYW3SG.mjs";
-import "./chunks/chunk-EIGFLZ2Y.mjs";
+} from "./chunks/chunk-53E7SSTF.mjs";
+import "./chunks/chunk-PZDQXGA6.mjs";
 
 // packages/xmpp/src/index.ts
 import { default as default2 } from "@xmpp/xml";
@@ -34,6 +35,41 @@ async function announceAvailable(entity, timeoutMs) {
   }
   await echoed;
 }
+
+// packages/xmpp/src/upload.ts
+import xml2 from "@xmpp/xml";
+var NS_HTTP_UPLOAD = "urn:xmpp:http:upload:0";
+function uploadServiceJid(domain) {
+  return `upload.${domain}`;
+}
+function uploadSlotRequest(req) {
+  return xml2("request", {
+    xmlns: NS_HTTP_UPLOAD,
+    filename: req.filename,
+    size: String(req.size),
+    "content-type": req.contentType ?? "application/octet-stream"
+  });
+}
+var ALLOWED_PUT_HEADERS = /* @__PURE__ */ new Set(["authorization", "cookie", "expires"]);
+function parseUploadSlot(slot) {
+  if (!slot || slot.name !== "slot" || slot.attrs.xmlns !== NS_HTTP_UPLOAD)
+    throw new Error("upload service returned no slot");
+  const put = slot.getChild("put")?.attrs.url;
+  const get = slot.getChild("get")?.attrs.url;
+  if (typeof put !== "string" || typeof get !== "string")
+    throw new Error("upload slot is missing its put/get URL");
+  const putHeaders = {};
+  for (const header of slot.getChild("put")?.getChildren("header") ?? []) {
+    const name = String(header.attrs.name ?? "").toLowerCase();
+    if (ALLOWED_PUT_HEADERS.has(name)) putHeaders[name] = header.text().replace(/[\r\n]/g, "");
+  }
+  return { put, get, putHeaders };
+}
+async function requestUploadSlot(entity, service, req, timeoutMs = defaultTimeoutMs()) {
+  const iq = xml2("iq", { type: "get", to: service }, uploadSlotRequest(req));
+  const result = await entity.iqCaller.request(iq, timeoutMs);
+  return parseUploadSlot(result.getChild("slot", NS_HTTP_UPLOAD));
+}
 export {
   MucJoinError,
   MucOriginTracker,
@@ -43,6 +79,8 @@ export {
   joinRoom,
   queryMam,
   refuseSubscriptionRequests,
+  requestUploadSlot,
   unwrapPolicyDelivery,
+  uploadServiceJid,
   default2 as xml
 };