metanova 0.2.0 → 0.2.2

package/dist/index.cjs

@@ -1322,6 +1322,95 @@ function uniqueStrings(values) {
   return [...new Set(values.filter(Boolean))];
 }
 
+// src/utils/redditMedia.ts
+var REDDIT_BAD_IMAGE_URL_PATTERN = /thumbs\.redditmedia\.com|avatar|community_icon|subreddit|icon|award|emoji/i;
+var TRUSTED_REDDIT_SOURCES = /* @__PURE__ */ new Set([
+  "adapter",
+  "openGraph",
+  "twitter",
+  "jsonLd",
+  "oEmbed",
+  "nextData",
+  "nuxt",
+  "initialState",
+  "preloadedState",
+  "apollo",
+  "applicationJson",
+  "jsonScript"
+]);
+function isRedditUrl(value) {
+  try {
+    const host = new URL(value).hostname.toLowerCase().replace(/^www\./, "");
+    return host === "reddit.com" || host === "redd.it" || host.endsWith(".reddit.com");
+  } catch {
+    return false;
+  }
+}
+function filterRedditImageCandidates(images) {
+  const allowed = images.filter(isAllowedRedditImageCandidate);
+  const trusted = allowed.filter(isTrustedRedditImageCandidate);
+  return prioritizeRedditImages(trusted.length > 0 ? trusted : allowed);
+}
+function prioritizeRedditImages(images) {
+  return images.slice().sort(
+    (left, right) => redditImagePriority(right) - redditImagePriority(left) || imageArea(right) - imageArea(left)
+  );
+}
+function isAllowedRedditImageCandidate(image) {
+  if (image.width !== void 0 && image.width < 200) {
+    return false;
+  }
+  if (image.height !== void 0 && image.height < 200) {
+    return false;
+  }
+  return !REDDIT_BAD_IMAGE_URL_PATTERN.test(image.url);
+}
+function redditImagePriority(image) {
+  const mediaKind = typeof image.metadata?.redditMediaKind === "string" ? image.metadata.redditMediaKind : void 0;
+  const url = image.url.toLowerCase();
+  if (mediaKind === "gallery") {
+    return 700;
+  }
+  if (mediaKind === "previewOriginal") {
+    return 620;
+  }
+  if (mediaKind === "directImage") {
+    return 580;
+  }
+  if (/\/\/preview\.redd\.it\//i.test(url)) {
+    return 560;
+  }
+  if (/\/\/i\.redd\.it\//i.test(url)) {
+    return 540;
+  }
+  if (image.source === "openGraph" || image.source === "twitter") {
+    return 420;
+  }
+  if (/\/\/external-preview\.redd\.it\//i.test(url)) {
+    return 300;
+  }
+  if (/\/\/thumbs\.redditmedia\.com\//i.test(url)) {
+    return 1;
+  }
+  return isRedditMediaUrl(url) ? 250 : 0;
+}
+function hasRedditImageContext(images) {
+  return images.some((image) => {
+    const adapter = typeof image.metadata?.adapter === "string" ? image.metadata.adapter : "";
+    const originalSource = typeof image.metadata?.originalSource === "string" ? image.metadata.originalSource : "";
+    return adapter === "redditAdapter" || originalSource === "redditJsonEndpoint" || Boolean(image.metadata?.redditMediaKind);
+  });
+}
+function isRedditMediaUrl(value) {
+  return /(?:^https?:)?\/\/(?:(?:i|preview|external-preview)\.redd\.it|thumbs\.redditmedia\.com|v\.redd\.it)\//i.test(value);
+}
+function isTrustedRedditImageCandidate(image) {
+  return TRUSTED_REDDIT_SOURCES.has(image.source) || Boolean(image.metadata?.redditMediaKind);
+}
+function imageArea(image) {
+  return (image.width ?? 0) * (image.height ?? 0);
+}
+
 // src/scorers/image.ts
 var SOURCE_WEIGHT = {
   adapter: 98,
@@ -1342,6 +1431,7 @@ var SOURCE_WEIGHT = {
 };
 function scoreImages(images, customScorers = []) {
   const duplicateCounts = countDuplicates(images);
+  const redditContext = hasRedditImageContext(images);
   return images.map((image, index) => {
     const scored = scoreImageWithDetails(image, index, images, duplicateCounts);
     const customScore = customScorers.reduce((total, scorer) => total + scorer(image, { index, images }), 0);
@@ -1357,7 +1447,7 @@ function scoreImages(images, customScorers = []) {
       }
     };
   }).sort(
-    (left, right) => (right.score ?? 0) - (left.score ?? 0) || sourceSortWeight(right) - sourceSortWeight(left) || imageArea(right) - imageArea(left)
+    (left, right) => (redditContext ? redditImagePriority(right) - redditImagePriority(left) : 0) || (right.score ?? 0) - (left.score ?? 0) || sourceSortWeight(right) - sourceSortWeight(left) || imageArea2(right) - imageArea2(left)
   );
 }
 function selectBestImage(images, customScorers = []) {
@@ -1375,15 +1465,17 @@ function scoreImageWithDetails(image, index, images, duplicateCounts) {
   const dimensions = scoreDimensions(image);
   const format = scoreFormat(image);
   const urlSignal = scoreUrlSignal(image);
+  const redditMedia = scoreRedditMedia(image);
   const urlPenalty = scoreUrlPenalty(image);
   const duplicatePenalty = scoreDuplicatePenalty(image, duplicateCounts);
   score += dimensions.score;
   score += format.score;
   score += urlSignal.score;
+  score += redditMedia.score;
   score -= urlPenalty;
   score -= duplicatePenalty.score;
   score -= Math.min(index * 1.5, 10);
-  reasons.push(...dimensions.reasons, ...format.reasons, ...urlSignal.reasons, ...duplicatePenalty.reasons);
+  reasons.push(...dimensions.reasons, ...format.reasons, ...urlSignal.reasons, ...redditMedia.reasons, ...duplicatePenalty.reasons);
   if (images.length === 1) {
     score += 4;
     reasons.push("only candidate image added 4 points");
@@ -1483,6 +1575,33 @@ function platformThumbnailScore(url) {
   }
   return { score: 0, reasons: [] };
 }
+function scoreRedditMedia(image) {
+  const priority = redditImagePriority(image);
+  if (priority === 0 && !isRedditMediaUrl(image.url)) {
+    return { score: 0, reasons: [] };
+  }
+  const url = image.url.toLowerCase();
+  const mediaKind = typeof image.metadata?.redditMediaKind === "string" ? image.metadata.redditMediaKind : void 0;
+  if (mediaKind === "gallery") {
+    return { score: 24, reasons: ["Reddit gallery media added 24 points"] };
+  }
+  if (mediaKind === "previewOriginal") {
+    return { score: 20, reasons: ["Reddit original preview media added 20 points"] };
+  }
+  if (/\/\/i\.redd\.it\//i.test(url)) {
+    return { score: 18, reasons: ["Reddit direct image media added 18 points"] };
+  }
+  if (/\/\/preview\.redd\.it\//i.test(url)) {
+    return { score: 16, reasons: ["Reddit preview media added 16 points"] };
+  }
+  if (/\/\/external-preview\.redd\.it\//i.test(url)) {
+    return { score: -8, reasons: ["Reddit external preview media subtracted 8 points"] };
+  }
+  if (/\/\/thumbs\.redditmedia\.com\//i.test(url)) {
+    return { score: -60, reasons: ["Reddit thumbnail host subtracted 60 points"] };
+  }
+  return { score: 0, reasons: [] };
+}
 function scoreUrlPenalty(image) {
   const url = image.url.toLowerCase();
   let penalty = 0;
@@ -1555,7 +1674,7 @@ function countDuplicates(images) {
   }
   return counts;
 }
-function imageArea(image) {
+function imageArea2(image) {
   return (image.width ?? 0) * (image.height ?? 0);
 }
 function sourceSortWeight(image) {
@@ -1673,8 +1792,9 @@ function discoverMedia(rawSources, finalUrl) {
   if (externalResults.some((result) => (result.images?.length ?? 0) > 0 || (result.videos?.length ?? 0) > 0)) {
     trace.push("media discovery included adapter and plugin media");
   }
+  const dedupedImages = dedupeMediaBySignature(images);
   return {
-    images: dedupeMediaBySignature(uniqueMediaByUrl(images)),
+    images: isRedditUrl(finalUrl) ? filterRedditImageCandidates(dedupedImages) : dedupedImages,
     videos: dedupeMediaBySignature(uniqueMediaByUrl(videos)),
     audio: dedupeMediaBySignature(uniqueMediaByUrl(audio)),
     trace
@@ -1766,7 +1886,8 @@ function mediaFromJsonValue(value, kind, source) {
         height: parseNumber(stringFromUnknown(value.height)) ?? parseNumber(stringFromUnknown(nestedDetails?.height)),
         alt: stringFromUnknown(value.alt) ?? stringFromUnknown(value.caption) ?? stringFromUnknown(value.name) ?? stringFromUnknown(nestedDetails?.alt),
         title: stringFromUnknown(value.title) ?? stringFromUnknown(nestedDetails?.title),
-        type: stringFromUnknown(value.type) ?? stringFromUnknown(value.mimeType) ?? stringFromUnknown(value.encodingFormat) ?? stringFromUnknown(nestedDetails?.type)
+        type: stringFromUnknown(value.type) ?? stringFromUnknown(value.mimeType) ?? stringFromUnknown(value.encodingFormat) ?? stringFromUnknown(nestedDetails?.type),
+        metadata: isRecord3(value.metadata) ? value.metadata : void 0
       },
       ...srcsetAssets
     ];
@@ -1874,7 +1995,7 @@ function dedupeMediaBySignature(assets) {
   for (const asset of assets) {
     const key = mediaSignature2(asset.url);
     const current = seen.get(key);
-    if (!current || sourceRank(asset.source) > sourceRank(current.source)) {
+    if (!current || mediaRank(asset) > mediaRank(current)) {
       seen.set(key, asset);
     }
   }
@@ -1908,6 +2029,10 @@ function sourceRank(source) {
   };
   return ranks[source] ?? 50;
 }
+function mediaRank(asset) {
+  const redditPriority = redditImagePriority(asset);
+  return redditPriority > 0 ? 1e3 + redditPriority : sourceRank(asset.source);
+}
 function shouldIgnoreMediaUrl2(url) {
   const normalized = url.toLowerCase();
   return normalized.startsWith("data:") || normalized.startsWith("blob:") || normalized.startsWith("javascript:") || /(?:sprite|spacer|blank|transparent|placeholder|tracking|beacon|pixel|emoji|favicon|apple-touch-icon)(?:[._/-]|$|\?)/i.test(normalized) || /(?:^|[/?_-])1x1(?:[._/-]|$|\?)/i.test(normalized);
@@ -2232,7 +2357,7 @@ function normalizeMetadata(rawSources, context = {}) {
     ...mediaDiscovery.trace,
     ...selectedImage.best ? [`selected image from ${sourceLabel2(selectedImage.best)}`] : []
   ]);
-  return stripUndefined2({
+  const normalized = stripUndefined2({
     ok: true,
     url,
     finalUrl,
@@ -2262,6 +2387,12 @@ function normalizeMetadata(rawSources, context = {}) {
     diagnostics,
     trace: diagnostics.trace
   });
+  normalized.images = selectedImage.images;
+  normalized.videos = videos;
+  normalized.audio = audio;
+  normalized.favicons = favicons;
+  normalized.trace = diagnostics.trace;
+  return normalized;
 }
 function normalizeAssets2(assets, baseUrl) {
   return assets.map((asset) => {
@@ -2897,8 +3028,8 @@ var redditAdapter = {
       type: reddit.isPost ? "social_post" : "website",
       siteName: "Reddit",
       canonicalUrl: context.raw.openGraph.url ?? context.raw.html.canonicalUrl,
-      title: cleanSocialTitle(titleSelection.value),
-      description: descriptionSelection.value,
+      title: cleanRedditTitle(titleSelection.value),
+      description: cleanRedditDescription(descriptionSelection.value),
       images: markAdapterMedia(mediaFromContext(context).images, "redditAdapter"),
       videos: markAdapterMedia(mediaFromContext(context).videos, "redditAdapter"),
       author: username ? { name: username } : entityFromContext(context, ["author", "submitter", "user"]),
@@ -2984,7 +3115,7 @@ var tiktokAdapter = {
     return this.detect?.(url) ?? false;
   },
   extract(context) {
-    return socialVideoResult("tiktokAdapter", "TikTok", context);
+    return tiktokResult(context);
   },
   normalize(rawData) {
     return normalizePlatformResult(rawData);
@@ -3203,25 +3334,215 @@ function redditDescriptionFromContext(context) {
   }
   return { value: context.raw.html.description, method: context.raw.html.description ? "reddit:html" : void 0 };
 }
-function socialVideoResult(source, platform, context) {
+function tiktokResult(context) {
   const url = new URL(context.finalUrl);
   const username = url.pathname.match(/@([^/]+)/)?.[1];
   const postId = url.pathname.match(/\/(?:video|photo)\/([^/]+)/)?.[1] ?? url.pathname.split("/").filter(Boolean).at(-1);
+  const itemStruct = tiktokItemStructFromContext(context, postId);
+  const titleSelection = tiktokTitleFromContext(context, itemStruct, username);
+  const descriptionSelection = tiktokDescriptionFromContext(context, itemStruct);
+  const author = tiktokAuthorFromItemStruct(itemStruct, username);
+  const media = tiktokMediaFromContext(context, itemStruct);
+  const publishedTime = tiktokPublishedTime(itemStruct) ?? publishedTimeFromContext(context);
   return compactAdapterResult({
-    source,
-    platform,
+    source: "tiktokAdapter",
+    platform: "TikTok",
     type: "social_post",
-    siteName: platform,
+    siteName: "TikTok",
     canonicalUrl: context.raw.openGraph.url,
-    title: titleFromContext(context, ["title", "desc", "description", "caption"]),
-    description: descriptionFromContext(context),
-    images: markAdapterMedia(mediaFromContext(context).images, source),
-    videos: markAdapterMedia(mediaFromContext(context).videos, source),
-    author: username ? { name: username } : entityFromContext(context, ["author", "user", "creator", "owner"]),
-    article: { publishedTime: publishedTimeFromContext(context) },
-    identifiers: { username, postId }
+    title: titleSelection.value,
+    description: descriptionSelection.value,
+    images: markAdapterMedia(media.images, "tiktokAdapter"),
+    videos: markAdapterMedia(media.videos, "tiktokAdapter"),
+    author,
+    article: { publishedTime },
+    video: postId ? {
+      id: postId,
+      title: titleSelection.value,
+      channel: author,
+      publishedTime,
+      duration: tiktokVideoDuration(itemStruct),
+      viewCount: tiktokStatCount(itemStruct, "playCount")
+    } : void 0,
+    identifiers: { username, postId },
+    raw: {
+      extractionMethod: titleSelection.method ?? descriptionSelection.method ?? "tiktok:htmlFallback"
+    }
   });
 }
+function tiktokTitleFromContext(context, itemStruct, username) {
+  const desc = cleanTikTokText(stringFromUnknown3(itemStruct?.desc));
+  if (desc) {
+    return { value: desc, method: "tiktok:itemStruct.desc" };
+  }
+  const musicTitle = tiktokMusicTitle(itemStruct);
+  if (musicTitle) {
+    return { value: musicTitle, method: "tiktok:itemStruct.music" };
+  }
+  const fallback = cleanTikTokText(titleFromContext(context, ["desc", "caption", "title", "description"]));
+  if (fallback) {
+    return { value: fallback, method: "tiktok:fallback" };
+  }
+  return {
+    value: username ? `TikTok post by @${username}` : void 0,
+    method: username ? "tiktok:urlFallback" : void 0
+  };
+}
+function tiktokDescriptionFromContext(context, itemStruct) {
+  const desc = cleanTikTokText(stringFromUnknown3(itemStruct?.desc));
+  if (desc) {
+    return { value: desc, method: "tiktok:itemStruct.desc" };
+  }
+  return {
+    value: cleanTikTokText(descriptionFromContext(context)),
+    method: "tiktok:fallback"
+  };
+}
+function tiktokItemStructFromContext(context, postId) {
+  for (const item of context.raw.embeddedData.items) {
+    const defaultScope = isRecord4(item.data["__DEFAULT_SCOPE__"]) ? item.data["__DEFAULT_SCOPE__"] : void 0;
+    const videoDetail = isRecord4(defaultScope?.["webapp.video-detail"]) ? defaultScope["webapp.video-detail"] : void 0;
+    const itemInfo = isRecord4(videoDetail?.itemInfo) ? videoDetail.itemInfo : void 0;
+    const itemStruct = isRecord4(itemInfo?.itemStruct) ? itemInfo.itemStruct : void 0;
+    if (itemStruct && (!postId || stringFromUnknown3(itemStruct.id) === postId)) {
+      return itemStruct;
+    }
+  }
+  let found;
+  for (const item of context.raw.embeddedData.items) {
+    walkData(item.data, (value, key) => {
+      if (found || key !== "itemStruct" || !isRecord4(value)) {
+        return;
+      }
+      if (!postId || stringFromUnknown3(value.id) === postId) {
+        found = value;
+      }
+    });
+    if (found) {
+      return found;
+    }
+  }
+  return void 0;
+}
+function tiktokMediaFromContext(context, itemStruct) {
+  const discovered = mediaFromContext(context);
+  return {
+    images: [...tiktokImagesFromItemStruct(itemStruct), ...discovered.images],
+    videos: [...tiktokVideosFromItemStruct(itemStruct), ...discovered.videos]
+  };
+}
+function tiktokImagesFromItemStruct(itemStruct) {
+  const video = isRecord4(itemStruct?.video) ? itemStruct.video : void 0;
+  if (!video) {
+    return [];
+  }
+  const width = numberFromUnknown(video.width);
+  const height = numberFromUnknown(video.height);
+  const candidates = [
+    stringFromUnknown3(video.originCover),
+    stringFromUnknown3(video.cover),
+    stringFromUnknown3(video.dynamicCover),
+    ...urlsFromUnknown(video.shareCover)
+  ];
+  return uniqueStrings3(candidates).map((url) => ({
+    url,
+    kind: "image",
+    source: "applicationJson",
+    width,
+    height,
+    metadata: {
+      tiktokMediaKind: "videoCover"
+    }
+  }));
+}
+function tiktokVideosFromItemStruct(itemStruct) {
+  const video = isRecord4(itemStruct?.video) ? itemStruct.video : void 0;
+  if (!video) {
+    return [];
+  }
+  const width = numberFromUnknown(video.width);
+  const height = numberFromUnknown(video.height);
+  const candidates = [
+    stringFromUnknown3(video.playAddr),
+    stringFromUnknown3(video.downloadAddr),
+    ...urlsFromTikTokPlayAddr(video.PlayAddrStruct),
+    ...Array.isArray(video.bitrateInfo) ? video.bitrateInfo.flatMap((item) => isRecord4(item) ? urlsFromTikTokPlayAddr(item.PlayAddr) : []) : []
+  ];
+  return uniqueStrings3(candidates).filter((url) => /^https?:\/\//i.test(url)).map((url) => ({
+    url,
+    kind: "video",
+    source: "applicationJson",
+    width,
+    height,
+    type: "video/mp4",
+    metadata: {
+      tiktokMediaKind: "videoPlay"
+    }
+  }));
+}
+function urlsFromTikTokPlayAddr(value) {
+  if (!isRecord4(value)) {
+    return [];
+  }
+  return urlsFromUnknown(value.UrlList);
+}
+function tiktokAuthorFromItemStruct(itemStruct, username) {
+  const author = isRecord4(itemStruct?.author) ? itemStruct.author : void 0;
+  const name = stringFromUnknown3(author?.nickname) ?? stringFromUnknown3(author?.uniqueId) ?? username;
+  if (!name) {
+    return void 0;
+  }
+  return {
+    name,
+    url: username ? `https://www.tiktok.com/@${username}` : void 0
+  };
+}
+function tiktokPublishedTime(itemStruct) {
+  const created = numberFromUnknown(itemStruct?.createTime);
+  return created ? new Date(created * 1e3).toISOString() : void 0;
+}
+function tiktokVideoDuration(itemStruct) {
+  const video = isRecord4(itemStruct?.video) ? itemStruct.video : void 0;
+  return stringFromUnknown3(video?.duration);
+}
+function tiktokStatCount(itemStruct, key) {
+  const stats = isRecord4(itemStruct?.stats) ? itemStruct.stats : void 0;
+  return numberFromUnknown(stats?.[key]);
+}
+function tiktokMusicTitle(itemStruct) {
+  const music = isRecord4(itemStruct?.music) ? itemStruct.music : void 0;
+  const title = cleanTikTokText(stringFromUnknown3(music?.title));
+  const author = cleanTikTokText(stringFromUnknown3(music?.authorName));
+  if (!title) {
+    return void 0;
+  }
+  if (author && !/original sound/i.test(title)) {
+    return `${title} - ${author}`;
+  }
+  return title;
+}
+function cleanTikTokText(value) {
+  const cleaned = value?.replace(/\s+/g, " ").trim();
+  if (!cleaned || isLowQualityTikTokText(cleaned)) {
+    return void 0;
+  }
+  return cleaned;
+}
+function isLowQualityTikTokText(value) {
+  return /\{[^}]+\}/.test(value) || /tiktok\s*shop|free shipping|eligible items|exclusive collections/i.test(value) || /^tiktok live creator networks$/i.test(value) || /^tiktok\s*-\s*make your day$/i.test(value) || /^discover (?:new |popular )?videos?\b.*\btiktok\b/i.test(value);
+}
+function urlsFromUnknown(value) {
+  if (typeof value === "string" && value.trim()) {
+    return [value.trim()];
+  }
+  if (Array.isArray(value)) {
+    return value.flatMap(urlsFromUnknown);
+  }
+  return [];
+}
+function uniqueStrings3(values) {
+  return [...new Set(values.filter((value) => Boolean(value)))];
+}
 function normalizePlatformResult(rawData) {
   const type = rawData.type ?? inferAdapterType(rawData);
   return compactAdapterResult({
@@ -3572,6 +3893,20 @@ function parseRedditUrl(url) {
 function cleanSocialTitle(title) {
   return title?.replace(/\s*:\s*r\/[A-Za-z0-9_]+$/i, "").trim();
 }
+function cleanRedditTitle(title) {
+  const cleaned = cleanSocialTitle(title);
+  if (!cleaned || /reddit\s*-\s*please wait for verification|please wait for verification|whoa there, pardner/i.test(cleaned)) {
+    return void 0;
+  }
+  return cleaned;
+}
+function cleanRedditDescription(description) {
+  const cleaned = description?.replace(/\s+/g, " ").trim();
+  if (!cleaned || /please wait for verification|whoa there, pardner|request has been blocked/i.test(cleaned)) {
+    return void 0;
+  }
+  return cleaned;
+}
 function hostMatches(url, domains) {
   const host = url.hostname.toLowerCase().replace(/^www\./, "");
   return domains.some((domain) => host === domain || host.endsWith(`.${domain}`));
@@ -3961,12 +4296,17 @@ function ascii(bytes, offset, length) {
 }
 
 // src/fetchMetadata.ts
+var REDDIT_BLOCKED_METADATA_WARNING = "Reddit returned a verification/block page; metadata is incomplete.";
+var PROVIDER_BLOCKED_SUGGESTED_ACTION = "retry_on_different_host_or_use_supported_proxy";
 async function fetchMetadata(url, options = {}) {
   const startedAt = Date.now();
   try {
     const requestedUrl = normalizeUrl(url);
     const fetchResult = await fetchPageWithStrategies(requestedUrl, options);
     const page = fetchResult.page;
+    if (fetchResult.providerDiagnostics?.blocked) {
+      return createBlockedProviderMetadata(requestedUrl, fetchResult, Date.now() - startedAt);
+    }
     const directMedia = createDirectMediaMetadata(page, requestedUrl, Date.now() - startedAt);
     if (directMedia) {
       return directMedia;
@@ -3993,7 +4333,7 @@ async function fetchMetadata(url, options = {}) {
       ...metadata.canonicalUrl ? ["resolved canonical URL"] : []
     ];
     metadata.diagnostics.fallbacksAttempted = mergeFallbackAttempts2(metadata.diagnostics.fallbacksAttempted, fetchResult.fallbacksAttempted);
-    metadata.diagnostics.sourcePriority = uniqueStrings3([...metadata.diagnostics.sourcePriority ?? [], ...fetchResult.sourcePriority ?? []]);
+    metadata.diagnostics.sourcePriority = uniqueStrings4([...metadata.diagnostics.sourcePriority ?? [], ...fetchResult.sourcePriority ?? []]);
     metadata.diagnostics.extractionMethod = metadata.diagnostics.extractionMethod ?? fetchResult.extractionMethod;
     metadata.diagnostics.retryInfo = metadata.diagnostics.retryInfo ?? fetchResult.retryInfo;
     metadata.trace = metadata.diagnostics.trace;
@@ -4035,8 +4375,64 @@ async function fetchMetadata(url, options = {}) {
     };
   }
 }
+function createBlockedProviderMetadata(requestedUrl, fetchResult, fetchDurationMs) {
+  const page = fetchResult.page;
+  const providerDiagnostics = fetchResult.providerDiagnostics;
+  const trace = uniqueStrings4([
+    ...page.isShortUrl ? [`detected short URL provider: ${page.shortUrlProvider ?? "unknown"}`] : [],
+    ...page.redirects.length > 0 ? [`resolved ${page.redirects.length} redirect${page.redirects.length === 1 ? "" : "s"}`] : [],
+    ...fetchResult.trace,
+    "detected blocked provider response"
+  ]);
+  const warnings = uniqueStrings4([
+    ...fetchResult.warnings,
+    REDDIT_BLOCKED_METADATA_WARNING,
+    ...page.statusCode < 200 || page.statusCode >= 300 ? [`Fetch completed with non-success status code ${page.statusCode}.`] : []
+  ]);
+  return {
+    ok: false,
+    url: requestedUrl,
+    finalUrl: page.finalUrl,
+    type: "unknown",
+    siteName: providerDiagnostics?.platform === "reddit" ? "Reddit" : void 0,
+    confidence: 0,
+    completeness: 0,
+    reliability: 0,
+    images: [],
+    videos: [],
+    audio: [],
+    favicons: [],
+    trace,
+    diagnostics: {
+      originalUrl: requestedUrl,
+      finalUrl: page.finalUrl,
+      isShortUrl: page.isShortUrl,
+      shortUrlProvider: page.shortUrlProvider,
+      statusCode: page.statusCode,
+      contentType: page.contentType,
+      redirects: page.redirects,
+      sourcesUsed: [],
+      warnings,
+      fallbacksAttempted: mergeFallbackAttempts2(void 0, fetchResult.fallbacksAttempted),
+      trace,
+      sourcePriority: fetchResult.sourcePriority,
+      extractionMethod: fetchResult.extractionMethod,
+      retryInfo: fetchResult.retryInfo,
+      providerDiagnostics,
+      confidenceBreakdown: {
+        title: 0,
+        description: 0,
+        image: 0,
+        structuredData: 0,
+        adapter: 0
+      },
+      fetchDurationMs,
+      extractedAt: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
 async function fetchPageWithStrategies(requestedUrl, options) {
-  if (isRedditUrl(requestedUrl)) {
+  if (isRedditUrl2(requestedUrl)) {
     return fetchRedditPageWithStrategy(requestedUrl, options);
   }
   return {
@@ -4049,6 +4445,7 @@ async function fetchPageWithStrategies(requestedUrl, options) {
 async function fetchRedditPageWithStrategy(requestedUrl, options) {
   const attempts = [];
   const warnings = [];
+  const informationalFallbacks = [];
   const sourcePriority = ["redditJsonEndpoint", "oldReddit", "embeddedStructuredData", "openGraph", "html"];
   let lastError;
   const jsonUrl = redditJsonEndpoint(requestedUrl);
@@ -4059,7 +4456,7 @@ async function fetchRedditPageWithStrategy(requestedUrl, options) {
     });
     attempts.push(attempt);
     lastError = attempt.error;
-    if (attempt.page && attempt.ok && !attempt.blocked) {
+    if (attempt.page && attempt.ok) {
       const redditPost = parseRedditJsonPayload(attempt.page.html);
       if (redditPost?.title) {
         return {
@@ -4074,7 +4471,7 @@ async function fetchRedditPageWithStrategy(requestedUrl, options) {
       }
       warnings.push("Reddit JSON endpoint responded, but no post payload could be extracted.");
     } else if (attempt.blocked) {
-      warnings.push("Reddit JSON endpoint appears to have blocked access.");
+      informationalFallbacks.push("Informational fallback: Reddit JSON endpoint appears to have blocked access; continuing with fallback extraction.");
     }
   }
   const oldRedditUrl = redditOldUrl(requestedUrl);
@@ -4082,12 +4479,12 @@ async function fetchRedditPageWithStrategy(requestedUrl, options) {
     const attempt = await attemptFetch("oldReddit", oldRedditUrl, options);
     attempts.push(attempt);
     lastError = attempt.error;
-    if (attempt.page && attempt.ok && !attempt.blocked) {
+    if (attempt.page && attempt.ok) {
       return {
         page: attempt.page,
         fallbacksAttempted: attempts,
         warnings,
-        trace: ["retried Reddit page through old.reddit"],
+        trace: [...informationalFallbacks, "retried Reddit page through old.reddit"],
         sourcePriority,
         extractionMethod: "reddit:oldReddit",
         retryInfo: redditRetryInfo(attempts)
@@ -4100,33 +4497,48 @@ async function fetchRedditPageWithStrategy(requestedUrl, options) {
   const htmlAttempt = await attemptFetch("redditHtmlFallback", requestedUrl, options);
   attempts.push(htmlAttempt);
   lastError = htmlAttempt.error;
-  if (htmlAttempt.page) {
-    if (htmlAttempt.blocked) {
-      warnings.push("Reddit HTML fallback appears to have been blocked; metadata may be incomplete.");
-    }
+  if (htmlAttempt.page && htmlAttempt.ok) {
     return {
       page: htmlAttempt.page,
       fallbacksAttempted: attempts,
       warnings,
-      trace: ["used Reddit HTML fallback"],
+      trace: [...informationalFallbacks, "used Reddit HTML fallback"],
       sourcePriority,
       extractionMethod: "reddit:htmlFallback",
       retryInfo: redditRetryInfo(attempts)
     };
   }
+  if (htmlAttempt.blocked) {
+    warnings.push("Reddit HTML fallback appears to have been blocked; metadata may be incomplete.");
+  }
+  const providerDiagnostics = redditProviderDiagnosticsFromAttempts(attempts);
+  if (providerDiagnostics) {
+    return {
+      page: synthesizeRedditBlockedPage(requestedUrl, attempts, providerDiagnostics),
+      fallbacksAttempted: attempts,
+      warnings: uniqueStrings4([...warnings, REDDIT_BLOCKED_METADATA_WARNING]),
+      trace: [...informationalFallbacks, "Reddit provider blocked metadata extraction"],
+      sourcePriority,
+      extractionMethod: "reddit:blockedProvider",
+      retryInfo: redditRetryInfo(attempts),
+      providerDiagnostics
+    };
+  }
   throw lastError ?? new Error("All Reddit extraction fetch attempts failed.");
 }
 async function attemptFetch(method, url, options) {
   try {
     const page = await fetchPage(url, options);
     const retryAfter = page.headers["retry-after"];
-    const blocked = isRedditBlocked(page);
+    const blockReason = redditBlockReason(page);
+    const blocked = Boolean(blockReason);
     return {
       method,
       url,
       ok: page.statusCode >= 200 && page.statusCode < 300 && !blocked,
       statusCode: page.statusCode,
       blocked,
+      blockReason,
       retryAfter,
       page
     };
@@ -4139,7 +4551,7 @@ async function attemptFetch(method, url, options) {
     };
   }
 }
-function isRedditUrl(url) {
+function isRedditUrl2(url) {
   try {
     const host = new URL(url).hostname.toLowerCase().replace(/^www\./, "");
     return host === "reddit.com" || host === "redd.it" || host.endsWith(".reddit.com");
@@ -4255,46 +4667,163 @@ function findRedditPostRecord(value) {
   return void 0;
 }
 function redditImagesFromPost(post) {
-  const images = [];
+  const images = [
+    ...redditGalleryImagesFromPost(post),
+    ...redditDirectImagesFromPost(post)
+  ];
   const preview = isRecord5(post.preview) && Array.isArray(post.preview.images) ? post.preview.images : [];
   for (const image of preview) {
     if (!isRecord5(image)) {
       continue;
     }
-    for (const candidate of [image.source, ...Array.isArray(image.resolutions) ? image.resolutions : []]) {
-      if (!isRecord5(candidate)) {
-        continue;
-      }
-      const url = redditMediaUrl(stringFromUnknown4(candidate.url));
-      if (!url) {
-        continue;
-      }
-      images.push({
-        url,
-        kind: "image",
-        source: "adapter",
-        width: numberFromUnknown2(candidate.width),
-        height: numberFromUnknown2(candidate.height),
-        metadata: {
-          adapter: "redditJsonEndpoint",
-          originalSource: "redditJsonEndpoint"
-        }
-      });
+    const source = redditImageFromRecord(image.source, "previewOriginal");
+    if (source) {
+      images.push(source);
+      continue;
+    }
+    const fallbackResolution = largestRedditImageRecord(Array.isArray(image.resolutions) ? image.resolutions : []);
+    const fallback = redditImageFromRecord(fallbackResolution, "previewResolution");
+    if (fallback) {
+      images.push(fallback);
     }
   }
   const thumbnail = redditMediaUrl(stringFromUnknown4(post.thumbnail));
   if (thumbnail && /^https?:\/\//i.test(thumbnail)) {
-    images.push({
-      url: thumbnail,
-      kind: "image",
-      source: "adapter",
-      metadata: {
-        adapter: "redditJsonEndpoint",
-        originalSource: "redditJsonEndpoint"
-      }
-    });
+    const thumbnailAsset = redditImageAsset(thumbnail, void 0, void 0, "thumbnail");
+    if (thumbnailAsset) {
+      images.push(thumbnailAsset);
+    }
+  }
+  return dedupeRedditImages(prioritizeRedditImages(images));
+}
+function redditGalleryImagesFromPost(post) {
+  const mediaMetadata = isRecord5(post.media_metadata) ? post.media_metadata : void 0;
+  if (!mediaMetadata) {
+    return [];
   }
-  return images;
+  const galleryItems = isRecord5(post.gallery_data) && Array.isArray(post.gallery_data.items) ? post.gallery_data.items : [];
+  const orderedIds = galleryItems.map((item) => isRecord5(item) ? stringFromUnknown4(item.media_id) : void 0).filter((item) => Boolean(item));
+  const seenIds = /* @__PURE__ */ new Set();
+  const assets = [];
+  for (const id of orderedIds) {
+    const asset = redditImageFromMediaMetadata(mediaMetadata[id], id);
+    if (asset) {
+      assets.push(asset);
+      seenIds.add(id);
+    }
+  }
+  for (const [id, value] of Object.entries(mediaMetadata)) {
+    if (seenIds.has(id)) {
+      continue;
+    }
+    const asset = redditImageFromMediaMetadata(value, id);
+    if (asset) {
+      assets.push(asset);
+    }
+  }
+  return assets;
+}
+function redditDirectImagesFromPost(post) {
+  const url = redditMediaUrl(stringFromUnknown4(post.url_overridden_by_dest) ?? stringFromUnknown4(post.url));
+  if (!url || !isDirectRedditImageUrl(url)) {
+    return [];
+  }
+  const previewSource = previewSourceRecord(post);
+  const asset = redditImageAsset(
+    url,
+    numberFromUnknown2(previewSource?.width),
+    numberFromUnknown2(previewSource?.height),
+    "directImage"
+  );
+  return asset ? [asset] : [];
+}
+function redditImageFromMediaMetadata(value, mediaId) {
+  if (!isRecord5(value)) {
+    return void 0;
+  }
+  const source = isRecord5(value.s) ? value.s : void 0;
+  const url = redditMediaUrl(
+    stringFromUnknown4(source?.u) ?? stringFromUnknown4(source?.gif) ?? stringFromUnknown4(source?.mp4)
+  );
+  if (!url) {
+    return void 0;
+  }
+  const asset = redditImageAsset(
+    url,
+    numberFromUnknown2(source?.x) ?? numberFromUnknown2(source?.width),
+    numberFromUnknown2(source?.y) ?? numberFromUnknown2(source?.height),
+    "gallery",
+    stringFromUnknown4(value.m)
+  );
+  return asset ? {
+    ...asset,
+    metadata: {
+      ...asset.metadata,
+      redditMediaId: mediaId
+    }
+  } : void 0;
+}
+function redditImageFromRecord(value, redditMediaKind) {
+  if (!isRecord5(value)) {
+    return void 0;
+  }
+  const url = redditMediaUrl(stringFromUnknown4(value.url) ?? stringFromUnknown4(value.u));
+  if (!url) {
+    return void 0;
+  }
+  return redditImageAsset(
+    url,
+    numberFromUnknown2(value.width) ?? numberFromUnknown2(value.x),
+    numberFromUnknown2(value.height) ?? numberFromUnknown2(value.y),
+    redditMediaKind
+  );
+}
+function redditImageAsset(url, width, height, redditMediaKind, type) {
+  const asset = {
+    url,
+    kind: "image",
+    source: "adapter",
+    width,
+    height,
+    type,
+    metadata: {
+      adapter: "redditJsonEndpoint",
+      originalSource: "redditJsonEndpoint",
+      redditMediaKind
+    }
+  };
+  return isAllowedRedditImageCandidate(asset) ? asset : void 0;
+}
+function largestRedditImageRecord(values) {
+  return values.filter(isRecord5).sort(
+    (left, right) => (numberFromUnknown2(right.width) ?? 0) * (numberFromUnknown2(right.height) ?? 0) - (numberFromUnknown2(left.width) ?? 0) * (numberFromUnknown2(left.height) ?? 0)
+  )[0];
+}
+function previewSourceRecord(post) {
+  const images = isRecord5(post.preview) && Array.isArray(post.preview.images) ? post.preview.images : [];
+  const firstImage = images.find(isRecord5);
+  return firstImage && isRecord5(firstImage.source) ? firstImage.source : void 0;
+}
+function isDirectRedditImageUrl(value) {
+  try {
+    const parsed = new URL(value);
+    const host = parsed.hostname.toLowerCase();
+    return host === "i.redd.it" || host === "preview.redd.it";
+  } catch {
+    return false;
+  }
+}
+function dedupeRedditImages(images) {
+  const seen = /* @__PURE__ */ new Set();
+  const unique = [];
+  for (const image of images) {
+    if (seen.has(image.url)) {
+      continue;
+    }
+    seen.add(image.url);
+    unique.push(image);
+  }
+  return unique;
 }
 function redditVideosFromPost(post) {
   const videos = [];
@@ -4321,7 +4850,9 @@ function redditVideosFromPost(post) {
 }
 function synthesizeRedditJsonPage(jsonPage, requestedUrl, post) {
   const finalUrl = post.canonicalUrl ?? requestedUrl;
-  const bestImage = post.images.sort((left, right) => (right.width ?? 0) * (right.height ?? 0) - (left.width ?? 0) * (left.height ?? 0))[0];
+  const bestImage = post.images.slice().sort(
+    (left, right) => redditImagePriority(right) - redditImagePriority(left) || (right.width ?? 0) * (right.height ?? 0) - (left.width ?? 0) * (left.height ?? 0)
+  )[0];
   const video = post.videos[0];
   const structuredData = {
     "@context": "https://schema.org",
@@ -4377,8 +4908,52 @@ function synthesizeRedditJsonPage(jsonPage, requestedUrl, post) {
     statusCode: jsonPage.statusCode
   };
 }
-function isRedditBlocked(page) {
-  return page.statusCode === 403 || page.statusCode === 429 || /please wait for verification|whoa there, pardner|blocked|forbidden|too many requests|request has been blocked/i.test(page.html);
+function redditProviderDiagnosticsFromAttempts(attempts) {
+  const blockedAttempts = attempts.filter((attempt) => attempt.blocked);
+  if (blockedAttempts.length === 0) {
+    return void 0;
+  }
+  const selectedAttempt = blockedAttempts.find((attempt) => attempt.blockReason === "provider_verification_required") ?? blockedAttempts.at(-1);
+  return {
+    platform: "reddit",
+    blocked: true,
+    statusCode: selectedAttempt?.statusCode,
+    reason: selectedAttempt?.blockReason ?? "provider_blocked_request",
+    suggestedAction: PROVIDER_BLOCKED_SUGGESTED_ACTION
+  };
+}
+function synthesizeRedditBlockedPage(requestedUrl, attempts, providerDiagnostics) {
+  const selectedPage = attempts.find((attempt) => attempt.blockReason === providerDiagnostics.reason)?.page ?? attempts.slice().reverse().find((attempt) => attempt.page)?.page;
+  return {
+    url: requestedUrl,
+    originalUrl: requestedUrl,
+    finalUrl: requestedUrl,
+    isShortUrl: selectedPage?.isShortUrl ?? false,
+    shortUrlProvider: selectedPage?.shortUrlProvider,
+    html: "",
+    bytes: new Uint8Array(),
+    statusCode: providerDiagnostics.statusCode ?? selectedPage?.statusCode ?? 403,
+    contentType: selectedPage?.contentType,
+    redirects: selectedPage?.redirects ?? [],
+    headers: selectedPage?.headers ?? {}
+  };
+}
+function redditBlockReason(page) {
+  const title = htmlTitle(page.html);
+  const text = normalizeText(`${title ?? ""} ${page.html}`);
+  if (/reddit\s*-\s*please wait for verification/i.test(title ?? "") || /please wait for verification|verification required|verify you are human/i.test(text)) {
+    return "provider_verification_required";
+  }
+  if (page.statusCode === 403 || page.statusCode === 429 || /whoa there, pardner|request has been blocked|too many requests|forbidden|you're blocked|you are blocked|youre blocked|blocked by network security/i.test(text) || /^blocked$/i.test(title ?? "")) {
+    return "provider_blocked_request";
+  }
+  return void 0;
+}
+function htmlTitle(html) {
+  return normalizeText(html.match(/<title[^>]*>([\s\S]*?)<\/title>/i)?.[1]);
+}
+function normalizeText(value) {
+  return value?.replace(/<[^>]*>/g, " ").replace(/\s+/g, " ").trim() ?? "";
 }
 function redditRetryInfo(attempts) {
   const blockedAttempts = attempts.filter((attempt) => attempt.blocked || attempt.statusCode === 429 || attempt.statusCode === 403);
@@ -4412,7 +4987,7 @@ function mergeFallbackAttempts2(existing, incoming) {
   }
   const seen = /* @__PURE__ */ new Set();
   return attempts.map((value) => {
-    const { page: _page, ...attempt } = value;
+    const { page: _page, blockReason: _blockReason, ...attempt } = value;
     return attempt;
   }).filter((attempt) => {
     const key = `${attempt.method}:${attempt.url ?? ""}:${attempt.statusCode ?? ""}:${attempt.error ?? ""}`;
@@ -4423,7 +4998,7 @@ function mergeFallbackAttempts2(existing, incoming) {
     return true;
   });
 }
-function uniqueStrings3(values) {
+function uniqueStrings4(values) {
   return [...new Set(values.filter((value) => Boolean(value)))];
 }
 function redditMediaUrl(value) {