@postfetch/core 0.6.0 → 0.8.0

package/dist/index.js

@@ -1,3 +1,6 @@
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
 // src/internal.ts
 class PostfetchError extends Error {
   status;
@@ -162,13 +165,18 @@ function instagramAppUserAgent() {
 
 // src/facebook.ts
 async function resolveFacebook(input) {
-  const canonical = await canonicalUrl(input.net, input.url);
+  const page = await canonicalPage(input.net, normalizedInputUrl(input.url));
+  const canonical = page.url;
   const id = facebookId(canonical) ?? facebookId(input.url) ?? "video";
-  const embed = await embedVideo(input.net, canonical);
-  const watch = !embed && /^\d+$/.test(id) ? await watchVideo(input.net, id) : null;
+  const pageMetadata = facebookMetadata(page.html);
+  const embed = await embedVideo(input.net, canonical, input.preferredWidth);
+  const watch = !embed && /^\d+$/.test(id) ? await watchVideo(input.net, id, input.preferredWidth) : null;
   const url = embed ?? watch?.url ?? null;
   if (!url) {
-    throw new Error("Facebook video not found");
+    if (pageMetadata?.text) {
+      return { archiveFilename: filename(`facebook_${id}.zip`), id, items: [], metadata: pageMetadata, platform: "facebook" };
+    }
+    throw new PostfetchError(404, "Facebook video not found", "notFound");
   }
   const item = {
     filename: filename(`facebook_${id}.mp4`),
@@ -179,7 +187,18 @@ async function resolveFacebook(input) {
     platform: "facebook",
     url
   };
-  return { archiveFilename: filename(`facebook_${id}.zip`), id, items: [item], metadata: watch?.metadata, platform: "facebook" };
+  return {
+    archiveFilename: filename(`facebook_${id}.zip`),
+    id,
+    items: [item],
+    metadata: mergeMetadata(pageMetadata, watch?.metadata),
+    platform: "facebook"
+  };
+}
+function normalizedInputUrl(input) {
+  const url = asUrl(input);
+  const share = url.pathname.match(/^\/share\/([a-z])\/([A-Za-z0-9]+)/i);
+  return share ? `${url.origin}/share/${share[1]}/${share[2]}/` : input;
 }
 function navigationHeaders2() {
   return {
@@ -188,30 +207,38 @@ function navigationHeaders2() {
     "user-agent": browserUserAgent()
   };
 }
-async function canonicalUrl(net, input) {
+async function canonicalPage(net, input) {
   const response = await net(input, { headers: navigationHeaders2() });
-  const resolved = asUrl(response.url);
-  return `${resolved.origin}${resolved.pathname}`;
+  const resolved = asUrl(response.url || input);
+  return {
+    html: response.ok ? await response.text() : "",
+    url: `${resolved.origin}${resolved.pathname}`
+  };
 }
-async function embedVideo(net, canonical) {
+async function embedVideo(net, canonical, preferredWidth) {
   const embed = `https://www.facebook.com/plugins/video.php?href=${encodeURIComponent(canonical)}`;
   const response = await net(embed, { headers: navigationHeaders2() });
   if (!response.ok) {
     return null;
   }
   const html = await response.text();
-  return source(html, "hd_src") ?? source(html, "sd_src");
+  return preferredSource(preferredWidth, source(html, "hd_src"), source(html, "sd_src"));
 }
-async function watchVideo(net, id) {
+async function watchVideo(net, id, preferredWidth) {
   const headers = { ...navigationHeaders2(), accept: "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8" };
   const response = await net(`https://www.facebook.com/watch/?v=${id}&_rdr`, { headers });
   if (!response.ok) {
     return null;
   }
   const html = await response.text();
-  const url = source(html, "playable_url_quality_hd") ?? source(html, "browser_native_hd_url") ?? source(html, "playable_url") ?? source(html, "browser_native_sd_url");
+  const hd = source(html, "playable_url_quality_hd") ?? source(html, "browser_native_hd_url");
+  const sd = source(html, "playable_url") ?? source(html, "browser_native_sd_url");
+  const url = preferredSource(preferredWidth, hd, sd);
   return url ? { url, metadata: watchMetadata(html) } : null;
 }
+function preferredSource(preferredWidth, hd, sd) {
+  return preferredWidth >= 540 ? hd ?? sd : sd ?? hd;
+}
 function watchMetadata(html) {
   const owner = html.match(/"name":("(?:\\.|[^"\\])*"),"__isVideoOwner"/);
   const name = owner ? JSON.parse(owner[1]) : undefined;
@@ -221,6 +248,63 @@ function watchMetadata(html) {
     viewCount: count(html.match(/"video_view_count":(\d+)/)?.[1])
   };
 }
+function facebookMetadata(html) {
+  const canonical = metaContent(html, "og:url");
+  if (!canonical || !facebookPostUrl(canonical)) {
+    return;
+  }
+  const text = metaContent(html, "og:description") ?? metaContent(html, "description");
+  const name = metaContent(html, "og:title");
+  if (!text && !name) {
+    return;
+  }
+  return {
+    text: text ?? undefined,
+    author: name ? { name } : undefined
+  };
+}
+function facebookPostUrl(input) {
+  try {
+    const url = new URL(input);
+    return /\/posts\/(?:[^/]+\/)?[A-Za-z0-9]+\/?$/.test(url.pathname) || /\/share\/p\/[A-Za-z0-9]+\/?$/.test(url.pathname) || (url.pathname === "/permalink.php" || url.pathname === "/story.php") && Boolean(url.searchParams.get("story_fbid"));
+  } catch {
+    return false;
+  }
+}
+function metaContent(html, key) {
+  for (const match of html.matchAll(/<meta\b[^>]*>/gi)) {
+    const tag = match[0];
+    if ((attribute(tag, "property") ?? attribute(tag, "name")) !== key) {
+      continue;
+    }
+    const content = attribute(tag, "content");
+    return content ? decodeHtml(content) : null;
+  }
+  return null;
+}
+function attribute(tag, name) {
+  const match = tag.match(new RegExp(`\\b${name}\\s*=\\s*(["'])(.*?)\\1`, "is"));
+  return match?.[2] ?? null;
+}
+function decodeHtml(input) {
+  const named = { amp: "&", apos: "'", gt: ">", lt: "<", nbsp: " ", quot: '"' };
+  return input.replace(/&(#x[\da-f]+|#\d+|amp|apos|gt|lt|nbsp|quot);/gi, (entity, code) => {
+    if (code[0] !== "#") {
+      return named[code.toLowerCase()] ?? entity;
+    }
+    const value = code[1]?.toLowerCase() === "x" ? Number.parseInt(code.slice(2), 16) : Number.parseInt(code.slice(1), 10);
+    return Number.isSafeInteger(value) && value <= 1114111 ? String.fromCodePoint(value) : entity;
+  });
+}
+function mergeMetadata(page, watch) {
+  if (!page) {
+    return watch;
+  }
+  if (!watch) {
+    return page;
+  }
+  return { ...page, ...watch, author: watch.author ?? page.author };
+}
 function source(html, key) {
   const match = html.match(new RegExp(`"${key}":("(?:\\\\.|[^"\\\\])*")`));
   if (!match) {
@@ -799,7 +883,7 @@ function parseJson(value) {
     return JSON.parse(value);
   } catch {
     try {
-      return JSON.parse(decodeHtml(value));
+      return JSON.parse(decodeHtml2(value));
     } catch {
       return null;
     }
@@ -834,7 +918,7 @@ function bestVideoUrl(html) {
   }
   let parsed;
   try {
-    parsed = JSON.parse(decodeHtml(encoded));
+    parsed = JSON.parse(decodeHtml2(encoded));
   } catch {
     return null;
   }
@@ -871,7 +955,7 @@ function linkedinHandle(value) {
     return null;
   }
 }
-function decodeHtml(value) {
+function decodeHtml2(value) {
   return value.replace(/&(quot|amp|lt|gt|#39|#x27|#(\d+)|#x([0-9a-f]+));/gi, (_entity, name, decimal, hex) => {
     switch (name.toLowerCase()) {
       case "quot":
@@ -1531,7 +1615,7 @@ function extensionOf(mime) {
 
 // src/soundcloud.ts
 async function resolveSoundcloud(input) {
-  const url = await canonicalUrl2(input.net, input.url);
+  const url = await canonicalUrl(input.net, input.url);
   const clientId = await appClientId(input.net);
   const track = await resolveTrack(input.net, url, clientId);
   const id = trackId(track);
@@ -1557,7 +1641,7 @@ function soundcloudMetadata(track) {
     }
   };
 }
-async function canonicalUrl2(net, input) {
+async function canonicalUrl(net, input) {
   const host = asUrl(input).hostname;
   if (host !== "on.soundcloud.com" && host !== "snd.sc") {
     return input;
@@ -1925,15 +2009,28 @@ async function resolveTwitter(input) {
   if (string(tweet.__typename) === "TweetTombstone") {
     throw new Error("Tweet is unavailable or age-restricted");
   }
-  const media = Array.isArray(tweet.mediaDetails) ? tweet.mediaDetails.filter(object) : [];
-  const items = media.flatMap((entry, index) => twitterItem(entry, id, index + 1));
-  if (items.length === 0) {
-    throw new Error("Twitter media not found");
-  }
+  const groups = twitterTweets(tweet, id).flatMap(({ id: postId2, tweet: post }) => {
+    const media = Array.isArray(post.mediaDetails) ? post.mediaDetails.filter(object) : [];
+    return media.flatMap((entry, index) => {
+      const candidates = twitterCandidates(entry, postId2, index + 1);
+      return candidates.length > 0 ? [candidates] : [];
+    });
+  });
+  const items = input.tryMaxBytes === undefined ? groups.map((group) => group[0].item) : await sizeLimitedItems(input, groups);
   return { archiveFilename: filename(`twitter_${id}.zip`), id, items, metadata: twitterMetadata(tweet), platform: "twitter" };
 }
 function twitterMetadata(tweet) {
   const user = object(tweet.user) ? tweet.user : null;
+  const extra = {};
+  const lang = string(tweet.lang);
+  if (lang) {
+    extra.lang = lang;
+  }
+  const quotedTweet = object(tweet.quoted_tweet) ? tweet.quoted_tweet : null;
+  const quotedId = quotedTweet ? string(quotedTweet.id_str) : null;
+  if (quotedTweet && quotedId) {
+    extra.quotedTweet = { id: quotedId, metadata: twitterMetadata(quotedTweet) };
+  }
   return {
     text: string(tweet.text) ?? string(tweet.full_text) ?? undefined,
     author: user ? {
@@ -1947,9 +2044,26 @@ function twitterMetadata(tweet) {
     shareCount: count(tweet.retweet_count),
     viewCount: count(tweet.view_count),
     nsfw: bool(tweet.possibly_sensitive),
-    extra: { lang: string(tweet.lang) ?? undefined }
+    extra
   };
 }
+function twitterTweets(tweet, rootId) {
+  const tweets = [];
+  const seen = new Set;
+  let current = tweet;
+  let fallbackId = rootId;
+  while (current) {
+    const id = string(current.id_str) ?? fallbackId;
+    if (!id || seen.has(id)) {
+      break;
+    }
+    tweets.push({ id, tweet: current });
+    seen.add(id);
+    current = object(current.quoted_tweet) ? current.quoted_tweet : null;
+    fallbackId = null;
+  }
+  return tweets;
+}
 async function syndication(net, id) {
   const url = `https://cdn.syndication.twimg.com/tweet-result?id=${id}&lang=en&token=${syndicationToken(id)}`;
   const response = await net(url, { headers: { accept: "application/json", "user-agent": browserUserAgent() } });
@@ -1965,25 +2079,92 @@ async function syndication(net, id) {
 function syndicationToken(id) {
   return (Number(id) / 1000000000000000 * Math.PI).toString(36).replace(/(0+|\.)/g, "");
 }
-function twitterItem(entry, id, index) {
+function twitterCandidates(entry, id, index) {
   const headers = { "user-agent": browserUserAgent() };
   const type = string(entry.type);
   if (type === "video" || type === "animated_gif") {
-    const url = bestVariant(entry);
-    return url ? [{ filename: filename(`twitter_${id}_${index}.mp4`), headers, id, kind: "video", mime: "video/mp4", platform: "twitter", url }] : [];
+    return videoVariants(entry).map(({ bitrate, url }) => ({
+      bitrate,
+      item: { filename: filename(`twitter_${id}_${index}.mp4`), headers, id, kind: "video", mime: "video/mp4", platform: "twitter", url }
+    }));
   }
   const photo = string(entry.media_url_https);
-  return photo ? [{ filename: filename(`twitter_${id}_${index}.jpg`), headers, id, kind: "image", mime: "image/jpeg", platform: "twitter", url: `${photo}?name=orig` }] : [];
+  return photo ? [{ bitrate: 0, item: { filename: filename(`twitter_${id}_${index}.jpg`), headers, id, kind: "image", mime: "image/jpeg", platform: "twitter", url: `${photo}?name=orig` } }] : [];
 }
-function bestVariant(entry) {
+function videoVariants(entry) {
   const info = object(entry.video_info) ? entry.video_info : null;
   const variants = info && Array.isArray(info.variants) ? info.variants.filter(object) : [];
-  const best = variants.filter((variant) => string(variant.content_type) === "video/mp4").reduce((current, variant) => {
-    const bitrate = number(variant.bitrate) ?? 0;
-    const currentBitrate = current ? number(current.bitrate) ?? 0 : -1;
-    return bitrate > currentBitrate ? variant : current;
-  }, null);
-  return best ? string(best.url) : null;
+  const seen = new Set;
+  return variants.flatMap((variant) => {
+    const url = string(variant.url);
+    if (string(variant.content_type) !== "video/mp4" || !url || seen.has(url)) {
+      return [];
+    }
+    seen.add(url);
+    return [{ bitrate: number(variant.bitrate) ?? 0, url }];
+  }).sort((left, right) => right.bitrate - left.bitrate);
+}
+async function sizeLimitedItems(input, groups) {
+  if (groups.length === 0 || input.tryMaxBytes === undefined) {
+    return groups.map((group) => group[0].item);
+  }
+  const sizes = new Map;
+  const size = (candidate) => {
+    const existing = sizes.get(candidate.item.url);
+    if (existing) {
+      return existing;
+    }
+    const pending = contentLength(input.net, candidate.item);
+    sizes.set(candidate.item.url, pending);
+    return pending;
+  };
+  const highest = groups.map((group) => group[0]);
+  const highestSizes = await Promise.all(highest.map(size));
+  const highestTotal = knownTotal(highestSizes);
+  if (highestTotal !== null && highestTotal <= input.tryMaxBytes) {
+    return highest.map(({ item }) => item);
+  }
+  const sized = await Promise.all(groups.map(async (group) => Promise.all(group.map(async (candidate) => ({ ...candidate, bytes: await size(candidate) })))));
+  const fitting = bestFitting(sized, input.tryMaxBytes);
+  return (fitting ?? groups.map((group) => group.at(-1))).map(({ item }) => item);
+}
+function knownTotal(sizes) {
+  return sizes.some((size) => size === null) ? null : sizes.reduce((total, size) => total + (size ?? 0), 0);
+}
+function bestFitting(groups, maxBytes) {
+  let selections = [
+    { bytes: 0, candidates: [], quality: 0 }
+  ];
+  for (const group of groups) {
+    selections = selections.flatMap((selection) => group.flatMap((candidate) => {
+      if (candidate.bytes === null || selection.bytes + candidate.bytes > maxBytes) {
+        return [];
+      }
+      return [{
+        bytes: selection.bytes + candidate.bytes,
+        candidates: [...selection.candidates, candidate],
+        quality: selection.quality + candidate.bitrate
+      }];
+    }));
+    if (selections.length === 0) {
+      return null;
+    }
+  }
+  const best = selections.reduce((current, selection) => selection.quality > current.quality ? selection : current);
+  return best.candidates;
+}
+async function contentLength(net, item) {
+  try {
+    const response = await net(item.url, { headers: item.headers, method: "HEAD" }, 1);
+    const raw = response.ok ? response.headers.get("content-length") : null;
+    if (!raw || !/^\d+$/.test(raw)) {
+      return null;
+    }
+    const bytes = Number(raw);
+    return Number.isSafeInteger(bytes) ? bytes : null;
+  } catch {
+    return null;
+  }
 }
 function tweetId(input) {
   return asUrl(input).pathname.match(/\/status(?:es)?\/(\d+)/)?.[1] ?? null;
@@ -2215,12 +2396,20 @@ async function postfetch(url, options = {}) {
   if (trimmed.length === 0) {
     throw new PostfetchError(400, "url is required");
   }
+  if (options.tryMaxBytes !== undefined && (!Number.isSafeInteger(options.tryMaxBytes) || options.tryMaxBytes <= 0)) {
+    throw new PostfetchError(400, "tryMaxBytes must be a positive integer");
+  }
   const context = {
     net: createNet(options.fetch ?? globalThis.fetch),
     preferredWidth: options.preferredWidth ?? 720,
+    tryMaxBytes: options.tryMaxBytes,
     url: trimmed
   };
-  switch (detect(trimmed)) {
+  const result = await resolve(context);
+  return options.tryMaxBytes === undefined || result.platform === "twitter" ? result : trySmaller(context, result, options.tryMaxBytes);
+}
+async function resolve(context) {
+  switch (detect(context.url)) {
     case "facebook":
       return resolveFacebook(context);
     case "instagram":
@@ -2241,6 +2430,58 @@ async function postfetch(url, options = {}) {
       return resolveYoutube(context);
   }
 }
+async function trySmaller(context, result, maxBytes) {
+  const originalBytes = await resultBytes(context, result);
+  if (originalBytes === null || originalBytes <= maxBytes) {
+    return result;
+  }
+  try {
+    const smaller = await resolve({ ...context, preferredWidth: 1 });
+    if (sameMedia(result, smaller)) {
+      return result;
+    }
+    const smallerBytes = await resultBytes(context, smaller);
+    return smallerBytes !== null && smallerBytes < originalBytes ? smaller : result;
+  } catch {
+    return result;
+  }
+}
+async function resultBytes(context, result) {
+  const sizes = await Promise.all(result.items.map((item) => itemBytes(context, item)));
+  if (sizes.some((size) => size === null)) {
+    return null;
+  }
+  return sizes.reduce((total, size) => total + (size ?? 0), 0);
+}
+async function itemBytes(context, item) {
+  if (item.hls) {
+    return null;
+  }
+  const [video, audio] = await Promise.all([
+    contentLength2(context, item.url, item.headers),
+    item.audio ? contentLength2(context, item.audio.url, item.audio.headers) : Promise.resolve(0)
+  ]);
+  return video === null || audio === null ? null : video + audio;
+}
+async function contentLength2(context, url, headers) {
+  try {
+    const response = await context.net(url, { headers, method: "HEAD" }, 1);
+    const raw = response.ok ? response.headers.get("content-length") : null;
+    if (!raw || !/^\d+$/.test(raw)) {
+      return null;
+    }
+    const bytes = Number(raw);
+    return Number.isSafeInteger(bytes) ? bytes : null;
+  } catch {
+    return null;
+  }
+}
+function sameMedia(left, right) {
+  return left.items.length === right.items.length && left.items.every((item, index) => {
+    const other = right.items[index];
+    return item.url === other?.url && item.audio?.url === other.audio?.url;
+  });
+}
 function detect(url) {
   const host = asUrl(url).hostname;
   if (host.includes("tiktok.com")) {
@@ -2272,6 +2513,83 @@ function detect(url) {
   }
   throw new PostfetchError(400, "only Facebook, Instagram, LinkedIn, Pinterest, Reddit, SoundCloud, TikTok, X and YouTube URLs are supported");
 }
+// src/mp4-remux.ts
+async function remuxMp4(bytes, ffmpegPath = "ffmpeg", runtime) {
+  let directory;
+  let io;
+  try {
+    io = runtime ?? await nodeRuntime();
+    directory = await io.makeTempDir("postfetch-remux-");
+    const inputPath = `${directory}/input.mp4`;
+    const outputPath = `${directory}/output.mp4`;
+    await io.writeFile(inputPath, bytes);
+    const result = await io.run(ffmpegPath, [
+      "-nostdin",
+      "-hide_banner",
+      "-loglevel",
+      "error",
+      "-y",
+      "-i",
+      inputPath,
+      "-map",
+      "0:v:0",
+      "-map",
+      "0:a:0?",
+      "-c",
+      "copy",
+      "-movflags",
+      "+faststart",
+      "-avoid_negative_ts",
+      "make_zero",
+      "-use_editlist",
+      "0",
+      outputPath
+    ]);
+    if (!result.success) {
+      return null;
+    }
+    const output = await io.readFile(outputPath);
+    return output.length > 0 ? output : null;
+  } catch {
+    return null;
+  } finally {
+    if (directory && io) {
+      await io.removeDir(directory).catch(() => {
+        return;
+      });
+    }
+  }
+}
+async function nodeRuntime() {
+  const [{ spawn }, { mkdtemp, readFile, rm, writeFile }, { tmpdir }, { join }] = await Promise.all([
+    import("node:child_process"),
+    import("node:fs/promises"),
+    import("node:os"),
+    import("node:path")
+  ]);
+  return {
+    makeTempDir: (prefix) => mkdtemp(join(tmpdir(), prefix)),
+    readFile: async (path) => new Uint8Array(await readFile(path)),
+    removeDir: async (path) => {
+      await rm(path, { force: true, recursive: true });
+    },
+    run: (command, args) => new Promise((resolve2) => {
+      const child = spawn(command, args, { stdio: ["ignore", "ignore", "pipe"] });
+      let stderr = "";
+      child.stderr?.on("data", (chunk) => {
+        if (stderr.length < 4096) {
+          stderr += new TextDecoder().decode(chunk).slice(0, 4096 - stderr.length);
+        }
+      });
+      child.once("error", (error) => resolve2({ stderr: error.message, success: false }));
+      child.once("close", (code) => resolve2({ stderr, success: code === 0 }));
+    }),
+    writeFile: async (path, value) => {
+      await writeFile(path, value);
+    }
+  };
+}
+
 // src/remux.ts
 function mergeAudioVideo(video, audio) {
   const videoSource = analyze(video);
@@ -2498,7 +2816,7 @@ function buffered(item) {
 async function download(item, options = {}) {
   const net = createNet(options.fetch ?? globalThis.fetch);
   if (buffered(item)) {
-    const bytes = await itemBytes(net, item);
+    const bytes = await itemBytes2(net, item);
     return new Response(toArrayBuffer(bytes), { headers: { "content-length": String(bytes.length), "content-type": item.mime } });
   }
   const response = await net(item.url, { headers: item.headers });
@@ -2507,9 +2825,32 @@ async function download(item, options = {}) {
   }
   return response;
 }
+async function downloadBlob(url, optionsOrHeaders = {}, legacyOptions = {}) {
+  const modern = isDownloadBlobOptions(optionsOrHeaders);
+  const options = modern ? optionsOrHeaders : legacyOptions;
+  const headers = modern ? optionsOrHeaders.headers ?? {} : optionsOrHeaders;
+  const net = createNet(options.fetch ?? globalThis.fetch);
+  const response = await net(url, { headers });
+  if (!response.ok || !response.body) {
+    throw new PostfetchError(502, `download failed: ${response.status}`);
+  }
+  const blob = await response.blob();
+  if (!modern || optionsOrHeaders.remux !== true) {
+    return blob;
+  }
+  const remuxed = await remuxMp4(new Uint8Array(await blob.arrayBuffer()), optionsOrHeaders.ffmpegPath);
+  return remuxed ? new Blob([toArrayBuffer(remuxed)], { type: blob.type || "video/mp4" }) : blob;
+}
+function isDownloadBlobOptions(value) {
+  if (value instanceof Headers || Array.isArray(value)) {
+    return false;
+  }
+  const candidate = value;
+  return "headers" in candidate && typeof candidate.headers !== "string" || typeof candidate.remux === "boolean" || typeof candidate.ffmpegPath === "string" || typeof candidate.fetch === "function";
+}
 async function archive(result, options = {}) {
   const net = createNet(options.fetch ?? globalThis.fetch);
-  const files = await Promise.all(result.items.map(async (item) => ({ data: await itemBytes(net, item), name: item.filename })));
+  const files = await Promise.all(result.items.map(async (item) => ({ data: await itemBytes2(net, item), name: item.filename })));
   return { bytes: zip(files), filename: result.archiveFilename, mime: "application/zip" };
 }
 async function toResponse(result, options = {}) {
@@ -2521,7 +2862,7 @@ async function toResponse(result, options = {}) {
 async function singleResponse(item, options) {
   if (buffered(item)) {
     const net = createNet(options.fetch ?? globalThis.fetch);
-    const bytes = await itemBytes(net, item);
+    const bytes = await itemBytes2(net, item);
     return new Response(toArrayBuffer(bytes), {
       headers: {
         "content-disposition": `attachment; filename="${item.filename}"`,
@@ -2562,7 +2903,7 @@ async function archiveResponse(result, options) {
     }
   });
 }
-async function itemBytes(net, item) {
+async function itemBytes2(net, item) {
   if (item.hls) {
     const video = await assembleHls(net, item.url, item.headers);
     if (item.audio) {
@@ -2595,6 +2936,7 @@ function toArrayBuffer(bytes) {
 export {
   toResponse,
   postfetch,
+  downloadBlob,
   download,
   detect,
   archive,

package/dist/internal.d.ts

@@ -99,6 +99,17 @@ export type TiktokExtra = {
 export type TwitterExtra = {
     /** BCP 47 language tag detected for the tweet. */
     lang?: string;
+    /** The post quoted by this post, when X includes it in the resolved payload. */
+    quotedTweet?: TwitterQuotedTweet;
+};
+/** A quoted X post and its normalized metadata. */
+export type TwitterQuotedTweet = {
+    /** Status id of the quoted post. */
+    id: string;
+    /** Metadata belonging to the quoted post rather than the outer post. */
+    metadata: PostMetadata & {
+        extra?: TwitterExtra;
+    };
 };
 /** Instagram-specific metadata. */
 export type InstagramExtra = {
@@ -158,6 +169,8 @@ export type Net = (url: string, init?: RequestInit, attempts?: number) => Promis
 export type ResolveContext = {
     net: Net;
     preferredWidth: number;
+    /** Requested soft byte cap, for resolvers that can rank exact rendition sizes. */
+    tryMaxBytes?: number;
     url: string;
 };
 /**

package/dist/mp4-remux.d.ts

@@ -0,0 +1,18 @@
+type CommandResult = {
+    stderr: string;
+    success: boolean;
+};
+export type Mp4RemuxRuntime = {
+    makeTempDir(prefix: string): Promise<string>;
+    readFile(path: string): Promise<Uint8Array>;
+    removeDir(path: string): Promise<void>;
+    run(command: string, args: string[]): Promise<CommandResult>;
+    writeFile(path: string, bytes: Uint8Array): Promise<void>;
+};
+/**
+ * Normalize an MP4 with the same stream-copy remux used by UMMR. Encoded media
+ * is left untouched; FFmpeg only rebuilds the container and timing tables.
+ * Returns `null` when FFmpeg is unavailable or the input cannot be remuxed.
+ */
+export declare function remuxMp4(bytes: Uint8Array, ffmpegPath?: string, runtime?: Mp4RemuxRuntime): Promise<Uint8Array | null>;
+export {};

package/dist/postfetch.d.ts

@@ -5,14 +5,24 @@ export type PostfetchOptions = {
     fetch?: typeof fetch;
     /** Preferred media width in pixels; the closest available rendition is chosen. Defaults to `720`. */
     preferredWidth?: number;
+    /**
+     * Soft file-size cap in bytes. The normal rendition is resolved and probed
+     * with HEAD; when it exceeds the cap, a smaller available rendition is
+     * returned. X probes every available MP4 variant and picks the highest-quality
+     * complete result under the cap, or its smallest variants when none fit. For
+     * other platforms, if size discovery or a smaller rendition is unavailable,
+     * the normal result is returned unchanged.
+     */
+    tryMaxBytes?: number;
 };
 /**
  * Resolve a public social post URL to its media.
  *
  * Detects the platform from the URL host, then returns the post's media as typed
  * {@link MediaItem}s — direct CDN URLs plus the headers needed to fetch them. It
- * performs no side effects beyond the lookup; use {@link download}, {@link archive}
- * or {@link toResponse} to turn the result into bytes or a `Response`.
+ * performs no side effects beyond the lookup; use {@link download},
+ * {@link downloadBlob}, {@link archive} or {@link toResponse} to turn the result
+ * into bytes, a `Blob` or a `Response`.
  *
  * @param url A post URL from a supported platform.
  * @param options See {@link PostfetchOptions}.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@postfetch/core",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "description": "Zero-dependency typed core that turns Facebook, Instagram, LinkedIn, Pinterest, Reddit, SoundCloud, TikTok, X and YouTube post URLs into media files.",
   "license": "MIT",
   "type": "module",