umedia 0.2.2 → 0.4.0

package/lib/providers/twitch.js

@@ -0,0 +1,108 @@
+import { fetchJson, hostMatches } from "../util.js";
+import { Codes, UMediaError } from "../errors.js";
+
+/**
+ * Twitch clips — the public GraphQL endpoint the web player calls (its web
+ * client-id ships in Twitch's own JS; nothing secret). Direct CloudFront mp4
+ * renditions per quality. VODs/livestreams need the yt-dlp tier (honest).
+ */
+export const name = "twitch";
+
+// Twitch's own public web client id (shipped in their frontend bundle)
+const CLIENT_ID = "kimne78kx3ncx6brgo4mv6wki5h1ko";
+
+export function canHandle(url) {
+  try {
+    return hostMatches(new URL(String(url)).hostname, ["twitch.tv", "clips.twitch.tv"]);
+  } catch { return false; }
+}
+
+export function clipSlug(url) {
+  const m = String(url).match(/(?:clips\.twitch\.tv\/|\/clip\/)([\w-]+)/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 slug = clipSlug(url);
+  if (!slug) {
+    attempt.status = "failed";
+    throw new UMediaError(Codes.INVALID_URL,
+      "Only Twitch CLIP urls resolve natively (clips.twitch.tv/{slug} or twitch.tv/{ch}/clip/{slug}). VODs/livestreams: use downloadWithYtdlp().", { attempts: [attempt] });
+  }
+
+  let gql;
+  try {
+    gql = await fetchJson("https://gql.twitch.tv/gql",
+      {
+        method: "POST",
+        headers: { "client-id": CLIENT_ID, "content-type": "text/plain" },
+        body: JSON.stringify({
+          query: `query{clip(slug:"${slug}"){title durationSeconds broadcaster{displayName} thumbnailURL videoQualities{frameRate quality sourceURL} playbackAccessToken(params:{platform:"web",playerType:"site"}){value signature}}}`,
+        }),
+      }, 15_000);
+  } catch (e) {
+    attempt.status = "failed";
+    attempt.error = e.message;
+    throw new UMediaError(Codes.PROVIDER_UNAVAILABLE, `Twitch GraphQL unavailable. ${e.message}`, { attempts: [attempt] });
+  }
+  const clip = gql?.data?.clip;
+  if (!clip) {
+    attempt.status = "failed";
+    attempt.error = "clip not found (expired clips are removed with their VOD)";
+    throw new UMediaError(Codes.MEDIA_NOT_FOUND, `Twitch: ${attempt.error}`, { attempts: [attempt] });
+  }
+
+  // Twitch CDN (nauth) URLs only serve with the clip's playback token — sign them like the web player
+  const tok = clip.playbackAccessToken;
+  const sign = (u) => (tok?.value && tok?.signature
+    ? `${u}${u.includes("?") ? "&" : "?"}token=${encodeURIComponent(tok.value)}&sig=${tok.signature}`
+    : u);
+
+  const variants = (clip.videoQualities || [])
+    .filter((q) => q?.sourceURL)
+    .map((q) => ({
+      height: parseInt(q.quality, 10) || null, width: null, url: sign(q.sourceURL),
+      hasAudio: true, hasVideo: true,
+      quality: q.quality ? `${q.quality}p` : null, mimeType: "video/mp4",
+    }))
+    .sort((a, b) => (b.height || 0) - (a.height || 0));
+  const chosen = variants[0];
+  if (!chosen) {
+    attempt.status = "failed";
+    throw new UMediaError(Codes.MEDIA_NOT_FOUND, "Twitch clip has no downloadable renditions", { attempts: [attempt] });
+  }
+
+  attempt.status = "success";
+  attempt.latencyMs = Date.now() - t0;
+  return {
+    result: {
+      sourceUrl: url,
+      platform: name,
+      title: clip.title || null,
+      author: clip.broadcaster?.displayName || null,
+      thumbnail: clip.thumbnailURL || null,
+      itemCount: 1,
+      counts: { images: 0, videos: 1, audios: 0, other: 0 },
+      truncated: false,
+      media: [{
+        type: "video", index: 0, url: chosen.url,
+        thumbnail: clip.thumbnailURL || null,
+        mimeType: "video/mp4",
+        width: null, height: chosen.height ?? null,
+        duration: clip.durationSeconds ?? 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/vimeo.js

@@ -0,0 +1,108 @@
+import { fetchJson, hostMatches } from "../util.js";
+import { Codes, UMediaError } from "../errors.js";
+
+/**
+ * Vimeo — the public player config JSON (player.vimeo.com/video/{id}/config):
+ * progressive renditions when Vimeo serves them, otherwise HLS masters with
+ * real per-rendition quality labels.
+ */
+export const name = "vimeo";
+
+export function canHandle(url) {
+  try {
+    return hostMatches(new URL(String(url)).hostname, ["vimeo.com", "player.vimeo.com"]);
+  } catch { return false; }
+}
+
+export function videoId(url) {
+  const m = String(url).match(/(?:video\/|vimeo\.com\/(?:video\/)?)(\d{6,12})/);
+  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 Vimeo video URL (password-protected/album URLs need the yt-dlp tier)", { attempts: [attempt] });
+  }
+
+  let cfg;
+  try {
+    cfg = await fetchJson(`https://player.vimeo.com/video/${id}/config`,
+      { headers: { referer: "https://vimeo.com/" } }, 15_000);
+  } catch (e) {
+    attempt.status = "failed";
+    attempt.error = e.message;
+    throw new UMediaError(Codes.PROVIDER_UNAVAILABLE, `Vimeo player config unavailable. ${e.message}`, { attempts: [attempt] });
+  }
+  const v = cfg?.video;
+  if (!v) {
+    attempt.status = "failed";
+    attempt.error = cfg?.title || "video unavailable";
+    throw new UMediaError(Codes.MEDIA_NOT_FOUND, `Vimeo: ${attempt.error}`, { attempts: [attempt] });
+  }
+
+  const files = cfg.request?.files || {};
+  const variants = [];
+  for (const p of (files.progressive || [])) {
+    if (!p?.url) continue;
+    variants.push({
+      height: p.height ?? null, width: p.width ?? null, url: p.url,
+      hasAudio: true, hasVideo: true,
+      quality: p.quality || (p.height ? `${p.height}p` : null),
+      mimeType: p.mime || "video/mp4",
+    });
+  }
+  const hls = files.hls || {};
+  const cdns = hls.cdns || {};
+  const defaultUrl = cdns[hls.default_cdn]?.avc_url || Object.values(cdns)[0]?.avc_url || null;
+  if (defaultUrl) {
+    variants.push({
+      height: null, width: null, url: defaultUrl,
+      hasAudio: !hls.separate_av, hasVideo: true,
+      quality: "hls", mimeType: "application/x-mpegURL",
+    });
+  }
+
+  const progressive = variants.find((v) => /mp4/.test(v.mimeType || ""));
+  const chosen = progressive || variants[0];
+  if (!chosen) {
+    attempt.status = "failed";
+    throw new UMediaError(Codes.MEDIA_NOT_FOUND, "Vimeo serves no stream URLs (private or domain-restricted video)", { attempts: [attempt] });
+  }
+
+  attempt.status = "success";
+  attempt.latencyMs = Date.now() - t0;
+  return {
+    result: {
+      sourceUrl: url,
+      platform: name,
+      title: v.title || null,
+      author: cfg.owner?.display_name || cfg.user?.name || null,
+      thumbnail: v.thumbs?.base || v.thumb || null,
+      itemCount: 1,
+      counts: { images: 0, videos: 1, audios: 0, other: 0 },
+      truncated: false,
+      media: [{
+        type: "video", index: 0, url: chosen.url,
+        thumbnail: v.thumbs?.base || v.thumb || null,
+        mimeType: chosen.mimeType,
+        width: v.width ?? null, height: v.height ?? null,
+        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/x.js

@@ -1,69 +1,213 @@
 import { fetchJson, hostMatches } from "../util.js";
 import { Codes, UMediaError } from "../errors.js";
 
-/** X (Twitter) — syndication endpoint for public posts. Best-effort, honestly labeled. */
+/**
+ * X / Twitter — two proven public routes, no login:
+ *  1. syndication embed API with the computed token (the route embed widgets use)
+ *  2. GraphQL TweetDetail with a guest token (the route the logged-out web uses)
+ * Both are the exact techniques from yt-dlp's twitter extractor and cobalt's
+ * twitter service. Photos, videos (best bitrate mp4), gifs.
+ */
 export const name = "x";
 
+const BEARER = "AAAAAAAAAAAAAAAAAAAAANRILgAAAAAAnNwIzUejRCOuH5E6I8xnZz4puTs%3D1Zv7ttfk8LF81IUq16cHjhLTvJu4FA33AGWWjCpTnA";
+const GQL_FEATURES = JSON.stringify({
+  rweb_video_screen_enabled: false, payments_enabled: false, rweb_xchat_enabled: false,
+  profile_label_improvements_pcf_label_in_post_enabled: true, rweb_tipjar_consumption_enabled: true,
+  verified_phone_label_enabled: false, creator_subscriptions_tweet_preview_api_enabled: true,
+  responsive_web_graphql_timeline_navigation_enabled: true, responsive_web_graphql_skip_user_profile_image_extensions_enabled: false,
+  premium_content_api_read_enabled: false, communities_web_enable_tweet_community_results_fetch: true,
+  c9s_tweet_anatomy_moderator_badge_enabled: true, responsive_web_grok_analyze_button_fetch_trends_enabled: false,
+  responsive_web_grok_analyze_post_followups_enabled: true, responsive_web_jetfuel_frame: true,
+  responsive_web_grok_share_attachment_enabled: true, articles_preview_enabled: true,
+  responsive_web_edit_tweet_api_enabled: true, graphql_is_translatable_rweb_tweet_is_translatable_enabled: true,
+  view_counts_everywhere_api_enabled: true, longform_notetweets_consumption_enabled: true,
+  responsive_web_twitter_article_tweet_consumption_enabled: true, tweet_awards_web_tipping_enabled: false,
+  creator_subscriptions_quote_tweet_preview_enabled: false, freedom_of_speech_not_reach_fetch_enabled: true,
+  standardized_nudges_misinfo: true, tweet_with_visibility_results_prefer_gql_limited_actions_policy_enabled: true,
+  longform_notetweets_rich_text_read_enabled: true, longform_notetweets_inline_media_enabled: true,
+  responsive_web_grok_image_annotation_enabled: true, responsive_web_grok_imagine_annotation_enabled: true,
+  responsive_web_grok_community_note_auto_translation_is_enabled: false, responsive_web_enhance_cards_enabled: false,
+});
+
+const GQL_HEADERS = {
+  authorization: `Bearer ${BEARER}`,
+  "x-twitter-client-language": "en",
+  "x-twitter-active-user": "yes",
+  "accept-language": "en",
+  "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0 Safari/537.36",
+};
+
 export function canHandle(url) {
   try {
     return hostMatches(new URL(String(url)).hostname, ["twitter.com", "x.com"]);
   } catch { return false; }
 }
 
+export function tweetId(url) {
+  const m = String(url).match(/\/status(?:es)?\/(\d{8,25})/);
+  return m ? m[1] : null;
+}
+
+// the syndication embed token — computed from the tweet id (yt-dlp technique)
+const syndicationToken = (id) => ((Number(id) / 1e15) * Math.PI).toString(36).replace(/(0+|\.)/g, "");
+
+let _guestToken = null;
+async function guestToken() {
+  if (_guestToken) return _guestToken;
+  try {
+    const j = await fetchJson("https://api.x.com/1.1/guest/activate.json", {
+      method: "POST", headers: GQL_HEADERS,
+    }, 15_000);
+    if (j?.guest_token) return (_guestToken = j.guest_token);
+  } catch { /* syndication may still work */ }
+  return null;
+}
+
+function mediaFromEntities(entities, media) {
+  for (const m of entities || []) {
+    const isPhoto = m.type === "photo";
+    const isVideo = m.type === "video" || m.type === "animated_gif";
+    if (isPhoto && m.media_url_https) {
+      media.push({
+        type: "image", index: media.length, url: m.media_url_https, thumbnail: m.media_url_https,
+        mimeType: "image/jpeg", width: m.original_info?.width ?? null, height: m.original_info?.height ?? null,
+        duration: null, size: null, quality: "original",
+        hasAudio: false, hasVideo: false, source: name, variants: [],
+      });
+    } else if (isVideo && m.video_info?.variants?.length) {
+      const mp4s = m.video_info.variants
+        .filter((v) => v.content_type === "video/mp4" && v.url)
+        .map((v) => ({
+          height: null, width: null,
+          // cobalt strips the flaky `tag` param from twitter mp4 urls
+          url: (() => { try { const u = new URL(v.url); u.searchParams.delete("tag"); return u.toString(); } catch { return v.url; } })(),
+          hasAudio: true, hasVideo: true,
+          quality: v.bitrate ? `${Math.round(v.bitrate / 1000)}kbps` : "mp4",
+          mimeType: "video/mp4", bitrate: v.bitrate ?? null,
+        }))
+        .sort((a, b) => (b.bitrate || 0) - (a.bitrate || 0));
+      const best = mp4s[0]
+        || m.video_info.variants.filter((v) => v.url).map((v) => ({
+          height: null, width: null, url: v.url, hasAudio: true, hasVideo: true,
+          quality: null, mimeType: v.content_type || "application/x-mpegURL", bitrate: null,
+        }))[0];
+      if (best) {
+        media.push({
+          type: "video", index: media.length, url: best.url,
+          thumbnail: m.media_url_https || null,
+          mimeType: best.mimeType, width: m.original_info?.width ?? null, height: m.original_info?.height ?? null,
+          duration: m.video_info.duration_millis ? Math.round(m.video_info.duration_millis / 1000) : null,
+          size: null, quality: best.quality,
+          hasAudio: true, hasVideo: true, source: name, variants: mp4s,
+        });
+      }
+    }
+  }
+}
+
 export async function resolve(url, ctx = {}) {
   const attempt = { provider: name, status: "skipped" };
   ctx.attempts?.push(attempt);
-  const m = String(url).match(/status\/(\d+)/);
-  if (!m) throw new UMediaError(Codes.INVALID_URL, `No status id in ${url}`);
   const t0 = Date.now();
+
+  const id = tweetId(url);
+  if (!id) {
+    attempt.status = "failed";
+    throw new UMediaError(Codes.INVALID_URL, "Not a tweet URL (expected x.com/{user}/status/{id})", { attempts: [attempt] });
+  }
+
+  const media = [];
+  let title = null;
+  let author = null;
+
+  // 1) GraphQL TweetDetail with guest token (fullest data)
   try {
-    const tw = await fetchJson(`https://cdn.syndication.twimg.com/tweet-result?id=${m[1]}&lang=en`, {}, 12_000);
-    const media = [];
-    const photos = tw.photos || [];
-    photos.forEach((p, i) => media.push({
-      type: "image", index: i, url: p.url, thumbnail: p.url,
-      mimeType: "image/jpeg", width: p.width ?? null, height: p.height ?? null,
-      duration: null, size: null, quality: p.width && p.height ? `${p.width}x${p.height}` : null,
-      hasAudio: false, hasVideo: false, source: name, variants: [],
-    }));
-    const vids = tw.video?.variants || [];
-    const mp4s = vids.filter((v) => v.src?.includes(".mp4")).sort((a, b) => (b.bitrate || 0) - (a.bitrate || 0));
-    if (mp4s.length) {
-      const best = mp4s[0];
-      media.push({
-        type: "video", index: media.length, url: best.src, thumbnail: tw.video?.poster ?? null,
-        mimeType: "video/mp4", width: null, height: null,
-        duration: tw.video?.duration_millis ? tw.video.duration_millis / 1000 : null,
-        size: null, quality: best.bitrate ? `~${Math.round(best.bitrate / 1000)}kbps` : null,
-        hasAudio: true, hasVideo: true, source: name,
-        variants: mp4s.map((v) => ({
-          quality: v.bitrate ? `~${Math.round(v.bitrate / 1000)}kbps` : "unknown",
-          url: v.src, mimeType: "video/mp4", hasAudio: true, hasVideo: true,
-        })),
-      });
+    const token = await guestToken();
+    if (token) {
+      const u = new URL("https://api.x.com/graphql/4Siu98E55GquhG52zHdY5w/TweetDetail");
+      u.searchParams.set("variables", JSON.stringify({
+        focalTweetId: id, with_rux_injections: false, rankingMode: "Relevance",
+        includePromotedContent: true, withCommunity: true,
+        withQuickPromoteEligibilityTweetFields: true, withBirdwatchNotes: true, withVoice: true,
+      }));
+      u.searchParams.set("features", GQL_FEATURES);
+      u.searchParams.set("fieldToggles", JSON.stringify({ withArticleRichContentState: true, withArticlePlainText: false }));
+      const j = await fetchJson(u.toString(), {
+        headers: { ...GQL_HEADERS, "content-type": "application/json", "x-guest-token": token, cookie: `guest_id=v1%3A${token}` },
+      }, 20_000);
+      const entries = j?.data?.threaded_conversation_with_injections_v2?.instructions
+        ?.find((i) => i.type === "TimelineAddEntries")?.entries || [];
+      const node = entries.find((e) => e.entryId === `tweet-${id}`)?.content?.itemContent?.tweet_results?.result;
+      let base = node?.legacy;
+      if (node?.__typename === "TweetWithVisibilityResults") base = node.tweet?.legacy;
+      const rep = base?.retweeted_status_result?.result?.legacy?.extended_entities
+        || base?.retweeted_status_result?.result?.tweet?.legacy?.extended_entities;
+      if (base?.full_text) title = base.full_text;
+      author = node?.core?.user_results?.result?.legacy?.screen_name
+        || node?.tweet?.core?.user_results?.result?.legacy?.screen_name || null;
+      mediaFromEntities(rep?.media || base?.extended_entities?.media, media);
     }
-    if (!media.length) throw new UMediaError(Codes.MEDIA_NOT_FOUND, "Post has no media (or it is not public)");
-    attempt.status = "success";
-    attempt.latencyMs = Date.now() - t0;
-    return {
-      result: {
-        sourceUrl: url, platform: "x", title: (tw.text || "").slice(0, 120) || null,
-        author: tw.user?.screen_name ?? null, thumbnail: media[0].thumbnail ?? null,
-        itemCount: media.length,
-        counts: {
-          images: media.filter((x) => x.type === "image").length,
-          videos: media.filter((x) => x.type === "video").length, audios: 0, other: 0,
-        },
-        truncated: false, media,
-      },
-      engine: { attempts: ctx.attempts || [attempt], finalProvider: name, totalLatencyMs: Date.now() - t0 },
-    };
   } catch (e) {
+    attempt.note = `graphql: ${String(e.message).slice(0, 60)}`;
+  }
+
+  // 2) syndication embed API with the computed token (embed-widget route)
+  if (!media.length) {
+    try {
+      const j = await fetchJson(
+        `https://cdn.syndication.twimg.com/tweet-result?id=${id}&token=${syndicationToken(id)}&lang=en`, {}, 15_000);
+      title = title || j?.text || null;
+      author = author || j?.user?.screen_name || null;
+      mediaFromEntities(j?.mediaDetails, media);
+      if (!media.length && j?.video?.variants) {
+        const mp4s = j.video.variants.filter((v) => v.type === "video/mp4").sort((a, b) => (b.bitrate || 0) - (a.bitrate || 0));
+        if (mp4s[0]) media.push({
+          type: "video", index: 0, url: mp4s[0].src, thumbnail: j.thumbnail?.image?.src || null,
+          mimeType: "video/mp4", width: null, height: null,
+          duration: j.video.duration_millis ? Math.round(j.video.duration_millis / 1000) : null,
+          size: null, quality: mp4s[0].bitrate ? `${Math.round(mp4s[0].bitrate / 1000)}kbps` : null,
+          hasAudio: true, hasVideo: true, source: name,
+          variants: mp4s.map((v) => ({ height: null, width: null, url: v.src, hasAudio: true, hasVideo: true, quality: v.bitrate ? `${Math.round(v.bitrate / 1000)}kbps` : null, mimeType: "video/mp4", bitrate: v.bitrate ?? null })),
+        });
+      }
+    } catch (e) {
+      attempt.note = `${attempt.note ? attempt.note + " · " : ""}syndication: ${String(e.message).slice(0, 60)}`;
+    }
+  }
+
+  if (!media.length) {
     attempt.status = "failed";
-    attempt.error = e.message;
-    if (e instanceof UMediaError) throw e;
-    throw new UMediaError(Codes.PROVIDER_UNAVAILABLE, `X unavailable: ${e.message}`, { attempts: [attempt] });
+    attempt.error = j_err(attempt.note);
+    throw new UMediaError(Codes.MEDIA_NOT_FOUND,
+      `X exposes no media for this tweet (${attempt.error}) — protected/removed tweets stay inaccessible; the yt-dlp tier adds cookie support.`, { attempts: [attempt] });
   }
+
+  attempt.status = "success";
+  attempt.latencyMs = Date.now() - t0;
+  return {
+    result: {
+      sourceUrl: url,
+      platform: name,
+      title: title ? title.slice(0, 200) : 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 },
+  };
+}
+
+function j_err(note) {
+  return (note || "no media in public routes").replace(/^.*?(graphql|syndication)/, "$1");
 }
 
 export async function search() {

package/lib/registry.js

@@ -1,14 +1,26 @@
 import * as yt from "./providers/youtube.js";
 import * as tiktok from "./providers/tiktok.js";
+import * as pinterest from "./providers/pinterest.js";
+import * as soundcloud from "./providers/soundcloud.js";
+import * as dailymotion from "./providers/dailymotion.js";
+import * as vimeo from "./providers/vimeo.js";
+import * as streamable from "./providers/streamable.js";
+import * as twitch from "./providers/twitch.js";
+import * as bluesky from "./providers/bluesky.js";
 import * as reddit from "./providers/reddit.js";
 import * as xprov from "./providers/x.js";
 import * as ig from "./providers/instagram.js";
+import * as facebook from "./providers/facebook.js";
+import * as threads from "./providers/threads.js";
+import * as snapchat from "./providers/snapchat.js";
+import * as rumble from "./providers/rumble.js";
+import * as tumblr from "./providers/tumblr.js";
 import * as ytdlp from "./providers/ytdlp.js";
 import * as itunes from "./providers/itunes.js";
 import { Codes, UMediaError } from "./errors.js";
 import { validateUrl } from "./util.js";
 
-const NATIVE = [yt, tiktok, reddit, xprov, ig];
+const NATIVE = [yt, tiktok, pinterest, soundcloud, dailymotion, vimeo, streamable, twitch, bluesky, reddit, xprov, ig, facebook, threads, snapchat, rumble, tumblr];
 
 export function detectPlatform(url) {
   for (const p of NATIVE) {
@@ -49,6 +61,7 @@ export async function resolve(url) {
   }
 
   const ctx = { attempts: [] };
+  let lastTyped = null;
   for (const p of NATIVE) {
     if (!p.canHandle(url)) continue;
     try {
@@ -61,6 +74,7 @@ export async function resolve(url) {
         throw e;
       }
       // transient/provider failure → try the next layer
+      if (e instanceof UMediaError) lastTyped = e;
       continue;
     }
   }
@@ -74,6 +88,12 @@ export async function resolve(url) {
     }
   }
   const last = ctx.attempts[ctx.attempts.length - 1];
+  // surface the real provider error when every matching provider failed —
+  // never mask a typed outcome behind a generic message
+  if (lastTyped) {
+    lastTyped.attempts = ctx.attempts;
+    throw lastTyped;
+  }
   throw new UMediaError(
     detectPlatform(url) === "unknown" ? Codes.INVALID_URL : Codes.PROVIDER_UNAVAILABLE,
     `No provider could resolve this URL.${last?.error ? " Last error: " + last.error : ""}` +
@@ -99,10 +119,22 @@ export function capabilities() {
   return {
     platforms: [
       { platform: "youtube", search: true, resolve: true, download: "network-dependent (yt-dlp tier recommended)", notes: "search+metadata always; stream URLs depend on network/PO-token state" },
-      { platform: "tiktok", search: false, resolve: true, download: true, notes: "photo galleries + video posts" },
-      { platform: "instagram", search: false, resolve: true, download: true, notes: "public embed best-effort" },
-      { platform: "reddit", search: false, resolve: true, download: true, notes: "posts + galleries" },
-      { platform: "x", search: false, resolve: true, download: true, notes: "public posts via syndication" },
+      { platform: "tiktok", search: false, resolve: true, download: true, notes: "video posts = direct CDN mp4; galleries = every slide the platform exposes (truncated flag honest)" },
+      { platform: "pinterest", search: false, resolve: true, download: true, notes: "image pins, video pins (direct mp4), idea/story pins, pin.it links" },
+      { platform: "soundcloud", search: false, resolve: true, download: true, notes: "full tracks: direct progressive MP3 + HLS, real titles/artists" },
+      { platform: "dailymotion", search: false, resolve: true, download: true, notes: "public metadata API; HLS/progressive renditions" },
+      { platform: "vimeo", search: false, resolve: true, download: true, notes: "player config: progressive mp4 when served, HLS otherwise" },
+      { platform: "streamable", search: false, resolve: true, download: true, notes: "direct mp4 renditions" },
+      { platform: "twitch", search: false, resolve: true, download: true, notes: "clips = direct mp4s; VODs/livestreams via yt-dlp tier" },
+      { platform: "bluesky", search: false, resolve: true, download: true, notes: "public AppView API: full-size images + video playlists" },
+      { platform: "instagram", search: false, resolve: true, download: true, notes: "oEmbed→mobile info API: photos, videos, full carousels" },
+      { platform: "reddit", search: false, resolve: true, download: true, notes: "posts + galleries + video with audio sidecar" },
+      { platform: "x", search: false, resolve: true, download: true, notes: "syndication token + guest GraphQL — photos/videos/gifs" },
+      { platform: "facebook", search: false, resolve: true, download: true, notes: "reels/watch/videos/shares/fb.watch via the player JSON" },
+      { platform: "threads", search: false, resolve: true, download: true, notes: "post SSR state + og media" },
+      { platform: "snapchat", search: false, resolve: true, download: true, notes: "spotlight videos + public story snap lists" },
+      { platform: "rumble", search: false, resolve: true, download: true, notes: "embed API: direct mp4 renditions" },
+      { platform: "tumblr", search: false, resolve: true, download: true, notes: "mobile API: video/audio/photo posts + reblog trails" },
       { platform: "itunes", search: true, resolve: false, download: "previews", notes: "real 30s clips" },
       { platform: "ytdlp", search: false, resolve: Boolean(ytdlp.binary()), download: Boolean(ytdlp.binary()), notes: "optional tier: 1800+ sites — install yt-dlp" },
     ],
@@ -116,10 +148,22 @@ export function status() {
     runtime: { node: process.version, platform: process.platform },
     providers: [
       { name: "youtube", state: "operational", via: "youtubei.js" },
-      { name: "tiktok", state: "operational", via: "embed/v2" },
-      { name: "instagram", state: "degraded", via: "public embed (best-effort)" },
+      { name: "tiktok", state: "operational", via: "embed state" },
+      { name: "pinterest", state: "operational", via: "public widget API" },
+      { name: "soundcloud", state: "operational", via: "public api-v2" },
+      { name: "dailymotion", state: "operational", via: "player metadata" },
+      { name: "vimeo", state: "operational", via: "player config" },
+      { name: "streamable", state: "operational", via: "public video api" },
+      { name: "twitch", state: "operational", via: "public GraphQL (clips)" },
+      { name: "bluesky", state: "operational", via: "public AppView XRPC" },
+      { name: "instagram", state: "operational", via: "oEmbed + mobile info api" },
       { name: "reddit", state: "operational", via: "public json" },
-      { name: "x", state: "degraded", via: "syndication (best-effort)" },
+      { name: "x", state: "operational", via: "syndication + guest graphql" },
+      { name: "facebook", state: "operational", via: "web player json" },
+      { name: "threads", state: "operational", via: "share page state" },
+      { name: "snapchat", state: "operational", via: "spotlight + story state" },
+      { name: "rumble", state: "operational", via: "embed json api" },
+      { name: "tumblr", state: "operational", via: "mobile api" },
       { name: "itunes", state: "operational", via: "search api" },
       { name: "ytdlp", state: ytdlp.binary() ? "operational" : "unavailable", via: "external binary" },
     ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "umedia",
-  "version": "0.2.2",
+  "version": "0.4.0",
   "description": "Standalone media engine — search, resolve and download media from YouTube, TikTok, Instagram, Reddit, X, iTunes (and 1800+ sites via the yt-dlp tier) entirely on your machine. No hosted API, no keys, no server bills. Honest quality labels, complete galleries, typed errors.",
   "type": "module",
   "main": "./index.js",