openmates 0.27.0-alpha.32 → 0.27.0-alpha.34

package/dist/chunk-TMYEFC7M.js

@@ -0,0 +1,692 @@
+import {
+  stripImageMetadata
+} from "./chunk-V2QAI5ET.js";
+
+// src/uploadService.ts
+import { readFileSync } from "fs";
+import { basename, extname } from "path";
+
+// ../upload-privacy/src/audio.ts
+var ascii = (bytes, offset, length) => String.fromCharCode(...bytes.subarray(offset, offset + length));
+var matches = (bytes, offset, value) => offset >= 0 && offset + value.length <= bytes.length && ascii(bytes, offset, value.length) === value;
+var u32le = (bytes, offset) => (bytes[offset] | bytes[offset + 1] << 8 | bytes[offset + 2] << 16 | bytes[offset + 3] << 24) >>> 0;
+var u32be = (bytes, offset) => (bytes[offset] << 24 | bytes[offset + 1] << 16 | bytes[offset + 2] << 8 | bytes[offset + 3]) >>> 0;
+var put32le = (bytes, offset, value) => {
+  bytes[offset] = value & 255;
+  bytes[offset + 1] = value >>> 8 & 255;
+  bytes[offset + 2] = value >>> 16 & 255;
+  bytes[offset + 3] = value >>> 24 & 255;
+};
+function stripWav(bytes) {
+  if (bytes.length < 44 || !matches(bytes, 0, "RIFF") || !matches(bytes, 8, "WAVE") || u32le(bytes, 4) !== bytes.length - 8) return void 0;
+  const chunks = [];
+  let offset = 12;
+  let hasFormat = false;
+  let hasData = false;
+  let changed = false;
+  while (offset < bytes.length) {
+    if (offset + 8 > bytes.length) return void 0;
+    const length2 = u32le(bytes, offset + 4);
+    const end = offset + 8 + length2 + (length2 & 1);
+    if (!Number.isSafeInteger(end) || end > bytes.length) return void 0;
+    const id = ascii(bytes, offset, 4);
+    if (id === "fmt " || id === "data" || id === "fact") {
+      if (id === "fmt ") hasFormat = true;
+      if (id === "data") hasData = true;
+      chunks.push(bytes.subarray(offset, end));
+    } else if (id === "LIST" && matches(bytes, offset + 8, "wavl")) {
+      return void 0;
+    } else changed = true;
+    offset = end;
+  }
+  if (!hasFormat || !hasData) return void 0;
+  if (!changed) return bytes;
+  const length = 12 + chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+  if (length - 8 > 4294967295) return void 0;
+  const output = new Uint8Array(length);
+  output.set(bytes.subarray(0, 12));
+  put32le(output, 4, length - 8);
+  let cursor = 12;
+  for (const chunk of chunks) {
+    output.set(chunk, cursor);
+    cursor += chunk.length;
+  }
+  return output;
+}
+function synchsafe(bytes, offset) {
+  if (offset + 4 > bytes.length || bytes.subarray(offset, offset + 4).some((value) => value & 128)) return void 0;
+  return bytes[offset] << 21 | bytes[offset + 1] << 14 | bytes[offset + 2] << 7 | bytes[offset + 3];
+}
+function stripMp3OrAdts(bytes, adts) {
+  let start = 0;
+  let end = bytes.length;
+  while (matches(bytes, start, "ID3")) {
+    if (start + 10 > end || bytes[start + 3] < 2 || bytes[start + 3] > 4) return void 0;
+    const size = synchsafe(bytes, start + 6);
+    if (size === void 0) return void 0;
+    const footer = (bytes[start + 5] & 16) !== 0 ? 10 : 0;
+    const next = start + 10 + size + footer;
+    if (next > end || footer && !matches(bytes, next - 10, "3DI")) return void 0;
+    start = next;
+  }
+  let removed;
+  do {
+    removed = false;
+    if (end - start >= 128 && matches(bytes, end - 128, "TAG")) {
+      end -= 128;
+      removed = true;
+    }
+    if (end - start >= 32 && matches(bytes, end - 32, "APETAGEX")) {
+      const footer = end - 32;
+      const size = u32le(bytes, footer + 12);
+      if (size < 32 || size > end - start) return void 0;
+      let tagStart = end - size;
+      if (tagStart - 32 >= start && matches(bytes, tagStart - 32, "APETAGEX")) tagStart -= 32;
+      end = tagStart;
+      removed = true;
+    }
+  } while (removed);
+  if (end - start < (adts ? 7 : 4) || bytes[start] !== 255 || (bytes[start + 1] & 240) !== 240) return void 0;
+  if (adts) {
+    if ((bytes[start + 1] & 6) !== 0 || (bytes[start + 2] & 60) === 60) return void 0;
+  } else if ((bytes[start + 1] & 8) !== 8 || (bytes[start + 1] & 6) === 0) return void 0;
+  return start === 0 && end === bytes.length ? bytes : bytes.slice(start, end);
+}
+var MP4_METADATA = /* @__PURE__ */ new Set(["udta", "meta", "uuid", "ilst", "keys", "ID32", "XMP_", "\xA9nam", "\xA9ART", "\xA9alb", "\xA9day", "\xA9too", "\xA9cmt", "\xA9wrt"]);
+var MP4_CONTAINERS = /* @__PURE__ */ new Set(["moov", "trak", "mdia", "minf", "stbl", "edts", "dinf", "mvex", "moof", "traf", "mfra", "tref", "ipro", "iprp", "ipco", "wave"]);
+function stripMp4(bytes) {
+  if (bytes.length < 16 || !matches(bytes, 4, "ftyp")) return void 0;
+  const output = bytes.slice();
+  let changed = false;
+  let sawMedia = false;
+  let count = 0;
+  function walk(start, end, depth) {
+    if (depth > 16) return false;
+    let position = start;
+    while (position < end) {
+      if (++count > 1e5 || position + 8 > end) return false;
+      const size32 = u32be(bytes, position);
+      const type = ascii(bytes, position + 4, 4);
+      let header = 8;
+      let size = size32;
+      if (size32 === 1) {
+        if (position + 16 > end) return false;
+        const high = u32be(bytes, position + 8);
+        size = high * 4294967296 + u32be(bytes, position + 12);
+        header = 16;
+      } else if (size32 === 0) size = end - position;
+      if (!Number.isSafeInteger(size) || size < header || position + size > end) return false;
+      if (type === "mdat") sawMedia = true;
+      if (MP4_METADATA.has(type)) {
+        output.set([102, 114, 101, 101], position + 4);
+        output.fill(0, position + header, position + size);
+        changed = true;
+      } else if (type === "free" || type === "skip") {
+        if (bytes.subarray(position + header, position + size).some((value) => value !== 0)) changed = true;
+        output.fill(0, position + header, position + size);
+      } else if (MP4_CONTAINERS.has(type) && !walk(position + header, position + size, depth + 1)) return false;
+      position += size;
+    }
+    return position === end;
+  }
+  return walk(0, bytes.length, 0) && sawMedia ? changed ? output : bytes : void 0;
+}
+var EBML_MASTERS = /* @__PURE__ */ new Set([440786851, 408125543, 290298740, 357149030, 374648427, 174, 224, 225, 524531317, 160, 475249515, 187, 183, 423732329, 24999, 272869232, 17849, 182, 128]);
+var EBML_METADATA = /* @__PURE__ */ new Set([307544935, 26568, 22337, 19840, 17505, 31657, 29604, 29572, 3979555, 4110627, 3965867, 4096955, 21358]);
+function ebmlVint(bytes, offset, end, isSize) {
+  if (offset >= end) return void 0;
+  const first = bytes[offset];
+  let mask = 128;
+  let length = 1;
+  while (length <= (isSize ? 8 : 4) && !(first & mask)) {
+    mask >>= 1;
+    length++;
+  }
+  if (length > (isSize ? 8 : 4) || offset + length > end) return void 0;
+  let value = isSize ? first & mask - 1 : first;
+  let unknown = isSize && value === mask - 1;
+  for (let i = 1; i < length; i++) {
+    value = value * 256 + bytes[offset + i];
+    unknown = unknown && bytes[offset + i] === 255;
+  }
+  return { value, length, unknown };
+}
+function writeVoid(output, start, length) {
+  for (let sizeLength = 1; sizeLength <= 8; sizeLength++) {
+    const payload = length - 1 - sizeLength;
+    if (payload < 0 || payload >= 2 ** (7 * sizeLength) - 1) continue;
+    output[start] = 236;
+    for (let i = 0; i < sizeLength; i++) {
+      const shift = 8 * (sizeLength - 1 - i);
+      output[start + 1 + i] = Math.floor(payload / 2 ** shift) & 255;
+    }
+    output[start + 1] |= 1 << 8 - sizeLength;
+    output.fill(0, start + 1 + sizeLength, start + length);
+    return true;
+  }
+  return false;
+}
+function stripWebm(bytes) {
+  if (!matches(bytes, 0, "E\xDF\xA3")) return void 0;
+  const output = bytes.slice();
+  let changed = false;
+  let sawSegment = false;
+  let count = 0;
+  const crcElements = [];
+  function walk(start, end, depth) {
+    if (depth > 16) return false;
+    let position = start;
+    while (position < end) {
+      if (++count > 1e5) return false;
+      const id = ebmlVint(bytes, position, end, false);
+      if (!id) return false;
+      const size = ebmlVint(bytes, position + id.length, end, true);
+      if (!size) return false;
+      const payload = position + id.length + size.length;
+      if (size.unknown && id.value !== 408125543) return false;
+      const next = size.unknown ? end : payload + size.value;
+      if (!Number.isSafeInteger(next) || next > end || next < payload) return false;
+      if (id.value === 408125543) sawSegment = true;
+      if (EBML_METADATA.has(id.value)) {
+        if (!writeVoid(output, position, next - position)) return false;
+        changed = true;
+      } else if (id.value === 191) {
+        if (size.value !== 4) return false;
+        crcElements.push({ start: position, length: next - position });
+      } else if (id.value === 236) {
+        if (bytes.subarray(payload, next).some((value) => value !== 0)) changed = true;
+        output.fill(0, payload, next);
+      } else if (EBML_MASTERS.has(id.value) && !walk(payload, next, depth + 1)) return false;
+      position = next;
+    }
+    return position === end;
+  }
+  if (!walk(0, bytes.length, 0) || !sawSegment) return void 0;
+  if (!changed) return bytes;
+  for (const element of crcElements) if (!writeVoid(output, element.start, element.length)) return void 0;
+  return output;
+}
+var OGG_CRC_TABLE = (() => {
+  const table = new Uint32Array(256);
+  for (let i = 0; i < 256; i++) {
+    let crc = i << 24;
+    for (let j = 0; j < 8; j++) crc = crc & 2147483648 ? (crc << 1 ^ 79764919) >>> 0 : crc << 1 >>> 0;
+    table[i] = crc;
+  }
+  return table;
+})();
+function pageCrc(bytes, start, end) {
+  let crc = 0;
+  for (let i = start; i < end; i++) crc = (crc << 8 ^ OGG_CRC_TABLE[(crc >>> 24 ^ (i >= start + 22 && i < start + 26 ? 0 : bytes[i])) & 255]) >>> 0;
+  return crc;
+}
+function stripOgg(bytes) {
+  if (!matches(bytes, 0, "OggS")) return void 0;
+  const pages = [];
+  const streams = /* @__PURE__ */ new Map();
+  let offset = 0;
+  while (offset < bytes.length) {
+    if (offset + 27 > bytes.length || !matches(bytes, offset, "OggS") || bytes[offset + 4] !== 0) return void 0;
+    const segmentCount = bytes[offset + 26];
+    if (offset + 27 + segmentCount > bytes.length) return void 0;
+    let dataLength = 0;
+    for (let i = 0; i < segmentCount; i++) dataLength += bytes[offset + 27 + i];
+    const dataStart = offset + 27 + segmentCount;
+    const end = dataStart + dataLength;
+    if (end > bytes.length) return void 0;
+    const serial = u32le(bytes, offset + 14);
+    const stream = streams.get(serial) ?? { packetIndex: 0, pendingOpen: false, pending: [], packets: [] };
+    if (Boolean(bytes[offset + 5] & 1) !== stream.pendingOpen) return void 0;
+    let cursor = dataStart;
+    for (let i = 0; i < segmentCount; i++) {
+      const length = bytes[offset + 27 + i];
+      if (stream.packetIndex < 2) for (let j = 0; j < length; j++) stream.pending.push(cursor + j);
+      cursor += length;
+      stream.pendingOpen = length === 255;
+      if (length < 255) {
+        if (stream.packetIndex < 2) stream.packets.push(stream.pending);
+        stream.pending = [];
+        stream.packetIndex++;
+      }
+    }
+    streams.set(serial, stream);
+    pages.push({ start: offset, end });
+    offset = end;
+  }
+  const output = bytes.slice();
+  let changed = false;
+  const patch = (positions, index, value) => {
+    output[positions[index]] = value;
+  };
+  const read = (positions, index) => bytes[positions[index]];
+  const read32 = (positions, index) => (read(positions, index) | read(positions, index + 1) << 8 | read(positions, index + 2) << 16 | read(positions, index + 3) << 24) >>> 0;
+  for (const stream of streams.values()) {
+    if (stream.pendingOpen || stream.packets.length < 2) return void 0;
+    const [first, second] = stream.packets;
+    const signature = (positions, value) => positions.length >= value.length && [...value].every((char, index) => read(positions, index) === char.charCodeAt(0));
+    const opus = signature(first, "OpusHead");
+    const vorbis = first.length >= 7 && read(first, 0) === 1 && signature(first.slice(1), "vorbis");
+    if (!opus && !vorbis) return void 0;
+    const prefix = opus ? 8 : 7;
+    if (second.length < prefix + 8 || (opus ? !signature(second, "OpusTags") : read(second, 0) !== 3 || !signature(second.slice(1), "vorbis"))) return void 0;
+    let cursor = prefix;
+    const vendorLength = read32(second, cursor);
+    cursor += 4;
+    if (vendorLength > second.length - cursor - 4) return void 0;
+    const vendorStart = cursor;
+    cursor += vendorLength;
+    const commentCount = read32(second, cursor);
+    cursor += 4;
+    if (commentCount > (second.length - cursor) / 4) return void 0;
+    const comments = [];
+    for (let i = 0; i < commentCount; i++) {
+      if (cursor + 4 > second.length) return void 0;
+      const length = read32(second, cursor);
+      cursor += 4;
+      if (length > second.length - cursor || vorbis && length < 2) return void 0;
+      comments.push({ start: cursor, length });
+      cursor += length;
+    }
+    if (vorbis && (cursor >= second.length || (read(second, cursor) & 1) === 0)) return void 0;
+    if (opus) {
+      for (let i = prefix; i < second.length; i++) patch(second, i, 0);
+    } else {
+      for (let i = vendorStart; i < vendorStart + vendorLength; i++) patch(second, i, 32);
+      for (const comment of comments) {
+        for (let i = comment.start; i < comment.start + comment.length; i++) patch(second, i, 32);
+        if (comment.length >= 2) {
+          patch(second, comment.start, 88);
+          patch(second, comment.start + 1, 61);
+        }
+      }
+      for (let i = cursor + 1; i < second.length; i++) patch(second, i, 0);
+    }
+    changed = true;
+  }
+  if (!changed) return void 0;
+  for (const page of pages) {
+    put32le(output, page.start + 22, pageCrc(output, page.start, page.end));
+  }
+  return output;
+}
+function stripAudioMetadata(bytes, mimeType) {
+  try {
+    const mime = mimeType.toLowerCase().split(";", 1)[0].trim();
+    if (mime === "audio/wav" || mime === "audio/wave" || mime === "audio/x-wav") return stripWav(bytes);
+    if (mime === "audio/mpeg" || mime === "audio/mp3") return stripMp3OrAdts(bytes, false);
+    if (mime === "audio/aac" || mime === "audio/aacp") return stripMp3OrAdts(bytes, true);
+    if (mime === "audio/mp4" || mime === "audio/x-m4a" || mime === "audio/m4a") return stripMp4(bytes);
+    if (mime === "audio/webm" || mime === "audio/x-matroska") return stripWebm(bytes);
+    if (mime === "audio/ogg" || mime === "application/ogg" || mime === "audio/opus") return stripOgg(bytes);
+  } catch {
+  }
+  return void 0;
+}
+
+// ../upload-privacy/src/index.ts
+var EXTENSIONS = {
+  "image/jpeg": "jpg",
+  "image/png": "png",
+  "image/webp": "webp",
+  "image/gif": "gif",
+  "image/svg+xml": "svg",
+  "image/bmp": "bmp",
+  "image/tiff": "tiff",
+  "image/heic": "heic",
+  "image/heif": "heif",
+  "application/pdf": "pdf",
+  "audio/mpeg": "mp3",
+  "audio/aac": "aac",
+  "audio/wav": "wav",
+  "audio/x-wav": "wav",
+  "audio/mp4": "m4a",
+  "audio/webm": "webm",
+  "audio/ogg": "ogg"
+};
+function detectMimeType(bytes, declaredType, filename) {
+  const startsWith = (...values) => values.every((value, index) => bytes[index] === value);
+  const ascii2 = (start, end) => String.fromCharCode(...bytes.subarray(start, end));
+  if (startsWith(255, 216)) return "image/jpeg";
+  if (startsWith(137, 80, 78, 71, 13, 10, 26, 10)) return "image/png";
+  if (ascii2(0, 4) === "RIFF") {
+    if (ascii2(8, 12) === "WEBP") return "image/webp";
+    if (ascii2(8, 12) === "WAVE") return "audio/wav";
+  }
+  if (/^GIF8[79]a$/.test(ascii2(0, 6))) return "image/gif";
+  if (ascii2(0, 2) === "BM") return "image/bmp";
+  if (startsWith(73, 73, 42, 0) || startsWith(77, 77, 0, 42)) return "image/tiff";
+  if (ascii2(0, 5) === "%PDF-") return "application/pdf";
+  if (ascii2(0, 4) === "OggS") return "audio/ogg";
+  if (ascii2(0, 3) === "ID3") return declaredType === "audio/aac" ? "audio/aac" : "audio/mpeg";
+  if (startsWith(26, 69, 223, 163)) return "audio/webm";
+  if (ascii2(4, 8) === "ftyp") {
+    const brand = ascii2(8, 12);
+    if (/^(hei[cfx]|mif1|msf1)$/.test(brand)) return "image/heic";
+    return "audio/mp4";
+  }
+  const extension = filename.match(/\.([a-zA-Z0-9]+)$/)?.[1].toLowerCase();
+  if (!declaredType || declaredType === "application/octet-stream") {
+    const type = Object.entries(EXTENSIONS).find(([, value]) => value === extension)?.[0];
+    if (type) return type;
+    if (extension === "jpeg") return "image/jpeg";
+    if (extension === "tif") return "image/tiff";
+    if (extension === "mp4") return "audio/mp4";
+    if (extension === "oga") return "audio/ogg";
+  }
+  return declaredType;
+}
+async function sanitizeUploadBytes(bytes, mimeType, filename) {
+  const baseType = detectMimeType(bytes, mimeType.split(";", 1)[0].toLowerCase(), filename);
+  const result = {
+    bytes,
+    mimeType: baseType || mimeType,
+    filename,
+    status: "unsupported"
+  };
+  try {
+    const input = new Uint8Array(bytes);
+    let cleaned = stripImageMetadata(input, baseType) ?? stripAudioMetadata(input, baseType);
+    if (!cleaned && !baseType.startsWith("image/") && !baseType.startsWith("audio/")) {
+      const { stripDocumentMetadata } = await import("./documents-HKLTU4HQ.js");
+      cleaned = await stripDocumentMetadata(input, baseType, filename);
+    }
+    if (cleaned) {
+      if (!cleaned.byteLength) throw new Error("Empty sanitized upload");
+      if (cleaned.byteLength > 100 * 1024 * 1024 && cleaned.byteLength > bytes.byteLength) {
+        throw new Error("Sanitized upload exceeds the upload size limit");
+      }
+      result.bytes = cleaned;
+      result.status = "sanitized";
+    }
+  } catch {
+    result.status = "failed";
+  }
+  return result;
+}
+
+// src/uploadService.ts
+var UPLOAD_MAX_ATTEMPTS = 3;
+var UPLOAD_RETRY_DELAY_MS = 2e3;
+var PROFILE_IMAGE_MAX_SIZE_BYTES = 300 * 1024;
+function adoptUploadEmbedId(embed, authoritativeEmbedId) {
+  embed.embedId = authoritativeEmbedId;
+}
+function getUploadUrl(apiUrl) {
+  try {
+    const url = new URL(apiUrl);
+    if (url.hostname === "localhost") return "http://localhost:8001";
+  } catch {
+  }
+  return "https://upload.openmates.org";
+}
+function getUploadOrigin(apiUrl) {
+  try {
+    const url = new URL(apiUrl);
+    if (url.hostname === "localhost") return "http://localhost:5173";
+    if (url.hostname.startsWith("api.")) {
+      return `${url.protocol}//app.${url.hostname.slice(4)}`;
+    }
+  } catch {
+  }
+  return "https://app.openmates.org";
+}
+function getUploadMimeType(filename) {
+  const ext = extname(filename).toLowerCase();
+  switch (ext) {
+    case ".jpg":
+    case ".jpeg":
+      return "image/jpeg";
+    case ".png":
+      return "image/png";
+    case ".webp":
+      return "image/webp";
+    case ".gif":
+      return "image/gif";
+    case ".heic":
+      return "image/heic";
+    case ".heif":
+      return "image/heif";
+    case ".bmp":
+      return "image/bmp";
+    case ".tif":
+    case ".tiff":
+      return "image/tiff";
+    case ".svg":
+      return "image/svg+xml";
+    case ".pdf":
+      return "application/pdf";
+    case ".mp3":
+      return "audio/mpeg";
+    case ".m4a":
+    case ".mp4":
+      return "audio/mp4";
+    case ".wav":
+      return "audio/wav";
+    case ".webm":
+      return "audio/webm";
+    case ".ogg":
+    case ".oga":
+      return "audio/ogg";
+    case ".aac":
+      return "audio/aac";
+    default:
+      return "application/octet-stream";
+  }
+}
+async function prepareUpload(fileBytes, filename, mimeType) {
+  try {
+    const result = await sanitizeUploadBytes(fileBytes, mimeType, filename);
+    if (result.status === "sanitized") {
+      return { bytes: result.bytes, filename, mimeType: result.mimeType };
+    }
+    if (result.status === "unsupported" && ["image/tiff", "image/heic", "image/heif", "image/bmp"].includes(result.mimeType)) {
+      try {
+        const { default: sharp } = await import("sharp");
+        const image = sharp(fileBytes);
+        const metadata = await image.metadata();
+        if ((metadata.pages ?? 1) !== 1) throw new Error("Multiple image pages");
+        const bytes = await image.rotate().png().toBuffer();
+        if (bytes.byteLength && bytes.byteLength <= 100 * 1024 * 1024) {
+          return { bytes, filename, mimeType: "image/png" };
+        }
+      } catch {
+      }
+    }
+    console.error("Warning: Could not remove embedded file metadata; uploading the original file.");
+    return { bytes: fileBytes, filename, mimeType: result.mimeType };
+  } catch {
+  }
+  console.error("Warning: Could not remove embedded file metadata; uploading the original file.");
+  return { bytes: fileBytes, filename, mimeType };
+}
+async function uploadFile(filePath, session) {
+  const filename = basename(filePath);
+  const fileBytes = readFileSync(filePath);
+  const prepared = await prepareUpload(fileBytes, filename, getUploadMimeType(filename));
+  const uploadUrl = `${getUploadUrl(session.apiUrl)}/v1/upload/file`;
+  const origin = getUploadOrigin(session.apiUrl);
+  const cookies = [];
+  if (session.cookies?.auth_refresh_token) {
+    cookies.push(`auth_refresh_token=${session.cookies.auth_refresh_token}`);
+  }
+  let response;
+  let lastError;
+  for (let attempt = 1; attempt <= UPLOAD_MAX_ATTEMPTS; attempt++) {
+    try {
+      const blob = new Blob([Buffer.from(prepared.bytes)], { type: prepared.mimeType });
+      const formData = new FormData();
+      formData.append("file", blob, prepared.filename);
+      response = await fetch(uploadUrl, {
+        method: "POST",
+        body: formData,
+        headers: {
+          Origin: origin,
+          ...cookies.length > 0 ? { Cookie: cookies.join("; ") } : {}
+        },
+        signal: AbortSignal.timeout(10 * 60 * 1e3)
+        // 10-minute timeout
+      });
+      break;
+    } catch (error) {
+      lastError = error;
+      if (attempt === UPLOAD_MAX_ATTEMPTS) break;
+      await new Promise((resolve) => setTimeout(resolve, UPLOAD_RETRY_DELAY_MS));
+    }
+  }
+  if (!response) {
+    const message = lastError instanceof Error ? lastError.message : String(lastError);
+    throw new Error(message || "Upload request failed.");
+  }
+  if (!response.ok) {
+    const status = response.status;
+    let errorMessage;
+    switch (status) {
+      case 401:
+        errorMessage = "Authentication failed. Run `openmates login` to re-authenticate.";
+        break;
+      case 413:
+        errorMessage = "File too large (maximum 100 MB).";
+        break;
+      case 415:
+        errorMessage = "Unsupported file type.";
+        break;
+      case 422: {
+        const body = await response.text().catch(() => "");
+        errorMessage = body.includes("malware") ? "File rejected: malware detected." : body.includes("content_safety") ? "File rejected: content safety violation." : `Upload validation failed: ${body}`;
+        break;
+      }
+      case 429:
+        errorMessage = "Upload rate limit exceeded. Try again in a minute.";
+        break;
+      default:
+        errorMessage = `Upload failed (HTTP ${status}).`;
+    }
+    throw new Error(errorMessage);
+  }
+  const data = await response.json();
+  return data;
+}
+async function transcribeUploadedAudio(uploadResult, filename, session, options = {}) {
+  const s3Key = uploadResult.files?.original?.s3_key ?? Object.values(uploadResult.files ?? {})[0]?.s3_key;
+  if (!s3Key) {
+    throw new Error("Upload succeeded but no audio file key was returned.");
+  }
+  const cookies = [];
+  if (session.cookies?.auth_refresh_token) {
+    cookies.push(`auth_refresh_token=${session.cookies.auth_refresh_token}`);
+  }
+  const requestItem = {
+    id: options.requestId ?? uploadResult.embed_id,
+    embed_id: uploadResult.embed_id,
+    s3_key: s3Key,
+    s3_base_url: uploadResult.s3_base_url,
+    aes_key: uploadResult.aes_key,
+    aes_nonce: uploadResult.aes_nonce,
+    vault_wrapped_aes_key: uploadResult.vault_wrapped_aes_key,
+    filename,
+    mime_type: uploadResult.content_type
+  };
+  if (options.chatId) {
+    requestItem.chat_id = options.chatId;
+  }
+  const response = await fetch(
+    `${session.apiUrl.replace(/\/$/, "")}/v1/apps/audio/skills/transcribe`,
+    {
+      method: "POST",
+      headers: {
+        Accept: "application/json",
+        "Content-Type": "application/json",
+        ...cookies.length > 0 ? { Cookie: cookies.join("; ") } : {}
+      },
+      body: JSON.stringify({ requests: [requestItem] }),
+      signal: AbortSignal.timeout(10 * 60 * 1e3)
+    }
+  );
+  if (!response.ok) {
+    let detail = `Transcription failed (HTTP ${response.status}).`;
+    try {
+      const data2 = await response.json();
+      detail = data2.detail ?? data2.error ?? detail;
+    } catch {
+    }
+    throw new Error(detail);
+  }
+  const data = await response.json();
+  if (data.success === false) {
+    throw new Error(data.error ?? "Transcription failed.");
+  }
+  const requestId = options.requestId ?? uploadResult.embed_id;
+  const group = data.data?.results?.find((item) => item.id === requestId) ?? data.data?.results?.[0];
+  const result = group?.results?.[0];
+  if (!result) {
+    throw new Error(group?.error ?? "Transcription response did not include a result.");
+  }
+  if (result.error) {
+    throw new Error(result.error);
+  }
+  return {
+    transcript: result.transcript ?? null,
+    transcript_original: result.transcript_original ?? null,
+    transcript_corrected: result.transcript_corrected ?? null,
+    use_corrected: result.use_corrected ?? null,
+    correction_model: result.correction_model ?? null,
+    model: result.model ?? null,
+    waveform: result.waveform ?? null
+  };
+}
+function getProfileImageMime(filename) {
+  const ext = extname(filename).toLowerCase();
+  if (ext === ".jpg" || ext === ".jpeg") return "image/jpeg";
+  if (ext === ".png") return "image/png";
+  throw new Error("Profile images must be JPEG or PNG files.");
+}
+async function uploadProfileImageForm(filePath, session, uploadPath, fields = {}) {
+  const filename = basename(filePath);
+  const fileBytes = readFileSync(filePath);
+  const contentType = getProfileImageMime(filename);
+  if (fileBytes.byteLength > PROFILE_IMAGE_MAX_SIZE_BYTES) {
+    throw new Error("Profile image must be 300 KB or smaller. Resize/compress the image and try again.");
+  }
+  const prepared = await prepareUpload(fileBytes, filename, contentType);
+  const uploadUrl = `${getUploadUrl(session.apiUrl)}${uploadPath}`;
+  const origin = getUploadOrigin(session.apiUrl);
+  const cookies = [];
+  if (session.cookies?.auth_refresh_token) {
+    cookies.push(`auth_refresh_token=${session.cookies.auth_refresh_token}`);
+  }
+  const formData = new FormData();
+  for (const [key, value] of Object.entries(fields)) {
+    formData.append(key, value);
+  }
+  formData.append("file", new Blob([Buffer.from(prepared.bytes)], { type: prepared.mimeType }), prepared.filename);
+  const response = await fetch(uploadUrl, {
+    method: "POST",
+    body: formData,
+    headers: {
+      Origin: origin,
+      ...cookies.length > 0 ? { Cookie: cookies.join("; ") } : {}
+    }
+  });
+  const data = await response.json().catch(() => ({}));
+  if (!response.ok && !data.status) {
+    throw new Error(data.detail ?? `Profile image upload failed (HTTP ${response.status}).`);
+  }
+  return data;
+}
+async function uploadProfileImage(filePath, session) {
+  return uploadProfileImageForm(filePath, session, "/v1/upload/profile-image");
+}
+async function uploadTeamProfileImage(filePath, session, teamId, encryptedProfileImageMetadata) {
+  return uploadProfileImageForm(filePath, session, "/v1/upload/team-profile-image", {
+    team_id: teamId,
+    encrypted_profile_image_metadata: encryptedProfileImageMetadata
+  });
+}
+
+export {
+  adoptUploadEmbedId,
+  uploadFile,
+  transcribeUploadedAudio,
+  uploadProfileImage,
+  uploadTeamProfileImage
+};