umedia 0.2.2 → 0.4.0

package/lib/providers/snapchat.js

@@ -0,0 +1,106 @@
+import { fetchJson, fetchText, hostMatches } from "../util.js";
+import { Codes, UMediaError } from "../errors.js";
+
+/**
+ * Snapchat — Spotlight videos (preload link on the page) and public stories
+ * (the page's __NEXT_DATA__ snap list — ALL snaps, in order).
+ * Reference: cobalt snapchat service.
+ */
+export const name = "snapchat";
+
+const SPOTLIGHT_PRELOAD = /<link data-react-helmet="true" rel="preload" href="([^"]+)" as="video"\/>/;
+const NEXT_DATA = /<script id="__NEXT_DATA__" type="application\/json">({.+?})<\/script>/;
+
+export function canHandle(url) {
+  try {
+    return hostMatches(new URL(String(url)).hostname, ["snapchat.com", "t.snapchat.com"]);
+  } catch { return false; }
+}
+
+export async function resolve(url, ctx = {}) {
+  const attempt = { provider: name, status: "skipped" };
+  ctx.attempts?.push(attempt);
+  const t0 = Date.now();
+
+  let target = String(url);
+  if (/t\.snapchat\.com\//i.test(target)) {
+    try {
+      const res = await fetch(target, { redirect: "follow", headers: { "user-agent": "Mozilla/5.0" } });
+      target = res.url || target;
+    } catch { /* keep original */ }
+  }
+
+  const media = [];
+  let title = null;
+  let author = null;
+
+  const spotlight = target.match(/\/spotlight\/([\w-]+)/i);
+  const story = target.match(/\/add\/([\w.-]+)(?:\/([\w-]+))?/i);
+
+  if (spotlight) {
+    const r = await fetchText(`https://www.snapchat.com/spotlight/${spotlight[1]}`, { headers: { "user-agent": "Mozilla/5.0" } }, 18_000).catch(() => null);
+    const v = r?.text?.match(SPOTLIGHT_PRELOAD)?.[1];
+    if (v && new URL(v).hostname.endsWith("sc-cdn.net")) {
+      media.push({
+        type: "video", index: 0, url: v, thumbnail: null,
+        mimeType: "video/mp4", width: null, height: null, duration: null, size: null,
+        quality: null, hasAudio: true, hasVideo: true, source: name, variants: [],
+      });
+      title = (r.text.match(/"title":"([^"]{1,120})"/) || r.text.match(/<title[^>]*>([^<]*)/i) || [])[1] || null;
+    }
+  } else if (story) {
+    const r = await fetchText(`https://www.snapchat.com/add/${story[1]}${story[2] ? "/" + story[2] : ""}`,
+      { headers: { "user-agent": "Mozilla/5.0" } }, 18_000).catch(() => null);
+    const raw = r?.text?.match(NEXT_DATA)?.[1];
+    if (raw) {
+      const data = JSON.parse(raw);
+      author = story[1];
+      const snaps = data?.props?.pageProps?.story?.snapList
+        || data?.props?.pageProps?.curatedHighlights?.[0]?.snapList
+        || [];
+      snaps.forEach((snap) => {
+        const isPhoto = snap.snapMediaType === 0;
+        const u = snap.snapUrls?.mediaUrl;
+        if (!u) return;
+        media.push({
+          type: isPhoto ? "image" : "video", index: media.length, url: u,
+          thumbnail: snap.snapUrls?.mediaPreviewUrl?.value || u,
+          mimeType: isPhoto ? "image/jpeg" : "video/mp4",
+          width: null, height: null,
+          duration: snap.duration ? Math.round(snap.duration / 1000) : null,
+          size: null, quality: null,
+          hasAudio: !isPhoto, hasVideo: !isPhoto, source: name, variants: [],
+        });
+      });
+    }
+  }
+
+  if (!media.length) {
+    attempt.status = "failed";
+    attempt.error = "no snap media exposed (removed, private, or login-gated)";
+    throw new UMediaError(Codes.MEDIA_NOT_FOUND,
+      `Snapchat exposes no media for this URL (${attempt.error}) — the yt-dlp tier covers gated stories.`, { attempts: [attempt] });
+  }
+
+  attempt.status = "success";
+  attempt.latencyMs = Date.now() - t0;
+  return {
+    result: {
+      sourceUrl: url,
+      platform: name,
+      title: title || (author ? `Snapchat story @${author}` : null),
+      author,
+      thumbnail: media[0].thumbnail,
+      itemCount: media.length,
+      counts: { images: media.filter((m) => m.type === "image").length, videos: media.filter((m) => m.type === "video").length, audios: 0, other: 0 },
+      truncated: false,
+      media,
+      streamUrlsAvailable: true,
+    },
+    engine: { attempts: ctx.attempts || [attempt], finalProvider: name, totalLatencyMs: Date.now() - t0 },
+  };
+}
+
+export async function search() {
+  return [];
+}

package/lib/providers/soundcloud.js

@@ -0,0 +1,138 @@
+import { fetchJson, fetchText, hostMatches, UA } from "../util.js";
+import { Codes, UMediaError } from "../errors.js";
+
+/**
+ * SoundCloud — public api-v2 (the route the web player itself calls):
+ * resolve -> transcodings -> CDN hop -> direct progressive MP3 (or HLS).
+ * This is the music pipeline: search elsewhere, download REAL full tracks here.
+ */
+export const name = "soundcloud";
+
+let _client_id = null;   // cached; rotated by SoundCloud occasionally
+let _cidFetchedAt = 0;
+
+export function canHandle(url) {
+  try {
+    return hostMatches(new URL(String(url)).hostname, ["soundcloud.com", "snd.sc"]);
+  } catch { return false; }
+}
+
+export function trackId(url) {
+  const m = String(url).match(/soundcloud\.com\/([\w-]+)\/([\w-]+)/i);
+  return m ? `${m[1]}/${m[2]}` : null;
+}
+
+async function clientId() {
+  if (_client_id && Date.now() - _cidFetchedAt < 6 * 3600_000) return _client_id;
+  // SoundCloud ships its public client_id inside its JS bundles — read it like the web player does
+  const page = await fetchText("https://soundcloud.com/discover", {}, 15_000);
+  const bundles = [...new Set((page.text.match(/https:\/\/a-v2\.sndcdn\.com\/assets\/[^"']+\.js/g) || []))].slice(0, 14);
+  for (const b of bundles) {
+    try {
+      const js = await fetchText(b, {}, 15_000);
+      const m = js.text.match(/client_id[":= ]{1,4}([A-Za-z0-9]{24,40})/);
+      if (m) {
+        _client_id = m[1];
+        _cidFetchedAt = Date.now();
+        return _client_id;
+      }
+    } catch { /* try the next bundle */ }
+  }
+  throw new UMediaError(Codes.PROVIDER_UNAVAILABLE, "SoundCloud client_id not retrievable (site changed) — use the yt-dlp tier");
+}
+
+export async function resolve(url, ctx = {}) {
+  const attempt = { provider: name, status: "skipped" };
+  ctx.attempts?.push(attempt);
+  const t0 = Date.now();
+
+  const slug = trackId(url);
+  if (!slug) {
+    attempt.status = "failed";
+    throw new UMediaError(Codes.INVALID_URL, "Not a SoundCloud track URL (expected soundcloud.com/{user}/{track})", { attempts: [attempt] });
+  }
+
+  const cid = await clientId();
+  let track;
+  try {
+    track = await fetchJson(
+      `https://api-v2.soundcloud.com/resolve?url=${encodeURIComponent(String(url).split("?")[0])}&client_id=${cid}`, {}, 20_000);
+  } catch (e) {
+    attempt.status = "failed";
+    attempt.error = e.message;
+    throw new UMediaError(Codes.MEDIA_NOT_FOUND, `SoundCloud track not retrievable. ${e.message}`, { attempts: [attempt] });
+  }
+  if (!track || track.kind !== "track") {
+    attempt.status = "failed";
+    throw new UMediaError(Codes.MEDIA_NOT_FOUND, "SoundCloud: not a public track (removed, private, or a set)", { attempts: [attempt] });
+  }
+
+  const media = [];
+  const variants = [];
+  for (const tr of (track.media?.transcodings || [])) {
+    const fmt = tr.format || {};
+    const isProg = fmt.protocol === "progressive";
+    const isMp3 = /mpeg|mp3/i.test(fmt.mime_type || "");
+    variants.push({
+      url: `${tr.url}${tr.url.includes("?") ? "&" : "?"}client_id=${cid}`,
+      height: null, width: null,
+      hasAudio: true, hasVideo: false,
+      quality: tr.quality || (isProg ? "progressive" : fmt.protocol),
+      mimeType: fmt.mime_type || null,
+      protocol: fmt.protocol,
+      _mp3: isProg && isMp3,
+    });
+  }
+  // resolve each transcoding hop -> real CDN URL (progressive mp3 first, then HLS)
+  const order = [...variants].sort((a, b) => (b._mp3 ? 1 : 0) - (a._mp3 ? 1 : 0));
+  const resolvedVariants = [];
+  for (const v of order) {
+    try {
+      const hop = await fetchJson(v.url, {}, 15_000);
+      if (hop?.url) resolvedVariants.push({ ...v, url: hop.url });
+    } catch { /* rights-restricted encoding — skip honestly */ }
+  }
+
+  if (!resolvedVariants.length) {
+    attempt.status = "failed";
+    attempt.error = "no downloadable encodings (rights-restricted)";
+    throw new UMediaError(Codes.ACCESS_RESTRICTED,
+      "SoundCloud exposes no downloadable encoding for this track (rights-restricted) — stream it in-app or use the yt-dlp tier", { attempts: [attempt] });
+  }
+
+  const chosen = resolvedVariants.find((v) => v._mp3) || resolvedVariants[0];
+  media.push({
+    type: "audio", index: 0, url: chosen.url,
+    thumbnail: track.artwork_url || track.user?.avatar_url || null,
+    mimeType: chosen.mimeType || (/mpegurl/.test(chosen.mimeType || "") ? "application/x-mpegURL" : "audio/mpeg"),
+    width: null, height: null,
+    duration: track.duration ? Math.round(track.duration / 1000) : null,
+    size: null, quality: chosen.quality,
+    hasAudio: true, hasVideo: false, source: name,
+    variants: resolvedVariants.map((v) => ({
+      height: null, width: null, url: v.url,
+      hasAudio: true, hasVideo: false, quality: v.quality, mimeType: v.mimeType,
+    })),
+  });
+
+  attempt.status = "success";
+  attempt.latencyMs = Date.now() - t0;
+  return {
+    result: {
+      sourceUrl: url,
+      platform: name,
+      title: track.title || null,
+      author: track.user?.username || null,
+      thumbnail: track.artwork_url || null,
+      itemCount: 1,
+      counts: { images: 0, videos: 0, audios: 1, other: 0 },
+      truncated: false,
+      media,
+    },
+    engine: { attempts: ctx.attempts || [attempt], finalProvider: name, totalLatencyMs: Date.now() - t0 },
+  };
+}
+
+export async function search() {
+  return [];
+}

package/lib/providers/streamable.js

@@ -0,0 +1,93 @@
+import { fetchJson, hostMatches } from "../util.js";
+import { Codes, UMediaError } from "../errors.js";
+
+/**
+ * Streamable — the public video JSON (api.streamable.com/videos/{id}):
+ * direct mp4 renditions (mp4 / mp4-mobile / original) with real heights.
+ */
+export const name = "streamable";
+
+export function canHandle(url) {
+  try {
+    return hostMatches(new URL(String(url)).hostname, ["streamable.com"]);
+  } catch { return false; }
+}
+
+export function videoId(url) {
+  const m = String(url).match(/streamable\.com\/(?:e\/|video\/)?([a-z0-9]+)/i);
+  return m ? m[1] : null;
+}
+
+export async function resolve(url, ctx = {}) {
+  const attempt = { provider: name, status: "skipped" };
+  ctx.attempts?.push(attempt);
+  const t0 = Date.now();
+
+  const id = videoId(url);
+  if (!id) {
+    attempt.status = "failed";
+    throw new UMediaError(Codes.INVALID_URL, "Not a Streamable URL", { attempts: [attempt] });
+  }
+
+  let v;
+  try {
+    v = await fetchJson(`https://api.streamable.com/videos/${id}`, {}, 15_000);
+  } catch (e) {
+    attempt.status = "failed";
+    attempt.error = e.message;
+    throw new UMediaError(Codes.MEDIA_NOT_FOUND, `Streamable video not retrievable. ${e.message}`, { attempts: [attempt] });
+  }
+  if (v?.error || (v?.status && v.status !== 2 && !v.files)) {
+    attempt.status = "failed";
+    attempt.error = v?.error || v?.message || "video not found or still processing";
+    throw new UMediaError(Codes.MEDIA_NOT_FOUND, `Streamable: ${attempt.error}`, { attempts: [attempt] });
+  }
+
+  const variants = [];
+  for (const [key, f] of Object.entries(v.files || {})) {
+    // their API occasionally returns a doubled scheme — normalize, never silently drop
+    const raw = typeof f?.url === "string" ? f.url.replace(/^https:https:\/\//, "https://") : null;
+    if (!raw) continue;
+    variants.push({
+      height: f.height ?? null, width: f.width ?? null, url: raw,
+      hasAudio: true, hasVideo: true,
+      quality: key === "mp4-mobile" ? "360p" : (f.height ? `${f.height}p` : key),
+      mimeType: "video/mp4",
+    });
+  }
+  const chosen = variants.sort((a, b) => (b.height || 0) - (a.height || 0))[0];
+  if (!chosen) {
+    attempt.status = "failed";
+    throw new UMediaError(Codes.MEDIA_NOT_FOUND, "Streamable: no downloadable renditions (deleted or processing)", { attempts: [attempt] });
+  }
+
+  attempt.status = "success";
+  attempt.latencyMs = Date.now() - t0;
+  return {
+    result: {
+      sourceUrl: url,
+      platform: name,
+      title: v.title || null,
+      author: null,
+      thumbnail: (typeof v.thumbnail_url === "string" ? v.thumbnail_url.replace(/^https:https:\/\//, "https://") : v.thumbnail_url) || null,
+      itemCount: 1,
+      counts: { images: 0, videos: 1, audios: 0, other: 0 },
+      truncated: false,
+      media: [{
+        type: "video", index: 0, url: chosen.url,
+        thumbnail: (typeof v.thumbnail_url === "string" ? v.thumbnail_url.replace(/^https:https:\/\//, "https://") : v.thumbnail_url) || null,
+        mimeType: "video/mp4",
+        width: chosen.width ?? null, height: chosen.height ?? null,
+        duration: v.video_duration ?? v.duration ?? null,
+        size: null, quality: chosen.quality,
+        hasAudio: true, hasVideo: true, source: name, variants,
+      }],
+      streamUrlsAvailable: true,
+    },
+    engine: { attempts: ctx.attempts || [attempt], finalProvider: name, totalLatencyMs: Date.now() - t0 },
+  };
+}
+
+export async function search() {
+  return [];
+}

package/lib/providers/threads.js

@@ -0,0 +1,103 @@
+import { fetchText, hostMatches } from "../util.js";
+import { Codes, UMediaError } from "../errors.js";
+
+/**
+ * Threads (Meta) — the share page's server-rendered state (`video_url` /
+ * `image_urls` in the post JSON) plus official og: meta. Best-effort like all
+ * Meta surfaces (login-gated on some networks); yt-dlp tier covers gated ones.
+ */
+export const name = "threads";
+
+export function canHandle(url) {
+  try {
+    return hostMatches(new URL(String(url)).hostname, ["threads.net", "threads.com"]);
+  } catch { return false; }
+}
+
+export async function resolve(url, ctx = {}) {
+  const attempt = { provider: name, status: "skipped" };
+  ctx.attempts?.push(attempt);
+  const t0 = Date.now();
+
+  let html;
+  try {
+    const r = await fetchText(String(url), {
+      headers: {
+        "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0 Safari/537.36",
+        accept: "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+        "accept-language": "en-US,en;q=0.9",
+      },
+    }, 18_000);
+    html = r.text;
+  } catch (e) {
+    attempt.status = "failed";
+    attempt.error = e.message;
+    throw new UMediaError(Codes.PROVIDER_UNAVAILABLE, `Threads page not retrievable. ${e.message}`, { attempts: [attempt] });
+  }
+
+  const un = (s) => { try { return JSON.parse(`"${s}"`); } catch { return s.replace(/\\\//g, "/"); } };
+  const media = [];
+
+  // post state: video_url + display_url (escaped JSON strings inside the SSR payload)
+  const video = html.match(/\\"video_url\\":\\"((?:[^"\\]|\\.)+?)\\"/) || html.match(/"video_url":"((?:[^"\\]|\\.)+?)"/);
+  const image = html.match(/\\"display_url\\":\\"((?:[^"\\]|\\.)+?)\\"/) || html.match(/"display_url":"((?:[^"\\]|\\.)+?)"/);
+  if (video?.[1]) {
+    const u = un(video[1]);
+    if (/^https?:/.test(u)) media.push({
+      type: "video", index: 0, url: u, thumbnail: image ? un(image[1]) : u,
+      mimeType: "video/mp4", width: null, height: null, duration: null, size: null,
+      quality: null, hasAudio: true, hasVideo: true, source: name, variants: [],
+    });
+  }
+  if (!media.length && image?.[1]) {
+    const u = un(image[1]);
+    if (/^https?:/.test(u)) media.push({
+      type: "image", index: 0, url: u, thumbnail: u,
+      mimeType: "image/jpeg", width: null, height: null, duration: null, size: null,
+      quality: null, hasAudio: false, hasVideo: false, source: name, variants: [],
+    });
+  }
+
+  // og: meta fallback
+  if (!media.length) {
+    const ogv = (html.match(/property="og:video"[^>]+content="([^"]+)"/) || html.match(/content="([^"]+)"[^>]+property="og:video"/) || [])[1];
+    const ogi = (html.match(/property="og:image"[^>]+content="([^"]+)"/) || html.match(/content="([^"]+)"[^>]+property="og:image"/) || [])[1];
+    const u = ogv || ogi;
+    if (u && /^https?:/.test(u)) media.push({
+      type: ogv ? "video" : "image", index: 0, url: u.replace(/&/g, "&"), thumbnail: (ogi || u).replace(/&/g, "&"),
+      mimeType: ogv ? "video/mp4" : "image/jpeg", width: null, height: null,
+      duration: null, size: null, quality: null,
+      hasAudio: Boolean(ogv), hasVideo: Boolean(ogv), source: name, variants: [],
+    });
+  }
+
+  if (!media.length) {
+    attempt.status = "failed";
+    attempt.error = "no media in the public page (login-gated or removed)";
+    throw new UMediaError(Codes.MEDIA_NOT_FOUND,
+      `Threads exposes no media for this URL (${attempt.error}) — the yt-dlp tier covers gated posts.`, { attempts: [attempt] });
+  }
+
+  const title = (html.match(/"caption":"((?:[^"\\]|\\.){1,200})"/) || html.match(/<title[^>]*>([^<]*)/i) || [])[1] || null;
+  attempt.status = "success";
+  attempt.latencyMs = Date.now() - t0;
+  return {
+    result: {
+      sourceUrl: url,
+      platform: name,
+      title: title ? un(title).slice(0, 200) : null,
+      author: (String(url).match(/@([\w.]+)/) || [])[1] || null,
+      thumbnail: media[0].thumbnail,
+      itemCount: media.length,
+      counts: { images: media.filter((m) => m.type === "image").length, videos: media.filter((m) => m.type === "video").length, audios: 0, other: 0 },
+      truncated: false,
+      media,
+      streamUrlsAvailable: true,
+    },
+    engine: { attempts: ctx.attempts || [attempt], finalProvider: name, totalLatencyMs: Date.now() - t0 },
+  };
+}
+
+export async function search() {
+  return [];
+}

package/lib/providers/tumblr.js

@@ -0,0 +1,153 @@
+import { fetchJson, hostMatches } from "../util.js";
+import { Codes, UMediaError } from "../errors.js";
+
+/**
+ * Tumblr — the public mobile API (api-http2.tumblr.com, the same endpoint the
+ * official iPhone app calls with its public api_key). Videos, audio, photos —
+ * including reblog trails. Reference: cobalt tumblr service.
+ */
+export const name = "tumblr";
+
+const API_KEY = "jrsCWX1XDuVxAFO4GkK147syAoN8BJZ5voz8tS80bPcj26Vc5Z";
+const API_BASE = "https://api-http2.tumblr.com";
+const MOBILE = {
+  "user-agent": "Tumblr/iPhone/33.3/333010/17.3.1/tumblr",
+  "x-version": "iPhone/33.3/333010/17.3.1/tumblr",
+};
+
+export function canHandle(url) {
+  try {
+    return hostMatches(new URL(String(url)).hostname, ["tumblr.com"]);
+  } catch { return false; }
+}
+
+export function parseUrl(url) {
+  const u = new URL(String(url));
+  const host = u.hostname.replace(/^www\./, "");
+  let m;
+  // https://{user}.tumblr.com/post/{id}/...
+  m = u.pathname.match(/^\/post\/(\d+)/);
+  if (m && host !== "tumblr.com") return { user: host.split(".")[0], id: m[1] };
+  // https://www.tumblr.com/{user}/{id} or /blog/view/{user}/{id}
+  m = u.pathname.match(/^\/(?:blog\/view\/)?([\w.-]+)\/(\d+)/);
+  if (m) return { user: m[1], id: m[2] };
+  return null;
+}
+
+export async function resolve(url, ctx = {}) {
+  const attempt = { provider: name, status: "skipped" };
+  ctx.attempts?.push(attempt);
+  const t0 = Date.now();
+
+  const parsed = parseUrl(url);
+  if (!parsed) {
+    attempt.status = "failed";
+    throw new UMediaError(Codes.INVALID_URL, "Not a Tumblr post URL (expected {user}.tumblr.com/post/{id} or tumblr.com/{user}/{id})", { attempts: [attempt] });
+  }
+
+  let data;
+  try {
+    data = await fetchJson(
+      `${API_BASE}/v2/blog/${encodeURIComponent(parsed.user)}.tumblr.com/posts/${parsed.id}/permalink?api_key=${API_KEY}`, { headers: MOBILE }, 20_000);
+  } catch (e) {
+    attempt.status = "failed";
+    attempt.error = e.message;
+    throw new UMediaError(Codes.PROVIDER_UNAVAILABLE, `Tumblr API unavailable. ${e.message}`, { attempts: [attempt] });
+  }
+
+  const element = data?.response?.timeline?.elements?.[0];
+  if (!element) {
+    attempt.status = "failed";
+    attempt.error = data?.meta?.msg || "post not found";
+    throw new UMediaError(Codes.MEDIA_NOT_FOUND, `Tumblr: ${attempt.error}`, { attempts: [attempt] });
+  }
+
+  // contents: the post itself + any reblog trail, in order — ALL of it
+  const contents = [
+    ...(element.content || []),
+    ...(element.trail || []).flatMap((t) => t.content || []),
+  ];
+
+  const media = [];
+  for (const c of contents) {
+    if (c.type === "video" && (c.provider === "tumblr" || !c.provider) && c.media?.url) {
+      media.push({
+        type: "video", index: media.length, url: c.media.url,
+        thumbnail: c.poster?.[0]?.url || null,
+        mimeType: "video/mp4", width: c.width ?? null, height: c.height ?? null,
+        duration: null, size: null, quality: null,
+        hasAudio: true, hasVideo: true, source: name, variants: [],
+      });
+    } else if (c.type === "audio" && c.media?.url) {
+      media.push({
+        type: "audio", index: media.length, url: c.media.url,
+        thumbnail: null, mimeType: "audio/mpeg", width: null, height: null,
+        duration: null, size: null, quality: null,
+        hasAudio: true, hasVideo: false, source: name, variants: [],
+      });
+    } else if (c.type === "image" || c.type === "photo") {
+      // image content carries media as an ARRAY of renditions — take the best
+      // one as the item, keep the rest as variants. never inflate items.
+      const items = (Array.isArray(c.media) ? c.media : (c.media?.url ? [c.media] : []))
+        .filter((mm) => mm?.url);
+      const uniq = [...new Map(items.map((mm) => [mm.url, mm])).values()]
+        .sort((a, b) => ((b.width || 0) * (b.height || 0)) - ((a.width || 0) * (a.height || 0)));
+      const best = uniq[0];
+      if (best) {
+        media.push({
+          type: "image", index: media.length, url: best.url,
+          thumbnail: best.url, mimeType: "image/jpeg",
+          width: best.width ?? null, height: best.height ?? null,
+          duration: null, size: null, quality: best.width ? `${best.width}px` : null,
+          hasAudio: false, hasVideo: false, source: name,
+          variants: uniq.map((x) => ({
+            height: x.height ?? null, width: x.width ?? null, url: x.url,
+            hasAudio: false, hasVideo: false, quality: x.width ? `${x.width}px` : null, mimeType: "image/jpeg",
+          })),
+        });
+      }
+    }
+  }
+
+  // reblog trails repeat media from earlier hops — dedupe by URL, keep first order
+  const seen = new Set();
+  const deduped = [];
+  for (const mm of media) {
+    if (seen.has(mm.url)) continue;
+    seen.add(mm.url);
+    deduped.push({ ...mm, index: deduped.length });
+  }
+  media.length = 0;
+  media.push(...deduped);
+
+  if (!media.length) {
+    attempt.status = "failed";
+    throw new UMediaError(Codes.MEDIA_NOT_FOUND, "Tumblr post contains no downloadable media (text/link post, or third-party embed — use the yt-dlp tier for YouTube/Vimeo embeds)", { attempts: [attempt] });
+  }
+
+  attempt.status = "success";
+  attempt.latencyMs = Date.now() - t0;
+  return {
+    result: {
+      sourceUrl: url,
+      platform: name,
+      title: (element.summary || element.let || "").slice(0, 200) || null,
+      author: element.blog_name || parsed.user,
+      thumbnail: media[0].thumbnail,
+      itemCount: media.length,
+      counts: {
+        images: media.filter((m) => m.type === "image").length,
+        videos: media.filter((m) => m.type === "video").length,
+        audios: media.filter((m) => m.type === "audio").length, other: 0,
+      },
+      truncated: false,
+      media,
+      streamUrlsAvailable: true,
+    },
+    engine: { attempts: ctx.attempts || [attempt], finalProvider: name, totalLatencyMs: Date.now() - t0 },
+  };
+}
+
+export async function search() {
+  return [];
+}