getraw 0.2.0 → 0.3.0

package/.github/workflows/release.yml

@@ -41,3 +41,4 @@ jobs:
             --generate-notes
         env:
           GH_TOKEN: ${{ github.token }}
+

package/bun.lock

@@ -5,8 +5,11 @@
     "": {
       "name": "dlpx",
       "dependencies": {
+        "googlevideo": "^4.0.4",
         "hls-parser": "^0.13.6",
+        "meriyah": "^6.0.7",
         "mpd-parser": "^1.3.0",
+        "youtubei.js": "^17.0.1",
       },
       "devDependencies": {
         "@types/bun": "latest",
@@ -19,6 +22,8 @@
   "packages": {
     "@babel/runtime": ["@babel/runtime@7.29.7", "", {}, "sha512-Nq8OhGWiZIZGV6hLHoyAKLLcJihP/xFeBMGJoUrxTX2psI8dCifzLhZISFb+VWS3wFMRDmCGw5R+dOySCqPLhw=="],
 
+    "@bufbuild/protobuf": ["@bufbuild/protobuf@2.12.0", "", {}, "sha512-B/XlCaFIP8LOwzo+bz5uFzATYokcwCKQcghqnlfwSmM5eX/qTkvDBnDPs+gXtX/RyjxJ4DRikECcPJbyALA8FA=="],
+
     "@types/bun": ["@types/bun@1.3.14", "", { "dependencies": { "bun-types": "1.3.14" } }, "sha512-h1hFqFVcvAvD9j9K7ZW7vd82aSA+rTdznZa+5bwvCwqSB1jmmfLcbIWhOLx1/+boy/xmjgCs/OMUL8hRJSmnPw=="],
 
     "@types/node": ["@types/node@25.9.3", "", { "dependencies": { "undici-types": ">=7.24.0 <7.24.7" } }, "sha512-603BddQMv3pUcr4U2dhujk83N2tTDVr/34wII2B6bJy6g+8WD6yUb11jszNs0gdi4PesVWl7ABt8nYMVpnLUcg=="],
@@ -33,8 +38,12 @@
 
     "global": ["global@4.4.0", "", { "dependencies": { "min-document": "^2.19.0", "process": "^0.11.10" } }, "sha512-wv/LAoHdRE3BeTGz53FAamhGlPLhlssK45usmGFThIi4XqnBmjKQ16u+RNbP7WvigRZDxUsM0J3gcQ5yicaL0w=="],
 
+    "googlevideo": ["googlevideo@4.0.4", "", { "dependencies": { "@bufbuild/protobuf": "^2.0.0" } }, "sha512-S/rfuoPBI+qXCEUPJeVhXsHoISMgVhOz8hHSpGWa0OztfHhh+g9EKaEcqAb/+ttO7meoNQNqIy9dfIpz7HPc4g=="],
+
     "hls-parser": ["hls-parser@0.13.6", "", {}, "sha512-I40sl22E2muqeSTpG8kMN2dAegAhubkXPXtnsUXFwdKwZK47d1Q+XwuX32VMZ++AZU5oeQIZqAnGNHxSG1sWaw=="],
 
+    "meriyah": ["meriyah@6.1.4", "", {}, "sha512-Sz8FzjzI0kN13GK/6MVEsVzMZEPvOhnmmI1lU5+/1cGOiK3QUahntrNNtdVeihrO7t9JpoH75iMNXg6R6uWflQ=="],
+
     "min-document": ["min-document@2.19.2", "", { "dependencies": { "dom-walk": "^0.1.0" } }, "sha512-8S5I8db/uZN8r9HSLFVWPdJCvYOejMcEC82VIzNUc6Zkklf/d1gg2psfE79/vyhWOj4+J8MtwmoOz3TmvaGu5A=="],
 
     "mpd-parser": ["mpd-parser@1.3.1", "", { "dependencies": { "@babel/runtime": "^7.12.5", "@videojs/vhs-utils": "^4.0.0", "@xmldom/xmldom": "^0.8.3", "global": "^4.4.0" }, "bin": { "mpd-to-m3u8-json": "bin/parse.js" } }, "sha512-1FuyEWI5k2HcmhS1HkKnUAQV7yFPfXPht2DnRRGtoiiAAW+ESTbtEXIDpRkwdU+XyrQuwrIym7UkoPKsZ0SyFw=="],
@@ -46,5 +55,7 @@
     "undici-types": ["undici-types@7.24.6", "", {}, "sha512-WRNW+sJgj5OBN4/0JpHFqtqzhpbnV0GuB+OozA9gCL7a993SmU+1JBZCzLNxYsbMfIeDL+lTsphD5jN5N+n0zg=="],
 
     "url-toolkit": ["url-toolkit@2.2.5", "", {}, "sha512-mtN6xk+Nac+oyJ/PrI7tzfmomRVNFIWKUbG8jdYFt52hxbiReFAXIjYskvu64/dvuW71IcB7lV8l0HvZMac6Jg=="],
+
+    "youtubei.js": ["youtubei.js@17.0.1", "", { "dependencies": { "@bufbuild/protobuf": "^2.0.0", "meriyah": "^6.1.4" } }, "sha512-1lO4b8UqMDzE0oh2qEGzbBOd4UYRdxn/4PdpRM7BGTHxM6ddsEsKZTu90jp8V9FHVgC2h1UirQyqoqLiKwl+Zg=="],
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "getraw",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Fast media downloader CLI built natively in Bun/TypeScript",
   "type": "module",
   "bin": {
@@ -13,8 +13,11 @@
     "dashboard": "bun run tools/dashboard.ts"
   },
   "dependencies": {
+    "googlevideo": "^4.0.4",
     "hls-parser": "^0.13.6",
-    "mpd-parser": "^1.3.0"
+    "meriyah": "^6.0.7",
+    "mpd-parser": "^1.3.0",
+    "youtubei.js": "^17.0.1"
   },
   "devDependencies": {
     "@types/bun": "latest"

package/src/cli/index.ts

@@ -3,7 +3,8 @@ import { parseArgs, printHelp } from "./options";
 import { Orchestrator } from "../core/orchestrator";
 import { logger } from "../core/logger";
 
-const VERSION = "0.0.0";
+import pkg from "../../package.json";
+const VERSION = pkg.version;
 
 async function main(): Promise<void> {
   const args = process.argv.slice(2);

package/src/cli/options.ts

@@ -20,7 +20,7 @@ export const FLAG_DEFS: FlagDef[] = [
   { long: "--list-formats", short: "-F", description: "List available formats", type: "boolean", key: "listFormats" },
   { long: "--dump-json", short: "-j", description: "Dump info JSON to stdout", type: "boolean", key: "dumpJson" },
   { long: "--quiet", short: "-q", description: "Suppress output", type: "boolean", key: "quiet" },
-  { long: "--verbose", short: "-v", description: "Verbose output", type: "boolean", key: "verbose" },
+  { long: "--verbose", description: "Verbose output", type: "boolean", key: "verbose" },
   { long: "--no-progress", description: "Disable progress bar", type: "boolean", key: "noProgress" },
   { long: "--retries", short: "-R", description: "Number of retries", type: "number", key: "retries" },
   { long: "--rate-limit", short: "-r", description: "Rate limit in bytes/sec", type: "number", key: "rateLimit" },
@@ -32,7 +32,7 @@ export const FLAG_DEFS: FlagDef[] = [
   { long: "--embed-subs", description: "Embed subtitles in output", type: "boolean", key: "embedSubs" },
   { long: "--merge-output-format", description: "Output container for merging", type: "string", key: "mergeOutputFormat" },
   { long: "--ffmpeg-location", description: "Path to ffmpeg binary", type: "string", key: "ffmpegLocation" },
-  { long: "--version", short: "-V", description: "Print version", type: "boolean", key: "version" },
+  { long: "--version", short: "-v", description: "Print version", type: "boolean", key: "version" },
   { long: "--help", short: "-h", description: "Show help", type: "boolean", key: "help" },
 ];
 

package/src/core/orchestrator.ts

@@ -102,7 +102,7 @@ export class Orchestrator {
           ? `${filepath}.f${format.format_id}.${format.ext}`
           : filepath;
 
-      await downloader.download(targetPath, format.url, {
+      await downloader.download(format.url, targetPath, {
         headers: { ...info.http_headers, ...format.http_headers },
         rateLimit: options.rateLimit,
         retries: options.retries,

package/src/extractors/base.ts

@@ -1,9 +1,78 @@
 import { BaseExtractor } from "../core/types";
 import { GenericExtractor } from "./generic";
+import { YouTubeExtractor } from "./youtube/index";
+import { TwitterExtractor } from "./twitter/index";
+import { TwitterSpacesExtractor } from "./twitter/spaces";
+import { TikTokExtractor } from "./tiktok/index";
+import { TikTokUserExtractor } from "./tiktok/user";
+import { InstagramExtractor } from "./instagram/index";
+import { InstagramReelsExtractor } from "./instagram/reels";
+import { RedditExtractor } from "./reddit/index";
+import { RedditGalleryExtractor } from "./reddit/gallery";
+import { TwitchVODExtractor } from "./twitch/index";
+import { TwitchClipExtractor } from "./twitch/clips";
+import { TwitchLiveExtractor } from "./twitch/live";
+import { VimeoExtractor } from "./vimeo/index";
+import { SoundCloudExtractor } from "./soundcloud/index";
+import { SoundCloudPlaylistExtractor } from "./soundcloud/playlist";
+import { BilibiliExtractor } from "./bilibili/index";
+import { BilibiliBangumiExtractor } from "./bilibili/bangumi";
+import { KickExtractor } from "./kick/index";
+import { KickClipsExtractor } from "./kick/clips";
+import { KickLiveExtractor } from "./kick/live";
+import { NiconicoExtractor } from "./niconico/index";
+import { DailymotionExtractor } from "./dailymotion";
+import { RumbleExtractor } from "./rumble";
+import { BandcampExtractor } from "./bandcamp";
+import { SpotifyExtractor } from "./spotify";
+import { PeerTubeExtractor } from "./peertube";
+import { OdyseeExtractor } from "./odysee";
+import { StreamableExtractor } from "./streamable";
+import { ImgurExtractor } from "./imgur";
+import { CoubExtractor } from "./coub";
+import { TEDExtractor } from "./ted";
+import { ArchiveOrgExtractor } from "./archive-org";
+import { DropboxExtractor } from "./dropbox";
+import { GoogleDriveExtractor } from "./google-drive";
 
 export { BaseExtractor };
 
-const extractors: BaseExtractor[] = [];
+const extractors: BaseExtractor[] = [
+  new YouTubeExtractor(),
+  new TwitterExtractor(),
+  new TwitterSpacesExtractor(),
+  new TikTokExtractor(),
+  new TikTokUserExtractor(),
+  new InstagramExtractor(),
+  new InstagramReelsExtractor(),
+  new RedditExtractor(),
+  new RedditGalleryExtractor(),
+  new TwitchVODExtractor(),
+  new TwitchClipExtractor(),
+  new TwitchLiveExtractor(),
+  new VimeoExtractor(),
+  new SoundCloudExtractor(),
+  new SoundCloudPlaylistExtractor(),
+  new BilibiliExtractor(),
+  new BilibiliBangumiExtractor(),
+  new KickExtractor(),
+  new KickClipsExtractor(),
+  new KickLiveExtractor(),
+  new NiconicoExtractor(),
+  new DailymotionExtractor(),
+  new RumbleExtractor(),
+  new BandcampExtractor(),
+  new SpotifyExtractor(),
+  new PeerTubeExtractor(),
+  new OdyseeExtractor(),
+  new StreamableExtractor(),
+  new ImgurExtractor(),
+  new CoubExtractor(),
+  new TEDExtractor(),
+  new ArchiveOrgExtractor(),
+  new DropboxExtractor(),
+  new GoogleDriveExtractor(),
+];
 const genericExtractor = new GenericExtractor();
 
 export function registerExtractor(extractor: BaseExtractor): void {

package/src/extractors/youtube/index.ts

@@ -1,17 +1,51 @@
 import { BaseExtractor, ExtractorError } from "../../core/types";
 import type { InfoDict, Format, Thumbnail } from "../../core/types";
-import { InnerTubeClient } from "./innertube";
-import type { PlayerResponse, VideoDetails, StreamingData } from "./innertube";
-import { fetchPlayerJs, decipherSignatureUrl, clearCache as clearSigCache } from "./signature";
-import { transformNsig, clearNsigCache } from "./nsig";
 import { parseCaptionTracks } from "./captions";
-import { PlaylistExtractor } from "./playlist";
+import { InnerTubeClient } from "./innertube";
+import type { RawFormat, PlayerResponse, StreamingData } from "./innertube";
+import { decipherStreamUrl, setPageHtmlForPlayerExtraction } from "./player";
 
 const VALID_URL = /^https?:\/\/(?:(?:www|m|music)\.)?(?:youtube\.com\/(?:watch\?.*v=|shorts\/|live\/|embed\/|v\/)|youtu\.be\/)([a-zA-Z0-9_-]{11})/;
 const PLAYLIST_URL = /^https?:\/\/(?:(?:www|m|music)\.)?youtube\.com\/playlist\?.*list=([a-zA-Z0-9_-]+)/;
 const CHANNEL_URL = /^https?:\/\/(?:(?:www|m|music)\.)?youtube\.com\/(?:channel\/|@)([a-zA-Z0-9_-]+)/;
 
-const PLAYER_URL_RE = /"jsUrl"\s*:\s*"(\/s\/player\/[^"]+\/base\.js)"/;
+const USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36";
+
+function generateCpn(): string {
+  const chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_";
+  return Array.from({ length: 16 }, () => chars[Math.floor(Math.random() * 64)]).join("");
+}
+
+interface PageData {
+  playerResponse: PlayerResponse;
+  html: string;
+}
+
+async function fetchPageData(videoId: string): Promise<PageData> {
+  const resp = await fetch(`https://www.youtube.com/watch?v=${videoId}`, {
+    headers: {
+      "User-Agent": USER_AGENT,
+      "Accept-Language": "en-US,en;q=0.9",
+    },
+  });
+
+  if (!resp.ok) {
+    throw new ExtractorError(`Failed to fetch YouTube page: ${resp.status}`);
+  }
+
+  const html = await resp.text();
+  setPageHtmlForPlayerExtraction(html);
+
+  const prMatch = html.match(/var\s+ytInitialPlayerResponse\s*=\s*(\{.+?\});/s);
+  if (!prMatch) {
+    throw new ExtractorError("Could not extract player response from page");
+  }
+
+  return {
+    playerResponse: JSON.parse(prMatch[1]) as PlayerResponse,
+    html,
+  };
+}
 
 export class YouTubeExtractor extends BaseExtractor {
   readonly _VALID_URL = new RegExp(
@@ -19,234 +53,179 @@ export class YouTubeExtractor extends BaseExtractor {
   );
   readonly _NAME = "youtube";
 
-  private playlistExtractor = new PlaylistExtractor();
-
   protected async _real_extract(url: string): Promise<InfoDict> {
-    const playlistMatch = url.match(PLAYLIST_URL);
-    if (playlistMatch) {
-      return this.playlistExtractor.extractPlaylist(playlistMatch[1]);
-    }
-
-    const channelMatch = url.match(CHANNEL_URL);
-    if (channelMatch && !url.match(VALID_URL)) {
-      return this.playlistExtractor.extractChannelVideos(channelMatch[1]);
-    }
-
     const videoMatch = url.match(VALID_URL);
     if (!videoMatch) {
-      throw new ExtractorError(`Could not extract video ID from URL: ${url}`);
+      throw new ExtractorError(`Unsupported YouTube URL: ${url}`);
     }
 
     return this.extractVideo(videoMatch[1]);
   }
 
   private async extractVideo(videoId: string): Promise<InfoDict> {
-    const webClient = InnerTubeClient.withClient("WEB");
-    let playerResponse = await webClient.getPlayerResponse(videoId);
-
-    const status = playerResponse.playabilityStatus?.status;
-    if (status === "LOGIN_REQUIRED" || status === "CONTENT_CHECK_REQUIRED") {
-      playerResponse = await this.tryAgeGateBypass(videoId, playerResponse);
-    }
-
-    if (playerResponse.playabilityStatus?.status === "ERROR") {
-      throw new ExtractorError(
-        playerResponse.playabilityStatus.reason ?? "Video unavailable"
-      );
-    }
+    const pageData = await fetchPageData(videoId);
+    const playerResponse = pageData.playerResponse;
 
-    const videoDetails = playerResponse.videoDetails;
-    if (!videoDetails) {
-      throw new ExtractorError("No video details in player response");
+    const status = playerResponse.playabilityStatus;
+    if (status?.status !== "OK") {
+      throw new ExtractorError(status?.reason ?? "Video unavailable");
     }
 
-    let formats = await this.extractFormats(playerResponse, webClient, videoId);
-
-    if (formats.length === 0) {
-      const androidClient = InnerTubeClient.withClient("ANDROID");
-      const androidResponse = await androidClient.getPlayerResponse(videoId);
-      if (androidResponse.streamingData) {
-        formats = androidClient.parseFormats(androidResponse.streamingData);
-      }
-    }
-
-    const info = this.buildInfoDict(videoId, videoDetails, playerResponse, formats);
-    return info;
-  }
-
-  private async tryAgeGateBypass(
-    videoId: string,
-    originalResponse: PlayerResponse,
-  ): Promise<PlayerResponse> {
-    const tvClient = InnerTubeClient.withClient("TVHTML5_EMBED");
-    const embedUrl = `https://www.youtube.com/embed/${videoId}`;
-    const tvResponse = await tvClient.getPlayerResponse(videoId, embedUrl);
-
-    if (tvResponse.playabilityStatus?.status === "OK" && tvResponse.streamingData) {
-      return {
-        ...tvResponse,
-        videoDetails: originalResponse.videoDetails ?? tvResponse.videoDetails,
-        captions: originalResponse.captions ?? tvResponse.captions,
-        microformat: originalResponse.microformat ?? tvResponse.microformat,
-      };
+    const details = playerResponse.videoDetails;
+    if (!details?.title) {
+      throw new ExtractorError("Could not extract video info");
     }
 
-    return originalResponse;
-  }
+    const formats = await this.extractFormats(playerResponse.streamingData, pageData.html, videoId);
 
-  private async extractFormats(
-    playerResponse: PlayerResponse,
-    client: InnerTubeClient,
-    videoId: string,
-  ): Promise<Format[]> {
-    const streamingData = playerResponse.streamingData;
-    if (!streamingData) return [];
+    const thumbnails: Thumbnail[] = (details.thumbnail?.thumbnails ?? []).map((t) => ({
+      url: t.url,
+      width: t.width,
+      height: t.height,
+    }));
 
-    let formats = client.parseFormats(streamingData);
+    const result: InfoDict = {
+      id: videoId,
+      title: details.title,
+      formats,
+      thumbnails,
+      description: details.shortDescription,
+      channel: details.author,
+      channel_id: details.channelId,
+      duration: parseInt(details.lengthSeconds, 10) || undefined,
+      view_count: parseInt(details.viewCount, 10) || undefined,
+      webpage_url: `https://www.youtube.com/watch?v=${videoId}`,
+      live_status: details.isLive ? "is_live" : "not_live",
+    };
 
-    const needsDecipher = this.formatsNeedDecipher(streamingData);
-    if (needsDecipher) {
-      formats = await this.decipherFormats(formats, streamingData, videoId);
+    const captionTracks = playerResponse.captions?.playerCaptionsTracklistRenderer?.captionTracks;
+    if (captionTracks?.length) {
+      const { subtitles, automatic_captions } = parseCaptionTracks(captionTracks);
+      result.subtitles = subtitles;
+      result.automatic_captions = automatic_captions;
     }
 
-    return formats;
-  }
-
-  private formatsNeedDecipher(streamingData: StreamingData): boolean {
-    const allFormats = [
-      ...(streamingData.formats ?? []),
-      ...(streamingData.adaptiveFormats ?? []),
-    ];
-    return allFormats.some((f) => f.signatureCipher && !f.url);
+    return result;
   }
 
-  private async decipherFormats(
-    formats: Format[],
-    streamingData: StreamingData,
-    videoId: string,
-  ): Promise<Format[]> {
-    const playerJsUrl = await this.getPlayerJsUrl(videoId);
-    if (!playerJsUrl) return formats;
-
-    const playerJs = await fetchPlayerJs(playerJsUrl);
-
-    const allRaw = [
-      ...(streamingData.formats ?? []),
-      ...(streamingData.adaptiveFormats ?? []),
-    ];
+  private async extractFormats(streamingData: StreamingData | undefined, pageHtml: string, videoId?: string): Promise<Format[]> {
+    const cpn = generateCpn();
+    const formats: Format[] = [];
 
-    for (let i = 0; i < formats.length; i++) {
-      const raw = allRaw[i];
-      if (!raw) continue;
+    // First: get formats from page response (muxed formats with signatureCipher)
+    if (streamingData) {
+      const pageFormats: RawFormat[] = [
+        ...(streamingData.formats ?? []),
+        ...(streamingData.adaptiveFormats ?? []),
+      ];
 
-      if (raw.signatureCipher && !raw.url) {
+      for (const raw of pageFormats) {
+        if (!raw.url && !raw.signatureCipher) continue;
         try {
-          formats[i].url = decipherSignatureUrl(raw.signatureCipher, playerJs);
+          const url = await decipherStreamUrl(raw.url, raw.signatureCipher, pageHtml);
+          if (!url) continue;
+          const parsed = new URL(url);
+          parsed.searchParams.set("cpn", cpn);
+          formats.push(this.buildFormat(raw, parsed.toString()));
         } catch {
           continue;
         }
       }
+    }
 
-      if (formats[i].url) {
-        try {
-          formats[i].url = transformNsig(formats[i].url, playerJs);
-        } catch {
-          continue;
+    if (videoId) {
+      try {
+        const iosFormats = await this.fetchIosFormats(videoId, pageHtml, cpn);
+        const existingItags = new Set(formats.map((f) => f.format_id));
+        for (const f of iosFormats) {
+          if (!existingItags.has(f.format_id)) {
+            formats.push(f);
+          }
         }
+      } catch {
+        // IOS client failed, continue with page formats
       }
     }
 
     return formats;
   }
 
-  private async getPlayerJsUrl(videoId: string): Promise<string | null> {
-    const watchUrl = `https://www.youtube.com/watch?v=${videoId}`;
+  private async fetchIosFormats(videoId: string, pageHtml: string, cpn: string): Promise<Format[]> {
+    const iosClient = InnerTubeClient.withClient("IOS");
+    let response: PlayerResponse;
     try {
-      const response = await fetch(watchUrl, {
-        headers: {
-          "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36",
-        },
-      });
-      const html = await response.text();
-      const match = html.match(PLAYER_URL_RE);
-      return match ? `https://www.youtube.com${match[1]}` : null;
+      response = await iosClient.getPlayerResponse(videoId);
     } catch {
-      return null;
+      const androidClient = InnerTubeClient.withClient("ANDROID");
+      response = await androidClient.getPlayerResponse(videoId);
     }
-  }
-
-  private buildInfoDict(
-    videoId: string,
-    details: VideoDetails,
-    response: PlayerResponse,
-    formats: Format[],
-  ): InfoDict {
-    const microformat = response.microformat?.playerMicroformatRenderer;
-
-    const thumbnails: Thumbnail[] = (details.thumbnail?.thumbnails ?? []).map((t) => ({
-      url: t.url,
-      width: t.width,
-      height: t.height,
-    }));
 
-    const liveStatus = this.getLiveStatus(details, response);
+    if (response.playabilityStatus?.status !== "OK") return [];
 
-    const info: InfoDict = {
-      id: videoId,
-      title: details.title,
-      formats,
-      thumbnails,
-      description: details.shortDescription ?? microformat?.description?.simpleText,
-      channel: details.author,
-      channel_id: details.channelId,
-      channel_url: `https://www.youtube.com/channel/${details.channelId}`,
-      uploader: details.author,
-      uploader_id: details.channelId,
-      uploader_url: microformat?.ownerProfileUrl,
-      duration: parseInt(details.lengthSeconds, 10) || undefined,
-      view_count: parseInt(details.viewCount, 10) || undefined,
-      upload_date: microformat?.uploadDate?.replace(/-/g, ""),
-      live_status: liveStatus,
-      webpage_url: `https://www.youtube.com/watch?v=${videoId}`,
-      age_limit: 0,
-      categories: microformat?.category ? [microformat.category] : undefined,
-    };
+    const allRaw: RawFormat[] = [
+      ...(response.streamingData?.formats ?? []),
+      ...(response.streamingData?.adaptiveFormats ?? []),
+    ];
 
-    if (microformat?.liveBroadcastDetails?.startTimestamp) {
-      info.release_timestamp = Math.floor(
-        new Date(microformat.liveBroadcastDetails.startTimestamp).getTime() / 1000
-      );
-    }
+    const formats: Format[] = [];
+    const IOS_UA = "com.google.ios.youtube/19.45.4 (iPhone16,2; U; CPU iOS 17_5_1 like Mac OS X;)";
+
+    for (const raw of allRaw) {
+      if (!raw.url) continue;
+      let finalUrl: string;
+      try {
+        const deciphered = await decipherStreamUrl(raw.url, undefined, pageHtml);
+        finalUrl = deciphered ?? raw.url;
+      } catch {
+        finalUrl = raw.url;
+      }
 
-    const captionTracks = response.captions?.playerCaptionsTracklistRenderer?.captionTracks;
-    if (captionTracks?.length) {
-      const { subtitles, automatic_captions } = parseCaptionTracks(captionTracks);
-      info.subtitles = subtitles;
-      info.automatic_captions = automatic_captions;
+      const parsed = new URL(finalUrl);
+      parsed.searchParams.set("cpn", cpn);
+      const format = this.buildFormat(raw, parsed.toString());
+      format.http_headers = {
+        "User-Agent": IOS_UA,
+        "Origin": "https://www.youtube.com",
+        "Referer": "https://www.youtube.com/",
+      };
+      formats.push(format);
     }
 
-    return info;
+    return formats;
   }
 
-  private getLiveStatus(
-    details: VideoDetails,
-    response: PlayerResponse,
-  ): InfoDict["live_status"] {
-    if (details.isLive) return "is_live";
-    if (details.isUpcoming) return "is_upcoming";
-    if (details.isLiveContent) return "was_live";
-    if (response.playabilityStatus?.liveStreamability) return "is_live";
-    return "not_live";
-  }
+  private buildFormat(raw: RawFormat, url: string): Format {
+    const mime = raw.mimeType;
+    const mimeMatch = mime.match(/^(video|audio)\/(\w+);\s*codecs="([^"]+)"/);
+    const ext = mimeMatch?.[2] ?? "mp4";
+    const codecs = mimeMatch?.[3] ?? "";
+    const isVideo = mime.startsWith("video");
+    const isAudio = mime.startsWith("audio");
+
+    const format: Format = {
+      format_id: String(raw.itag),
+      url,
+      ext: isAudio && ext === "mp4" ? "m4a" : ext,
+      vcodec: isVideo ? codecs.split(",")[0]?.trim() : "none",
+      acodec: isAudio ? codecs : (isVideo && codecs.includes(",") ? codecs.split(",")[1]?.trim() : undefined),
+      width: raw.width,
+      height: raw.height,
+      fps: raw.fps,
+      tbr: raw.bitrate ? Math.round(raw.bitrate / 1000) : undefined,
+      filesize: raw.contentLength ? parseInt(raw.contentLength, 10) : undefined,
+      format_note: raw.qualityLabel ?? raw.quality ?? undefined,
+      audio_channels: raw.audioChannels,
+      http_headers: {
+        "Origin": "https://www.youtube.com",
+        "Referer": "https://www.youtube.com/",
+        "User-Agent": USER_AGENT,
+      },
+    };
 
-  static clearCaches(): void {
-    clearSigCache();
-    clearNsigCache();
+    if (raw.width && raw.height) {
+      format.resolution = `${raw.width}x${raw.height}`;
+    }
+
+    return format;
   }
 }
-
-export { InnerTubeClient } from "./innertube";
-export { PlaylistExtractor } from "./playlist";
-export { parseCaptionTracks, convertToSrt, convertToVtt } from "./captions";
-export { decipherSignatureUrl, fetchPlayerJs } from "./signature";
-export { transformNsig } from "./nsig";