@cedarjs/uploads 8.0.0-canary.3402 → 8.0.0-canary.3403

package/dist/detectContentType.js

@@ -0,0 +1,443 @@
+import {
+  canonicalContentType,
+  isContentTypeListed,
+  isExplicitOnlyContentType
+} from "./contentTypes.js";
+import { isMimeTypeAllowed } from "./profiles.js";
+const DETECT_CONTENT_TYPE_BYTES = 4096;
+const DETECT_CONTENT_TYPE_TAIL_BYTES = 64 * 1024;
+const MAX_ZIP_DIRECTORY_BYTES = 4 * 1024 * 1024;
+const DOCX = "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
+const XLSX = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
+const PPTX = "application/vnd.openxmlformats-officedocument.presentationml.presentation";
+const DOCM = "application/vnd.ms-word.document.macroenabled.12";
+const XLSM = "application/vnd.ms-excel.sheet.macroenabled.12";
+const PPTM = "application/vnd.ms-powerpoint.presentation.macroenabled.12";
+const ODT = "application/vnd.oasis.opendocument.text";
+const ODS = "application/vnd.oasis.opendocument.spreadsheet";
+const ODP = "application/vnd.oasis.opendocument.presentation";
+const DETECTABLE_CONTENT_TYPES = /* @__PURE__ */ new Set([
+  "image/jpeg",
+  "image/png",
+  "image/gif",
+  "image/webp",
+  "image/bmp",
+  "image/tiff",
+  "image/avif",
+  "image/heic",
+  "image/heic-sequence",
+  "image/heif",
+  "image/heif-sequence",
+  "application/pdf",
+  "video/mp4",
+  "audio/mp4",
+  "video/quicktime",
+  "video/webm",
+  "video/matroska",
+  DOCX,
+  XLSX,
+  PPTX,
+  DOCM,
+  XLSM,
+  PPTM,
+  ODT,
+  ODS,
+  ODP
+]);
+const PNG_SIGNATURE = [137, 80, 78, 71, 13, 10, 26, 10];
+const EBML_SIGNATURE = [26, 69, 223, 163];
+const BMP_INFO_HEADER_SIZES = /* @__PURE__ */ new Set([12, 40, 52, 56, 64, 108, 124]);
+const AVIF_BRANDS = /* @__PURE__ */ new Set(["avif", "avis"]);
+const HEIC_BRANDS = /* @__PURE__ */ new Set(["heic", "heix", "heim", "heis"]);
+const HEIC_SEQUENCE_BRANDS = /* @__PURE__ */ new Set(["hevc", "hevx", "hevm", "hevs"]);
+const MP4_BRANDS = /* @__PURE__ */ new Set([
+  "isom",
+  "iso2",
+  "iso3",
+  "iso4",
+  "iso5",
+  "iso6",
+  "iso7",
+  "iso8",
+  "iso9",
+  "mp41",
+  "mp42",
+  "mp71",
+  "avc1",
+  "dash",
+  "M4V "
+]);
+const MP4_AUDIO_BRANDS = /* @__PURE__ */ new Set(["M4A ", "M4B "]);
+const QUICKTIME_BRAND = "qt  ";
+const MAX_FTYP_BOX_SIZE = 1024;
+const EBML_DOC_TYPE_ID = 17026;
+const MAX_DOC_TYPE_LENGTH = 32;
+function hasBytesAt(bytes, offset, expected) {
+  if (bytes.length < offset + expected.length) {
+    return false;
+  }
+  return expected.every((b, i) => bytes[offset + i] === b);
+}
+function ascii(bytes, start, end) {
+  if (end > bytes.length) {
+    return null;
+  }
+  let text = "";
+  for (let i = start; i < end; i++) {
+    text += String.fromCharCode(bytes[i]);
+  }
+  return text;
+}
+function readUint32BE(bytes, offset) {
+  if (bytes.length < offset + 4) {
+    return null;
+  }
+  return bytes[offset] * 16777216 + bytes[offset + 1] * 65536 + bytes[offset + 2] * 256 + bytes[offset + 3];
+}
+function readUint32LE(bytes, offset) {
+  if (bytes.length < offset + 4) {
+    return null;
+  }
+  return bytes[offset] + bytes[offset + 1] * 256 + bytes[offset + 2] * 65536 + bytes[offset + 3] * 16777216;
+}
+function detectIsoBmff(bytes) {
+  if (ascii(bytes, 4, 8) !== "ftyp") {
+    return null;
+  }
+  const boxSize = readUint32BE(bytes, 0);
+  if (boxSize === null || boxSize < 16 || boxSize % 4 !== 0 || boxSize > MAX_FTYP_BOX_SIZE) {
+    return null;
+  }
+  const major = ascii(bytes, 8, 12);
+  if (major === null) {
+    return null;
+  }
+  const fromMajor = classifyMajorBrand(major);
+  if (fromMajor) {
+    return fromMajor;
+  }
+  if (bytes.length < boxSize) {
+    return null;
+  }
+  const compatible = [];
+  for (let offset = 16; offset + 4 <= boxSize; offset += 4) {
+    const brand = ascii(bytes, offset, offset + 4);
+    if (brand !== null) {
+      compatible.push(brand);
+    }
+  }
+  return classifyCompatibleBrands(major, compatible);
+}
+function classifyMajorBrand(major) {
+  if (AVIF_BRANDS.has(major)) {
+    return "image/avif";
+  }
+  if (HEIC_BRANDS.has(major)) {
+    return "image/heic";
+  }
+  if (HEIC_SEQUENCE_BRANDS.has(major)) {
+    return "image/heic-sequence";
+  }
+  if (major === QUICKTIME_BRAND) {
+    return "video/quicktime";
+  }
+  if (MP4_AUDIO_BRANDS.has(major)) {
+    return "audio/mp4";
+  }
+  if (MP4_BRANDS.has(major)) {
+    return "video/mp4";
+  }
+  return null;
+}
+function classifyCompatibleBrands(major, compatible) {
+  const has = (brands) => compatible.some((brand) => brands.has(brand));
+  if (has(AVIF_BRANDS)) {
+    return "image/avif";
+  }
+  if (has(HEIC_BRANDS)) {
+    return "image/heic";
+  }
+  if (has(HEIC_SEQUENCE_BRANDS)) {
+    return "image/heic-sequence";
+  }
+  if (major === "mif1" || major === "mif2" || compatible.includes("mif1")) {
+    return "image/heif";
+  }
+  if (major === "msf1" || compatible.includes("msf1")) {
+    return "image/heif-sequence";
+  }
+  if (compatible.includes(QUICKTIME_BRAND)) {
+    return "video/quicktime";
+  }
+  if (has(MP4_AUDIO_BRANDS)) {
+    return "audio/mp4";
+  }
+  if (has(MP4_BRANDS)) {
+    return "video/mp4";
+  }
+  return null;
+}
+function readVint(bytes, offset, keepMarker) {
+  if (offset >= bytes.length) {
+    return null;
+  }
+  const first = bytes[offset];
+  if (first === 0) {
+    return null;
+  }
+  let length = 1;
+  while (!(first & 128 >> length - 1)) {
+    length++;
+  }
+  if (offset + length > bytes.length) {
+    return null;
+  }
+  const marker = 128 >> length - 1;
+  let value = keepMarker ? first : first & marker - 1;
+  let allOnes = (first & marker - 1) === marker - 1;
+  for (let i = 1; i < length; i++) {
+    const byte = bytes[offset + i];
+    value = value * 256 + byte;
+    allOnes = allOnes && byte === 255;
+  }
+  return { value, length, unknown: !keepMarker && allOnes };
+}
+function detectEbml(bytes) {
+  if (!hasBytesAt(bytes, 0, EBML_SIGNATURE)) {
+    return null;
+  }
+  const headerSize = readVint(bytes, EBML_SIGNATURE.length, false);
+  if (!headerSize || headerSize.unknown) {
+    return null;
+  }
+  const headerStart = EBML_SIGNATURE.length + headerSize.length;
+  const headerEnd = headerStart + headerSize.value;
+  let offset = headerStart;
+  while (offset < Math.min(headerEnd, bytes.length)) {
+    const id = readVint(bytes, offset, true);
+    if (!id || id.length > 4 || offset + id.length > headerEnd) {
+      return null;
+    }
+    const size = readVint(bytes, offset + id.length, false);
+    if (!size || size.unknown) {
+      return null;
+    }
+    const dataStart = offset + id.length + size.length;
+    if (dataStart + size.value > headerEnd) {
+      return null;
+    }
+    if (id.value === EBML_DOC_TYPE_ID) {
+      let docTypeEnd = dataStart + size.value;
+      if (size.value > MAX_DOC_TYPE_LENGTH || docTypeEnd > bytes.length) {
+        return null;
+      }
+      while (docTypeEnd > dataStart && bytes[docTypeEnd - 1] === 0) {
+        docTypeEnd--;
+      }
+      switch (ascii(bytes, dataStart, docTypeEnd)) {
+        case "webm":
+          return "video/webm";
+        case "matroska":
+          return "video/matroska";
+        default:
+          return null;
+      }
+    }
+    offset = dataStart + size.value;
+  }
+  return null;
+}
+function detectBmp(bytes) {
+  if (ascii(bytes, 0, 2) !== "BM") {
+    return null;
+  }
+  const reserved = readUint32LE(bytes, 6);
+  const infoHeaderSize = readUint32LE(bytes, 14);
+  if (reserved === 0 && infoHeaderSize !== null && BMP_INFO_HEADER_SIZES.has(infoHeaderSize)) {
+    return "image/bmp";
+  }
+  return null;
+}
+const ZIP_LOCAL_HEADER = [80, 75, 3, 4];
+const ZIP_CENTRAL_HEADER = [80, 75, 1, 2];
+const ZIP_END_OF_DIRECTORY = [80, 75, 5, 6];
+const ZIP_LOCAL_HEADER_SIZE = 30;
+const ZIP_CENTRAL_HEADER_SIZE = 46;
+const ZIP_END_OF_DIRECTORY_SIZE = 22;
+const ZIP_MAX_COMMENT_LENGTH = 65535;
+const OPEN_DOCUMENT_TYPES = /* @__PURE__ */ new Set([ODT, ODS, ODP]);
+function readUint16LE(bytes, offset) {
+  if (bytes.length < offset + 2) {
+    return null;
+  }
+  return bytes[offset] + bytes[offset + 1] * 256;
+}
+function detectOpenDocument(bytes) {
+  const flags = readUint16LE(bytes, 6);
+  const method = readUint16LE(bytes, 8);
+  const compressedSize = readUint32LE(bytes, 18);
+  const size = readUint32LE(bytes, 22);
+  const nameLength = readUint16LE(bytes, 26);
+  const extraLength = readUint16LE(bytes, 28);
+  if (flags === null || method === null || compressedSize === null || size === null || nameLength === null || extraLength === null) {
+    return null;
+  }
+  if (method !== 0 || flags & 8 || compressedSize !== size || size > 64) {
+    return null;
+  }
+  const nameEnd = ZIP_LOCAL_HEADER_SIZE + nameLength;
+  if (ascii(bytes, ZIP_LOCAL_HEADER_SIZE, nameEnd) !== "mimetype") {
+    return null;
+  }
+  const contentStart = nameEnd + extraLength;
+  const content = ascii(bytes, contentStart, contentStart + size);
+  return content !== null && OPEN_DOCUMENT_TYPES.has(content) ? content : null;
+}
+const MAX_ZIP_END_RECORD_CANDIDATES = 16;
+function* zipEndRecords(end) {
+  const last = end.length - ZIP_END_OF_DIRECTORY_SIZE;
+  const first = Math.max(0, last - ZIP_MAX_COMMENT_LENGTH);
+  let candidates = 0;
+  for (let offset = last; offset >= first; offset--) {
+    if (!hasBytesAt(end, offset, ZIP_END_OF_DIRECTORY) || readUint16LE(end, offset + 20) !== last - offset) {
+      continue;
+    }
+    if (++candidates > MAX_ZIP_END_RECORD_CANDIDATES) {
+      return;
+    }
+    const disk = readUint16LE(end, offset + 4);
+    const directoryDisk = readUint16LE(end, offset + 6);
+    const entries = readUint16LE(end, offset + 10);
+    const directorySize = readUint32LE(end, offset + 12);
+    const directoryOffset = readUint32LE(end, offset + 16);
+    if (disk !== 0 || directoryDisk !== 0 || entries === null || entries === 65535 || directorySize === null || directorySize === 4294967295 || directorySize > MAX_ZIP_DIRECTORY_BYTES || directoryOffset === null || directoryOffset === 4294967295) {
+      continue;
+    }
+    yield { recordOffset: offset, entries, directorySize, directoryOffset };
+  }
+}
+function findZipCentralDirectory(tail) {
+  for (const record of zipEndRecords(tail)) {
+    if (record.entries > 0 && record.directorySize > 0) {
+      return { offset: record.directoryOffset, size: record.directorySize };
+    }
+  }
+  return null;
+}
+function readZipEntryNames(end, { recordOffset, entries, directorySize }) {
+  let offset = recordOffset - directorySize;
+  if (offset < 0) {
+    return null;
+  }
+  const names = [];
+  for (let i = 0; i < entries; i++) {
+    if (!hasBytesAt(end, offset, ZIP_CENTRAL_HEADER)) {
+      return null;
+    }
+    const nameLength = readUint16LE(end, offset + 28);
+    const extraLength = readUint16LE(end, offset + 30);
+    const commentLength = readUint16LE(end, offset + 32);
+    if (nameLength === null || extraLength === null || commentLength === null) {
+      return null;
+    }
+    const nameStart = offset + ZIP_CENTRAL_HEADER_SIZE;
+    const name = ascii(end, nameStart, nameStart + nameLength);
+    offset = nameStart + nameLength + extraLength + commentLength;
+    if (name === null || offset > recordOffset) {
+      return null;
+    }
+    names.push(name);
+  }
+  return offset === recordOffset ? names : null;
+}
+function classifyOfficeOpenXml(entryNames) {
+  const names = entryNames.map((name) => name.toLowerCase());
+  if (!names.includes("[content_types].xml")) {
+    return null;
+  }
+  const families = [
+    { prefix: "word/", plain: DOCX, macro: DOCM },
+    { prefix: "xl/", plain: XLSX, macro: XLSM },
+    { prefix: "ppt/", plain: PPTX, macro: PPTM }
+  ].filter(({ prefix }) => names.some((name) => name.startsWith(prefix)));
+  if (families.length !== 1) {
+    return null;
+  }
+  const hasMacros = names.some(
+    (name) => name.endsWith("vbaproject.bin") || name.endsWith("vbadata.xml") || name.startsWith("xl/macrosheets/")
+  );
+  return hasMacros ? families[0].macro : families[0].plain;
+}
+function detectZip(bytes, tail) {
+  if (!hasBytesAt(bytes, 0, ZIP_LOCAL_HEADER)) {
+    return null;
+  }
+  const openDocument = detectOpenDocument(bytes);
+  if (openDocument) {
+    return openDocument;
+  }
+  const end = tail ?? bytes;
+  for (const record of zipEndRecords(end)) {
+    const names = readZipEntryNames(end, record);
+    const type = names && classifyOfficeOpenXml(names);
+    if (type) {
+      return type;
+    }
+  }
+  return null;
+}
+function detectContentType(bytes, options = {}) {
+  if (hasBytesAt(bytes, 0, [255, 216, 255])) {
+    return "image/jpeg";
+  }
+  if (hasBytesAt(bytes, 0, PNG_SIGNATURE)) {
+    return "image/png";
+  }
+  const head6 = ascii(bytes, 0, 6);
+  if (head6 === "GIF87a" || head6 === "GIF89a") {
+    return "image/gif";
+  }
+  if (ascii(bytes, 0, 4) === "RIFF" && ascii(bytes, 8, 12) === "WEBP") {
+    return "image/webp";
+  }
+  if (ascii(bytes, 0, 5) === "%PDF-") {
+    return "application/pdf";
+  }
+  const head4 = ascii(bytes, 0, 4);
+  if (head4 === "II*\0" || head4 === "MM\0*") {
+    return "image/tiff";
+  }
+  return detectIsoBmff(bytes) ?? detectEbml(bytes) ?? detectBmp(bytes) ?? detectZip(bytes, options.tail);
+}
+function isClaimedContentTypeAllowed(accept, claimedType) {
+  const claimed = canonicalContentType(claimedType);
+  if (!claimed || claimed.includes("*")) {
+    return false;
+  }
+  return isExplicitOnlyContentType(claimed) ? isContentTypeListed(accept, claimed) : isMimeTypeAllowed(accept, claimed);
+}
+function acceptedContentType(bytes, accept, claimedType, options = {}) {
+  const detected = detectContentType(bytes, options);
+  if (detected) {
+    const allowed = isExplicitOnlyContentType(detected) ? isContentTypeListed(accept, detected) : isMimeTypeAllowed(accept, detected);
+    return allowed ? detected : null;
+  }
+  if (!claimedType) {
+    return null;
+  }
+  const claimed = canonicalContentType(claimedType);
+  if (DETECTABLE_CONTENT_TYPES.has(claimed)) {
+    return null;
+  }
+  return isClaimedContentTypeAllowed(accept, claimed) ? claimed : null;
+}
+export {
+  DETECTABLE_CONTENT_TYPES,
+  DETECT_CONTENT_TYPE_BYTES,
+  DETECT_CONTENT_TYPE_TAIL_BYTES,
+  MAX_ZIP_DIRECTORY_BYTES,
+  acceptedContentType,
+  detectContentType,
+  findZipCentralDirectory,
+  isClaimedContentTypeAllowed
+};

package/dist/fastify/plugin.d.ts

@@ -47,6 +47,22 @@ export interface UploadPluginOptions {
      * origin, keeping in mind that the stored MIME type is client-asserted.
      */
     inlineTypes?: string[];
+    /**
+     * Checks each file's type by what its bytes are, using
+     * `acceptedContentType()`, instead of trusting the type the client
+     * claimed. On `POST {prefix}/fs`, a file the detector recognises is
+     * accepted when its detected type is in the profile's `allowedMimeTypes`;
+     * one it doesn't recognise is accepted on its claimed type, through a
+     * wildcard too, except that a claimed type the detector would have
+     * recognised is refused, and a type that can carry script (SVG, HTML,
+     * JavaScript, XML) must be listed exactly. Files are stored under the
+     * canonical spelling of the accepted type (`image/jpeg` for a claimed
+     * `image/jpg`). The S3 webhook checks objects' bytes against their
+     * declared type the same way `confirmUpload` does.
+     *
+     * Defaults to `true`. `false` checks the claimed type only.
+     */
+    verifyContentType?: boolean;
 }
 /**
  * Registers the upload routes on a Fastify server. Register it on the

package/dist/fastify/plugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../../src/fastify/plugin.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,eAAe,EAAgC,MAAM,SAAS,CAAA;AAE5E,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAA;AAgB9D,OAAO,KAAK,EAEV,cAAc,EACd,cAAc,EAEf,MAAM,aAAa,CAAA;AAIpB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAA;AA4B1D,MAAM,WAAW,mBAAmB;IAClC;;;;OAIG;IACH,WAAW,EAAE,MAAM,GAAG,SAAS,CAAA;IAC/B,iCAAiC;IACjC,OAAO,EAAE,cAAc,CAAA;IACvB,EAAE,EAAE,cAAc,CAAA;IAClB,2CAA2C;IAC3C,MAAM,CAAC,EAAE,MAAM,CAAA;IACf;;;;;OAKG;IACH,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB;;;;;OAKG;IACH,YAAY,CAAC,EAAE,mBAAmB,CAAA;IAClC;;;OAGG;IACH,SAAS,CAAC,EAAE;QACV,QAAQ,EAAE,MAAM,CAAA;QAChB,gBAAgB,CAAC,EAAE,gBAAgB,CAAA;QACnC,KAAK,CAAC,EAAE,OAAO,KAAK,CAAA;KACrB,CAAA;IACD,6EAA6E;IAC7E,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAC1B;;;;;;OAMG;IACH,WAAW,CAAC,EAAE,MAAM,EAAE,CAAA;CACvB;AAgCD;;;;;;;;GAQG;AACH,wBAAsB,kBAAkB,CACtC,OAAO,EAAE,eAAe,EACxB,OAAO,EAAE,mBAAmB,GAC3B,OAAO,CAAC,IAAI,CAAC,CA8Qf"}
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../../src/fastify/plugin.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,eAAe,EAAgC,MAAM,SAAS,CAAA;AAE5E,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAA;AAiB9D,OAAO,KAAK,EAEV,cAAc,EACd,cAAc,EAEf,MAAM,aAAa,CAAA;AAIpB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAA;AA4B1D,MAAM,WAAW,mBAAmB;IAClC;;;;OAIG;IACH,WAAW,EAAE,MAAM,GAAG,SAAS,CAAA;IAC/B,iCAAiC;IACjC,OAAO,EAAE,cAAc,CAAA;IACvB,EAAE,EAAE,cAAc,CAAA;IAClB,2CAA2C;IAC3C,MAAM,CAAC,EAAE,MAAM,CAAA;IACf;;;;;OAKG;IACH,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB;;;;;OAKG;IACH,YAAY,CAAC,EAAE,mBAAmB,CAAA;IAClC;;;OAGG;IACH,SAAS,CAAC,EAAE;QACV,QAAQ,EAAE,MAAM,CAAA;QAChB,gBAAgB,CAAC,EAAE,gBAAgB,CAAA;QACnC,KAAK,CAAC,EAAE,OAAO,KAAK,CAAA;KACrB,CAAA;IACD,6EAA6E;IAC7E,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAC1B;;;;;;OAMG;IACH,WAAW,CAAC,EAAE,MAAM,EAAE,CAAA;IACtB;;;;;;;;;;;;;;OAcG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAA;CAC5B;AA+DD;;;;;;;;GAQG;AACH,wBAAsB,kBAAkB,CACtC,OAAO,EAAE,eAAe,EACxB,OAAO,EAAE,mBAAmB,GAC3B,OAAO,CAAC,IAAI,CAAC,CA2Rf"}

package/dist/fastify/plugin.js

@@ -1,5 +1,6 @@
 import fastifyMultipart from "@fastify/multipart";
 import { deleteFile } from "../deleteFile.js";
+import { acceptedContentType, detectContentType } from "../detectContentType.js";
 import { UploadError } from "../errors.js";
 import { generateStorageKey, trimTrailingSlashes } from "../keys.js";
 import {
@@ -43,6 +44,22 @@ function headerValue(req, name) {
 function normalizeMimeType(mimeType) {
   return mimeType.split(";")[0].trim().toLowerCase();
 }
+function verifiedContentType(payload, data, claimedType) {
+  const mimeType = acceptedContentType(
+    data,
+    payload.allowedMimeTypes,
+    claimedType
+  );
+  if (mimeType) {
+    return mimeType;
+  }
+  const detected = detectContentType(data);
+  const what = detected ? `'${detected}'` : `of a type that couldn't be recognised (claimed '${claimedType}')`;
+  throw new UploadError(
+    "MIME_TYPE_NOT_ALLOWED",
+    `File is ${what}, which is not allowed for upload profile '${payload.profile}'.`
+  );
+}
 function contentDispositionHeader(disposition, filename) {
   const ascii = filename.replace(/[^\x20-\x7e]/g, "_").replace(/["\\]/g, "_");
   const encoded = encodeURIComponent(filename);
@@ -58,7 +75,8 @@ async function cedarUploadsPlugin(fastify, options) {
     authenticate,
     s3Webhook,
     serveCacheControl = "private, max-age=3600",
-    inlineTypes = []
+    inlineTypes = [],
+    verifyContentType = true
   } = options;
   const allowedInlineTypes = new Set(inlineTypes.map(normalizeMimeType));
   if (!tokenSecret) {
@@ -120,7 +138,12 @@ async function cedarUploadsPlugin(fastify, options) {
         if (part.type !== "file") {
           continue;
         }
-        assertTokenAllowsFile(payload, { contentType: part.mimetype, size: 0n });
+        if (!verifyContentType) {
+          assertTokenAllowsFile(payload, {
+            contentType: part.mimetype,
+            size: 0n
+          });
+        }
         let data;
         try {
           data = await part.toBuffer();
@@ -134,18 +157,19 @@ async function cedarUploadsPlugin(fastify, options) {
           throw e;
         }
         const size = BigInt(data.byteLength);
-        assertTokenAllowsFile(payload, { contentType: part.mimetype, size });
-        const storageKey = generateStorageKey(part.mimetype);
+        const mimeType = verifyContentType ? verifiedContentType(payload, data, part.mimetype) : part.mimetype;
+        assertTokenAllowsFile(payload, { contentType: mimeType, size });
+        const storageKey = generateStorageKey(mimeType);
         const upload = await createPendingUpload({
           db,
           payload,
           filename: part.filename,
-          mimeType: part.mimetype,
+          mimeType,
           size,
           storageKey
         });
         stored.push({ target: payload.target, upload });
-        await target.write(storageKey, data, { contentType: part.mimetype });
+        await target.write(storageKey, data, { contentType: mimeType });
         const { count } = await db.upload.updateMany({
           where: { id: upload.id, status: "pending" },
           data: { status: "completed" }
@@ -229,7 +253,8 @@ async function cedarUploadsPlugin(fastify, options) {
           targets,
           topicArn: s3Webhook.topicArn,
           fetchCertificate: s3Webhook.fetchCertificate,
-          fetch: s3Webhook.fetch
+          fetch: s3Webhook.fetch,
+          verifyContentType
         });
         return reply.code(200).send(result);
       } catch (e) {

package/dist/index.d.ts

@@ -4,6 +4,9 @@ export type { UploadErrorCode } from './errors.js';
 export { defineStorageTargets, resolveTarget } from './targets.js';
 export { DB_MAX_FILE_SIZE, DEFAULT_UPLOAD_TOKEN_EXPIRES_IN, defineUploadProfiles, isMimeTypeAllowed, resolveProfile, } from './profiles.js';
 export type { ResolvedUploadProfile, UploadProfile, UploadProfiles, } from './profiles.js';
+export { acceptedContentType, DETECT_CONTENT_TYPE_BYTES, DETECT_CONTENT_TYPE_TAIL_BYTES, DETECTABLE_CONTENT_TYPES, detectContentType, findZipCentralDirectory, isClaimedContentTypeAllowed, MAX_ZIP_DIRECTORY_BYTES, } from './detectContentType.js';
+export type { DetectContentTypeOptions } from './detectContentType.js';
+export { canonicalContentType, CONTENT_TYPE_ALIASES, isExplicitOnlyContentType, isScriptableContentType, MACRO_CONTENT_TYPES, SCRIPTABLE_CONTENT_TYPES, } from './contentTypes.js';
 export { createFsProvider } from './providers/fs.js';
 export type { FsProviderOptions } from './providers/fs.js';
 export { createDbProvider } from './providers/db.js';
@@ -28,7 +31,7 @@ export type { CreateUploadAuthenticatorOptions, UploadAuthenticator, UploadReque
 export { cedarUploadsPlugin } from './fastify/plugin.js';
 export type { UploadPluginOptions } from './fastify/plugin.js';
 export { handleS3Webhook, processS3EventRecord } from './webhooks/s3.js';
-export type { S3Event, S3EventOutcome, S3EventRecord, S3WebhookOptions, S3WebhookResult, } from './webhooks/s3.js';
+export type { ProcessS3EventRecordOptions, S3Event, S3EventOutcome, S3EventRecord, S3WebhookOptions, S3WebhookResult, } from './webhooks/s3.js';
 export { verifySnsMessage } from './webhooks/sns.js';
 export type { SnsMessage } from './webhooks/sns.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAA;AAC1B,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AACzC,YAAY,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAClD,OAAO,EAAE,oBAAoB,EAAE,aAAa,EAAE,MAAM,cAAc,CAAA;AAClE,OAAO,EACL,gBAAgB,EAChB,+BAA+B,EAC/B,oBAAoB,EACpB,iBAAiB,EACjB,cAAc,GACf,MAAM,eAAe,CAAA;AACtB,YAAY,EACV,qBAAqB,EACrB,aAAa,EACb,cAAc,GACf,MAAM,eAAe,CAAA;AACtB,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAA;AACpD,YAAY,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAA;AAC1D,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAA;AACpD,OAAO,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAA;AAC9C,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAC1C,YAAY,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAA;AACtD,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAC5C,YAAY,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAA;AACxD,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAA;AAC9D,YAAY,EACV,0BAA0B,EAC1B,yBAAyB,GAC1B,MAAM,0BAA0B,CAAA;AACjC,OAAO,EACL,iBAAiB,EACjB,mBAAmB,EACnB,oBAAoB,EACpB,iBAAiB,GAClB,MAAM,kBAAkB,CAAA;AACzB,YAAY,EACV,wBAAwB,EACxB,kBAAkB,GACnB,MAAM,kBAAkB,CAAA;AACzB,OAAO,EACL,gBAAgB,EAChB,mBAAmB,EACnB,gBAAgB,GACjB,MAAM,iBAAiB,CAAA;AACxB,YAAY,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAA;AACxD,OAAO,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAC3D,OAAO,EACL,aAAa,EACb,qBAAqB,EACrB,gBAAgB,GACjB,MAAM,eAAe,CAAA;AACtB,YAAY,EACV,oBAAoB,EACpB,0BAA0B,EAC1B,4BAA4B,EAC5B,uBAAuB,EACvB,uBAAuB,EACvB,WAAW,EACX,mBAAmB,GACpB,MAAM,eAAe,CAAA;AACtB,OAAO,EACL,iCAAiC,EACjC,0BAA0B,EAC1B,4BAA4B,EAC5B,qBAAqB,EACrB,wBAAwB,EACxB,wBAAwB,EACxB,iBAAiB,EACjB,mBAAmB,GACpB,MAAM,iBAAiB,CAAA;AACxB,YAAY,EACV,kCAAkC,EAClC,yBAAyB,EACzB,6BAA6B,GAC9B,MAAM,iBAAiB,CAAA;AACxB,OAAO,EAAE,yBAAyB,EAAE,MAAM,oBAAoB,CAAA;AAC9D,YAAY,EACV,gCAAgC,EAChC,mBAAmB,EACnB,iBAAiB,GAClB,MAAM,oBAAoB,CAAA;AAC3B,OAAO,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAA;AACxD,YAAY,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAA;AAC9D,OAAO,EAAE,eAAe,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AACxE,YAAY,EACV,OAAO,EACP,cAAc,EACd,aAAa,EACb,gBAAgB,EAChB,eAAe,GAChB,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAA;AACpD,YAAY,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/index.js

@@ -8,6 +8,24 @@ import {
   isMimeTypeAllowed,
   resolveProfile
 } from "./profiles.js";
+import {
+  acceptedContentType,
+  DETECT_CONTENT_TYPE_BYTES,
+  DETECT_CONTENT_TYPE_TAIL_BYTES,
+  DETECTABLE_CONTENT_TYPES,
+  detectContentType,
+  findZipCentralDirectory,
+  isClaimedContentTypeAllowed,
+  MAX_ZIP_DIRECTORY_BYTES
+} from "./detectContentType.js";
+import {
+  canonicalContentType,
+  CONTENT_TYPE_ALIASES,
+  isExplicitOnlyContentType,
+  isScriptableContentType,
+  MACRO_CONTENT_TYPES,
+  SCRIPTABLE_CONTENT_TYPES
+} from "./contentTypes.js";
 import { createFsProvider } from "./providers/fs.js";
 import { createDbProvider } from "./providers/db.js";
 import { generateStorageKey } from "./keys.js";
@@ -46,13 +64,22 @@ import { cedarUploadsPlugin } from "./fastify/plugin.js";
 import { handleS3Webhook, processS3EventRecord } from "./webhooks/s3.js";
 import { verifySnsMessage } from "./webhooks/sns.js";
 export {
+  CONTENT_TYPE_ALIASES,
   DB_MAX_FILE_SIZE,
   DEFAULT_UPLOAD_TOKEN_EXPIRES_IN,
+  DETECTABLE_CONTENT_TYPES,
+  DETECT_CONTENT_TYPE_BYTES,
+  DETECT_CONTENT_TYPE_TAIL_BYTES,
+  MACRO_CONTENT_TYPES,
+  MAX_ZIP_DIRECTORY_BYTES,
+  SCRIPTABLE_CONTENT_TYPES,
   SERVE_TOKEN_PURPOSE,
   UPLOAD_TOKEN_CONTEXT_KEY,
   UPLOAD_TOKEN_HEADER,
   UPLOAD_TOKEN_PURPOSE,
   UploadError,
+  acceptedContentType,
+  canonicalContentType,
   cedarUploadsPlugin,
   cleanupStaleUploads,
   confirmUpload,
@@ -68,10 +95,15 @@ export {
   defineStorageTargets,
   defineUploadProfiles,
   deleteFile,
+  detectContentType,
+  findZipCentralDirectory,
   generateStorageKey,
   getUploadTokenPayload,
   handleS3Webhook,
+  isClaimedContentTypeAllowed,
+  isExplicitOnlyContentType,
   isMimeTypeAllowed,
+  isScriptableContentType,
   issueUploadToken,
   processS3EventRecord,
   requireUploadTokenSchema,

package/dist/keys.d.ts

@@ -1,7 +1,9 @@
 /**
  * A fresh storage key: a random id plus the extension that matches
  * `mimeType`, when one is known. Keys never derive from the client's
- * filename.
+ * filename. Aliased types are looked up under every spelling, so the
+ * registered `video/matroska` gets the `.mkv` the database only knows for
+ * `video/x-matroska`.
  */
 export declare function generateStorageKey(mimeType: string): string;
 /**

package/dist/keys.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"keys.d.ts","sourceRoot":"","sources":["../src/keys.ts"],"names":[],"mappings":"AAMA;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAI3D;AAID;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,QAIxC;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAQzD"}
+{"version":3,"file":"keys.d.ts","sourceRoot":"","sources":["../src/keys.ts"],"names":[],"mappings":"AAOA;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAM3D;AAID;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,QAIxC;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAQzD"}

package/dist/keys.js

@@ -1,8 +1,9 @@
 import { randomUUID } from "node:crypto";
 import mime from "mime-types";
+import { canonicalContentType, contentTypeSpellings } from "./contentTypes.js";
 import { UploadError } from "./errors.js";
 function generateStorageKey(mimeType) {
-  const ext = mime.extension(mimeType.split(";")[0].trim());
+  const ext = contentTypeSpellings(canonicalContentType(mimeType)).map((type) => mime.extension(type)).find(Boolean);
   return ext ? `${randomUUID()}.${ext}` : randomUUID();
 }
 const SAFE_KEY = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;