debrid-ts 0.1.0 → 0.2.0

package/README.md

@@ -1,7 +1,8 @@
 # debrid-ts
 
-Typed TypeScript clients for debrid services — **Real-Debrid**, **AllDebrid**
-and **Premiumize** — with every documented endpoint as a method, plus one
+Typed TypeScript clients for debrid services — **Real-Debrid**, **AllDebrid**,
+**Premiumize**, **TorBox**, **Debrid-Link**, **Offcloud**, **put.io** and
+**EasyDebrid** — plus one
 provider-agnostic interface so your code can swap providers by changing a
 constructor.
 
@@ -142,6 +143,27 @@ Covers every endpoint in the [API docs](https://www.premiumize.me/api):
 `getAuthorizeUrl()` + `exchangeCode()`, device flow via `getDeviceCode()` +
 `waitForDeviceToken()`, and the legacy password grant).
 
+### Other providers
+
+These clients cover the torrent workflow behind `DebridProvider`, not every endpoint of each API.
+
+```ts
+new TorBox(apiKey) // https://torbox.app/settings
+new DebridLink(token) // https://debrid-link.com/webapp/apikey, or an OAuth access token
+new Offcloud(apiKey) // from your Offcloud account
+new Putio(token) // https://app.put.io/oauth
+new EasyDebrid(apiKey) // from your EasyDebrid dashboard
+```
+
+| | TorBox | Debrid-Link | Offcloud | put.io | EasyDebrid |
+| --- | --- | --- | --- | --- | --- |
+| `isCached()` | Real lookup. | **Probe:** adds the hash (only accepted when cached), then removes it. A torrent you already have is never touched. | Real lookup. | Always `false`: there is no shared cache. | Real lookup. |
+| `addMagnet()` | Starts automatically. Throws `ACTIVE_LIMIT` if TorBox queues it instead. | Starts automatically. | Starts automatically. Throws `not_available` on a plan limit. | Starts automatically. | Adds nothing. Throws `not_cached` unless cached; the id is the info hash. |
+| `.torrent` upload | `addTorrentFile()` | `addTorrentFile()` | Not available | `addTorrentFile()` | Not available |
+| `getDownloadLinks()` | One request per file. | Reads the finished files. | Reads the finished files. | One request per file. | Generates links for the hash. |
+| `listTorrents()` paging | Server-side. | Server-side. | Client-side slice. | Client-side slice. | Always empty: nothing is stored per account. |
+| Delete | `deleteTorrent()` | `deleteTorrent()` | `deleteTorrent()` | `deleteTorrent()`, which also deletes the resulting files. | Nothing to delete. |
+
 ## Options
 
 Every client (and every static OAuth helper) accepts:

package/dist/index.d.mts

@@ -1370,4 +1370,336 @@ declare class Premiumize extends BaseFetcher implements DebridProvider {
   } & ClientOptions): Promise<PmTokenResponse>;
 }
 //#endregion
-export { type AdDelayedLink, type AdEnvelope, type AdHostDomainsData, type AdHostInfo, type AdHostPrioritiesData, type AdHostsData, type AdItemError, type AdLinkInfo, type AdLinkInfosData, type AdMagnetFileEntry, type AdMagnetFileUploadData, type AdMagnetFilesData, type AdMagnetFilter, type AdMagnetNode, type AdMagnetRestartData, type AdMagnetStatusData, type AdMagnetStatusItem, type AdMagnetStatusParams, type AdMagnetUploadData, type AdPinCheck, type AdPinGet, type AdPing, type AdRedirectorData, type AdStreamQuality, type AdStreamingLink, type AdUnlockedLink, type AdUploadedFile, type AdUploadedMagnet, type AdUserData, type AdUserHost, type AdUserHostsData, type AdUserInfo, type AdUserLink, type AdUserLinksData, type AdVerif, type AdVerifResend, type AdVoucherBalanceData, type AdVoucherDuration, type AdVoucherGenerateData, type AdVoucherGetData, AllDebrid, type AllDebridOptions, BaseFetcher, type BaseFetcherOptions, type BodyLike, type ClientOptions, DebridError, type DebridProvider, type DownloadLink, type FileInput, type FormValue, type PmAccountInfo, type PmBreadcrumb, type PmCacheCheck, type PmContentEntry, type PmDeviceCode, type PmDirectDl, type PmDirectDlContent, type PmErrorBody, type PmFileEntry, type PmFolderCreate, type PmFolderEntry, type PmFolderList, type PmFolderListParams, type PmItemDetails, type PmItemListAll, type PmListedFile, type PmOAuthError, type PmResponse, type PmSearchResults, type PmServicesList, type PmSuccess, type PmTokenResponse, type PmTransfer, type PmTransferContainer, type PmTransferCreateResult, type PmTransferCreated, type PmTransferList, type PmTransferStatus, type PmUploadInfo, type PmZipGenerate, Premiumize, type PremiumizeOptions, type QueryValue, REAL_DEBRID_OPENSOURCE_CLIENT_ID, type RdActiveCount, type RdAlternativeLink, type RdAvailableHost, type RdDeviceAuthorization, type RdDeviceCode, type RdDeviceCredentials, type RdDownloadItem, type RdHost, type RdHostState, type RdHostStatus, type RdHostStatuses, type RdHosts, type RdInstantAvailability, type RdLinkCheck, type RdMagnetAdded, type RdMediaAudioStream, type RdMediaInfo, type RdMediaSubtitleStream, type RdMediaVideoStream, type RdPagination, type RdSettingName, type RdSettings, type RdTokenResponse, type RdTorrent, type RdTorrentFile, type RdTorrentInfo, type RdTorrentStatus, type RdTraffic, type RdTrafficDay, type RdTrafficDetails, type RdTrafficEntry, type RdTranscodeQualities, type RdTranscodeStreams, type RdUnrestrictedLink, type RdUser, RealDebrid, type RealDebridOptions, type RequestOptions, type Torrent, type TorrentFile, type TorrentStatus, type UserInfo };
+//#region src/services/torbox/types.d.ts
+/** Standard TorBox response wrapper (`success: false` also arrives with HTTP 200). */
+interface TbEnvelope<T> {
+  success: boolean;
+  error: string | null;
+  detail: string;
+  data: T;
+}
+interface TbUser {
+  id: number;
+  email: string;
+  /** 0 = free */
+  plan: number;
+  is_subscribed: boolean;
+  premium_expires_at: string | null;
+}
+interface TbFile {
+  id: number;
+  name: string;
+  size: number;
+  short_name?: string;
+  mimetype?: string;
+}
+interface TbTorrent {
+  id: number;
+  hash: string;
+  name: string;
+  size: number;
+  created_at: string;
+  download_state: string;
+  /** 0–1 */
+  progress: number;
+  download_speed: number;
+  seeds: number;
+  ratio: number;
+  download_present: boolean;
+  download_finished: boolean;
+  files: TbFile[] | null;
+}
+interface TbCreateResult {
+  /** Absent when TorBox queued the torrent instead of starting it (`queued_id` is set then). */
+  torrent_id?: number | null;
+  queued_id?: number | null;
+  name?: string;
+  hash: string;
+}
+interface TbCacheResult {
+  hash: string;
+  name: string;
+  size: number;
+}
+//#endregion
+//#region src/services/torbox/torbox.d.ts
+type TorBoxOptions = ClientOptions;
+declare class TorBox extends BaseFetcher implements DebridProvider {
+  #private;
+  /** @param apiKey API key from https://torbox.app/settings */
+  constructor(apiKey: string, options?: TorBoxOptions);
+  /** Unwraps the `{ success, error, detail, data }` envelope. */
+  protected request<T>(method: string, path: string, options?: RequestOptions): Promise<T>;
+  readonly name = "torbox";
+  getUser(): Promise<UserInfo>;
+  /** Real lookup via `/torrents/checkcached`, no side effects. */
+  isCached(hashOrMagnet: string): Promise<boolean>;
+  addMagnet(magnet: string): Promise<Torrent>;
+  /** Adds a `.torrent` file and returns its torrent id. */
+  addTorrentFile(file: FileInput, filename?: string): Promise<string>;
+  listTorrents(offset?: number, limit?: number): Promise<Torrent[]>;
+  getTorrent(torrentId: string): Promise<Torrent>;
+  /** Requests one link per file. */
+  getDownloadLinks(torrentId: string): Promise<DownloadLink[]>;
+  /** GET /torrents/checkcached — the cached subset of `hashes`. */
+  checkCached(hashes: string[]): Promise<TbCacheResult[]>;
+  /** GET /torrents/requestdl */
+  requestDownloadLink(torrentId: string, fileId: number): Promise<string>;
+  /** POST /torrents/controltorrent with `operation: "delete"` */
+  deleteTorrent(torrentId: string): Promise<void>;
+  /** This instance as the provider-agnostic {@link DebridProvider}. */
+  toProvider(): DebridProvider;
+}
+//#endregion
+//#region src/services/debrid-link/types.d.ts
+/** `{ success: false, error }` responses are turned into DebridError by the client. */
+interface DlEnvelope<T> {
+  success: boolean;
+  value: T;
+  error?: string;
+}
+interface DlAccount {
+  username: string;
+  email?: string;
+  /** 0 = free, 1 = premium, 2 = lifetime premium */
+  accountType: number;
+  /** Seconds of premium left, 0 for free users */
+  premiumLeft: number;
+  avatarUrl?: string;
+}
+interface DlSeedboxFile {
+  id: string;
+  name: string;
+  size: number;
+  downloadUrl: string;
+  downloadPercent: number;
+}
+interface DlTorrent {
+  id: string;
+  name: string;
+  /** Unix seconds */
+  created: number;
+  hashString: string;
+  uploadRatio: number;
+  peersConnected: number;
+  /** 0 paused, 1 queued, 2 verifying, 4 downloading, 8 seeding, 100 finished */
+  status: number;
+  totalSize: number;
+  downloadPercent: number;
+  downloadSpeed: number;
+  /** `files` holds a single ZIP in lists when true; `?ids=` returns the real files */
+  isZip: boolean;
+  files: DlSeedboxFile[];
+}
+interface DlLink {
+  id: string;
+  name: string;
+  url: string;
+  downloadUrl: string;
+  host: string;
+  size: number;
+  created: number;
+  expired: boolean;
+}
+//#endregion
+//#region src/services/debrid-link/debrid-link.d.ts
+type DebridLinkOptions = ClientOptions;
+declare class DebridLink extends BaseFetcher implements DebridProvider {
+  #private;
+  /** @param token Private API key from https://debrid-link.com/webapp/apikey, or an OAuth access token */
+  constructor(token: string, options?: DebridLinkOptions);
+  /** Unwraps `{ success, value }`. */
+  protected request<T>(method: string, path: string, options?: RequestOptions): Promise<T>;
+  readonly name = "debrid-link";
+  getUser(): Promise<UserInfo>;
+  /**
+   * **Probe:** the API has no cache lookup, but only accepts a bare hash when
+   * it's cached. The probe torrent is removed again; a torrent the account
+   * already had is reported from the list and never touched.
+   */
+  isCached(hashOrMagnet: string): Promise<boolean>;
+  addMagnet(magnet: string): Promise<Torrent>;
+  /** Adds a `.torrent` file (multipart). */
+  addTorrentFile(file: FileInput, filename?: string): Promise<Torrent>;
+  listTorrents(offset?: number, limit?: number): Promise<Torrent[]>;
+  /** GET /seedbox/list */
+  listSeedbox(page?: number): Promise<DlTorrent[]>;
+  getTorrent(torrentId: string): Promise<Torrent>;
+  /** Direct links of the files that finished downloading. */
+  getDownloadLinks(torrentId: string): Promise<DownloadLink[]>;
+  /** POST /downloader/add — a folder link yields several files. */
+  unrestrictLink(url: string): Promise<DlLink[]>;
+  /** DELETE /seedbox/:id/remove */
+  deleteTorrent(torrentId: string): Promise<void>;
+  /** This instance as the provider-agnostic {@link DebridProvider}. */
+  toProvider(): DebridProvider;
+}
+//#endregion
+//#region src/services/offcloud/offcloud.d.ts
+type OffcloudOptions = ClientOptions;
+declare class Offcloud extends BaseFetcher implements DebridProvider {
+  #private;
+  /** @param apiKey API key from your Offcloud account */
+  constructor(apiKey: string, options?: OffcloudOptions);
+  /** Errors can arrive as `{ error }` with HTTP 200. */
+  protected request<T>(method: string, path: string, options?: RequestOptions): Promise<T>;
+  readonly name = "offcloud";
+  getUser(): Promise<UserInfo>;
+  /** Real lookup via `/cache/info`, no side effects. */
+  isCached(hashOrMagnet: string): Promise<boolean>;
+  addMagnet(magnet: string): Promise<Torrent>;
+  /** `/cloud/history` has no server-side pagination, so this slices locally. */
+  listTorrents(offset?: number, limit?: number): Promise<Torrent[]>;
+  /** POST /cloud/status */
+  getTorrent(torrentId: string): Promise<Torrent>;
+  /** Direct links from GET /cloud/explore/:id */
+  getDownloadLinks(torrentId: string): Promise<DownloadLink[]>;
+  /** POST /cloud/remove */
+  deleteTorrent(torrentId: string): Promise<void>;
+  /** This instance as the provider-agnostic {@link DebridProvider}. */
+  toProvider(): DebridProvider;
+}
+//#endregion
+//#region src/services/offcloud/types.d.ts
+interface OcAccount {
+  user_id: string;
+  is_premium: boolean;
+  /** e.g. `2026-12-31` */
+  expiration_date?: string;
+  can_download?: boolean;
+}
+type OcStatus = 'created' | 'queued' | 'downloading' | 'downloaded' | 'error' | 'canceled';
+interface OcCloudItem {
+  requestId: string;
+  fileName?: string;
+  status: OcStatus;
+  originalLink?: string;
+  createdOn?: string;
+  /** Set when the account can't start this download, e.g. `cloud` */
+  not_available?: string;
+}
+interface OcCacheItem {
+  cached: boolean;
+}
+interface OcFile {
+  id?: string;
+  name?: string;
+  size: number;
+  /** Path inside the download */
+  path: string;
+  url: string;
+}
+//#endregion
+//#region src/services/putio/types.d.ts
+interface PutioAccount {
+  user_id: number;
+  username: string;
+  mail?: string;
+  avatar_url?: string;
+  account_active: boolean;
+  plan_expiration_date?: string;
+}
+interface PutioTransfer {
+  id: number;
+  name: string;
+  /** e.g. `IN_QUEUE`, `DOWNLOADING`, `SEEDING`, `COMPLETED`, `ERROR` */
+  status: string;
+  percent_done: number;
+  size: number;
+  down_speed: number;
+  peers_connected?: number;
+  /** Peer count as named in the API spec */
+  peers?: number;
+  created_at?: string;
+  error_message?: string | null;
+  /** The resulting file or folder, set once finished */
+  file_id?: number | null;
+  magneturi?: string | null;
+  /** What was added: a magnet or HTTP(S) URL */
+  source?: string | null;
+}
+interface PutioFile {
+  id: number;
+  name: string;
+  size: number;
+  content_type: string;
+}
+/** A file inside a transfer's result, with its path from the result's root. */
+interface PutioFileEntry {
+  id: number;
+  path: string;
+  size: number;
+}
+//#endregion
+//#region src/services/putio/putio.d.ts
+type PutioOptions = ClientOptions;
+declare class Putio extends BaseFetcher implements DebridProvider {
+  #private;
+  /** @param token OAuth token from https://app.put.io/oauth */
+  constructor(token: string, options?: PutioOptions);
+  readonly name = "putio";
+  getUser(): Promise<UserInfo>;
+  /** put.io has no shared cache to look up, so this is always false. */
+  isCached(_hashOrMagnet: string): Promise<boolean>;
+  addMagnet(magnet: string): Promise<Torrent>;
+  /** Uploads a `.torrent` file, which starts a transfer, and returns its id. */
+  addTorrentFile(file: FileInput, filename?: string): Promise<string>;
+  /** `/transfers/list` has no server-side pagination, so this slices locally. */
+  listTorrents(offset?: number, limit?: number): Promise<Torrent[]>;
+  getTorrent(torrentId: string): Promise<Torrent>;
+  /** GET /transfers/:id */
+  getTransfer(transferId: string): Promise<PutioTransfer>;
+  /** Requests one link per file. */
+  getDownloadLinks(torrentId: string): Promise<DownloadLink[]>;
+  /** Every file a finished transfer produced, walking its folder tree. */
+  listTransferFiles(transferId: string): Promise<PutioFileEntry[]>;
+  /** GET /files/list, following the cursor. */
+  listFolder(folderId: number): Promise<PutioFile[]>;
+  /** GET /files/:id/url */
+  getFileUrl(fileId: number): Promise<string>;
+  /**
+   * Removes the transfer and, once finished, the files it produced, so this
+   * matches what "delete" means on the other providers.
+   */
+  deleteTorrent(torrentId: string): Promise<void>;
+  /** This instance as the provider-agnostic {@link DebridProvider}. */
+  toProvider(): DebridProvider;
+}
+//#endregion
+//#region src/services/easydebrid/easydebrid.d.ts
+type EasyDebridOptions = ClientOptions;
+declare class EasyDebrid extends BaseFetcher implements DebridProvider {
+  /** @param apiKey API key from your EasyDebrid dashboard */
+  constructor(apiKey: string, options?: EasyDebridOptions);
+  /** Errors can arrive as `{ error }` with HTTP 200. */
+  protected request<T>(method: string, path: string, options?: RequestOptions): Promise<T>;
+  readonly name = "easydebrid";
+  getUser(): Promise<UserInfo>;
+  /** Real lookup via `/link/lookup`, no side effects. */
+  isCached(hashOrMagnet: string): Promise<boolean>;
+  /** Nothing is added remotely: this checks the cache and returns the hash as the id. */
+  addMagnet(magnet: string): Promise<Torrent>;
+  /** EasyDebrid keeps no list of torrents per account. */
+  listTorrents(_offset?: number, _limit?: number): Promise<Torrent[]>;
+  getTorrent(torrentId: string): Promise<Torrent>;
+  /** Direct links from POST /link/generate */
+  getDownloadLinks(torrentId: string): Promise<DownloadLink[]>;
+  /** This instance as the provider-agnostic {@link DebridProvider}. */
+  toProvider(): DebridProvider;
+}
+//#endregion
+//#region src/services/easydebrid/types.d.ts
+interface EdUser {
+  id: string;
+  /** e.g. `2026-10-01` */
+  paid_until?: string | null;
+}
+interface EdFile {
+  filename: string;
+  /** Folders from the torrent root down to the file */
+  directory?: string[];
+  size: number;
+  url: string;
+}
+//#endregion
+export { type AdDelayedLink, type AdEnvelope, type AdHostDomainsData, type AdHostInfo, type AdHostPrioritiesData, type AdHostsData, type AdItemError, type AdLinkInfo, type AdLinkInfosData, type AdMagnetFileEntry, type AdMagnetFileUploadData, type AdMagnetFilesData, type AdMagnetFilter, type AdMagnetNode, type AdMagnetRestartData, type AdMagnetStatusData, type AdMagnetStatusItem, type AdMagnetStatusParams, type AdMagnetUploadData, type AdPinCheck, type AdPinGet, type AdPing, type AdRedirectorData, type AdStreamQuality, type AdStreamingLink, type AdUnlockedLink, type AdUploadedFile, type AdUploadedMagnet, type AdUserData, type AdUserHost, type AdUserHostsData, type AdUserInfo, type AdUserLink, type AdUserLinksData, type AdVerif, type AdVerifResend, type AdVoucherBalanceData, type AdVoucherDuration, type AdVoucherGenerateData, type AdVoucherGetData, AllDebrid, type AllDebridOptions, BaseFetcher, type BaseFetcherOptions, type BodyLike, type ClientOptions, DebridError, DebridLink, type DebridLinkOptions, type DebridProvider, type DlAccount, type DlEnvelope, type DlLink, type DlSeedboxFile, type DlTorrent, type DownloadLink, EasyDebrid, type EasyDebridOptions, type EdFile, type EdUser, type FileInput, type FormValue, type OcAccount, type OcCacheItem, type OcCloudItem, type OcFile, type OcStatus, Offcloud, type OffcloudOptions, type PmAccountInfo, type PmBreadcrumb, type PmCacheCheck, type PmContentEntry, type PmDeviceCode, type PmDirectDl, type PmDirectDlContent, type PmErrorBody, type PmFileEntry, type PmFolderCreate, type PmFolderEntry, type PmFolderList, type PmFolderListParams, type PmItemDetails, type PmItemListAll, type PmListedFile, type PmOAuthError, type PmResponse, type PmSearchResults, type PmServicesList, type PmSuccess, type PmTokenResponse, type PmTransfer, type PmTransferContainer, type PmTransferCreateResult, type PmTransferCreated, type PmTransferList, type PmTransferStatus, type PmUploadInfo, type PmZipGenerate, Premiumize, type PremiumizeOptions, Putio, type PutioAccount, type PutioFile, type PutioFileEntry, type PutioOptions, type PutioTransfer, type QueryValue, REAL_DEBRID_OPENSOURCE_CLIENT_ID, type RdActiveCount, type RdAlternativeLink, type RdAvailableHost, type RdDeviceAuthorization, type RdDeviceCode, type RdDeviceCredentials, type RdDownloadItem, type RdHost, type RdHostState, type RdHostStatus, type RdHostStatuses, type RdHosts, type RdInstantAvailability, type RdLinkCheck, type RdMagnetAdded, type RdMediaAudioStream, type RdMediaInfo, type RdMediaSubtitleStream, type RdMediaVideoStream, type RdPagination, type RdSettingName, type RdSettings, type RdTokenResponse, type RdTorrent, type RdTorrentFile, type RdTorrentInfo, type RdTorrentStatus, type RdTraffic, type RdTrafficDay, type RdTrafficDetails, type RdTrafficEntry, type RdTranscodeQualities, type RdTranscodeStreams, type RdUnrestrictedLink, type RdUser, RealDebrid, type RealDebridOptions, type RequestOptions, type TbCacheResult, type TbCreateResult, type TbEnvelope, type TbFile, type TbTorrent, type TbUser, TorBox, type TorBoxOptions, type Torrent, type TorrentFile, type TorrentStatus, type UserInfo };

package/dist/index.mjs

@@ -123,16 +123,21 @@ var BaseFetcher = class {
 /**
 * Pulls a message/code out of the error bodies the supported providers send:
 * `{ error: "bad_token", error_code: 8 }` (Real-Debrid / OAuth),
-* `{ error: { code, message } }` (AllDebrid), `{ message, code }` (Premiumize).
+* `{ error: { code, message } }` (AllDebrid), `{ message, code }` (Premiumize),
+* `{ error: "BAD_TOKEN", detail }` (TorBox), `{ error_type, error_message }` (put.io).
 */
 function describeError(details) {
 	if (!details || typeof details !== "object") return {};
 	const body = details;
 	const error = body.error;
 	if (typeof error === "string") return {
-		message: typeof body.error_description === "string" ? body.error_description : error,
+		message: asString(body.error_description) ?? asString(body.detail) ?? error,
 		code: error
 	};
+	if (typeof body.error_type === "string") return {
+		message: asString(body.error_message),
+		code: body.error_type
+	};
 	if (error && typeof error === "object") {
 		const nested = error;
 		return {
@@ -169,6 +174,11 @@ function toBlob(file, type) {
 function toMagnet(hashOrMagnet) {
 	return hashOrMagnet.startsWith("magnet:") ? hashOrMagnet : `magnet:?xt=urn:btih:${hashOrMagnet}`;
 }
+/** Accepts a magnet URI or a bare info hash and returns the lowercase hash, or '' if there is none. */
+function toInfoHash(hashOrMagnet) {
+	if (!hashOrMagnet.startsWith("magnet:")) return hashOrMagnet.toLowerCase();
+	return /[?&]xt=urn:btih:([^&]+)/i.exec(hashOrMagnet)?.[1]?.toLowerCase() ?? "";
+}
 //#endregion
 //#region src/services/real-debrid/real-debrid.ts
 /**
@@ -177,7 +187,7 @@ function toMagnet(hashOrMagnet) {
 * Implements the unified {@link DebridProvider} interface on top of the raw
 * per-endpoint methods (grouped by namespace exactly like the API docs).
 */
-const API_BASE$2 = "https://api.real-debrid.com/rest/1.0";
+const API_BASE$7 = "https://api.real-debrid.com/rest/1.0";
 const OAUTH_BASE$1 = "https://api.real-debrid.com/oauth/v2";
 /** grant_type for the device flow token exchange and for refreshing tokens */
 const DEVICE_GRANT = "http://oauth.net/grant_type/device/1.0";
@@ -190,7 +200,7 @@ var RealDebrid = class RealDebrid extends BaseFetcher {
 	constructor(apiToken, options = {}) {
 		super({
 			...options,
-			baseUrl: API_BASE$2,
+			baseUrl: API_BASE$7,
 			headers: { Authorization: `Bearer ${apiToken}` }
 		});
 	}
@@ -242,7 +252,7 @@ var RealDebrid = class RealDebrid extends BaseFetcher {
 		return (await this.listTorrentsRaw({
 			offset,
 			limit
-		})).map(toTorrent$2);
+		})).map(toTorrent$7);
 	}
 	/** Unrestricts every host link of a downloaded torrent into direct links. */
 	async getDownloadLinks(torrentId) {
@@ -318,16 +328,16 @@ var RealDebrid = class RealDebrid extends BaseFetcher {
 		return this.get(`/streaming/mediaInfos/${encodeURIComponent(linkId)}`);
 	}
 	/** GET /downloads — unrestricted downloads history. */
-	listDownloads(pagination = {}) {
-		return this.get("/downloads", { ...pagination });
+	async listDownloads(pagination = {}) {
+		return await this.get("/downloads", { ...pagination }) ?? [];
 	}
 	/** DELETE /downloads/delete/{id} */
 	deleteDownload(downloadId) {
 		return this.delete(`/downloads/delete/${encodeURIComponent(downloadId)}`);
 	}
 	/** GET /torrents — raw wire list. `filter: 'active'` lists active torrents only. */
-	listTorrentsRaw(params = {}) {
-		return this.get("/torrents", { ...params });
+	async listTorrentsRaw(params = {}) {
+		return await this.get("/torrents", { ...params }) ?? [];
 	}
 	/** GET /torrents/info/{id} — raw wire response. */
 	getTorrentInfo(torrentId) {
@@ -335,7 +345,7 @@ var RealDebrid = class RealDebrid extends BaseFetcher {
 	}
 	/** GET /torrents/info/{id} — mapped to the unified Torrent shape. */
 	async getTorrent(torrentId) {
-		return toTorrent$2(await this.getTorrentInfo(torrentId));
+		return toTorrent$7(await this.getTorrentInfo(torrentId));
 	}
 	/**
 	* GET /torrents/instantAvailability/{hash}/{hash}… — note that Real-Debrid
@@ -534,7 +544,7 @@ var RealDebrid = class RealDebrid extends BaseFetcher {
 		});
 	}
 };
-function toTorrent$2(info) {
+function toTorrent$7(info) {
 	const files = "files" in info ? info.files : void 0;
 	const selected = files?.filter((file) => file.selected === 1) ?? [];
 	const linkFor = (fileId) => selected.length === info.links.length ? info.links[selected.findIndex((file) => file.id === fileId)] : void 0;
@@ -576,7 +586,7 @@ function toDownloadLink$1(link) {
 * Implements the unified {@link DebridProvider} interface on top of the raw
 * per-endpoint methods (grouped by namespace exactly like the API docs).
 */
-const API_BASE$1 = "https://api.alldebrid.com";
+const API_BASE$6 = "https://api.alldebrid.com";
 var AllDebrid = class AllDebrid extends BaseFetcher {
 	/**
 	* @param apiKey Apikey from https://alldebrid.com/apikeys/
@@ -584,7 +594,7 @@ var AllDebrid = class AllDebrid extends BaseFetcher {
 	constructor(apiKey, options = {}) {
 		super({
 			...options,
-			baseUrl: API_BASE$1,
+			baseUrl: API_BASE$6,
 			headers: { Authorization: `Bearer ${apiKey}` }
 		});
 	}
@@ -629,7 +639,7 @@ var AllDebrid = class AllDebrid extends BaseFetcher {
 	/** AD has no server-side pagination for /magnet/status — slice locally. */
 	async listTorrents(offset = 0, limit = 100) {
 		const { magnets } = await this.getMagnetsStatus();
-		return magnets.slice(offset, offset + limit).map(toTorrent$1);
+		return magnets.slice(offset, offset + limit).map(toTorrent$6);
 	}
 	/**
 	* Direct download links for every file of a ready magnet. The file links
@@ -788,7 +798,7 @@ var AllDebrid = class AllDebrid extends BaseFetcher {
 		const { magnets } = await this.getMagnetsStatus({ id: Number(torrentId) });
 		const magnet = magnets.find((item) => String(item.id) === String(torrentId)) ?? magnets[0];
 		if (!magnet) throw new DebridError(`Magnet ${torrentId} not found`, 404, "MAGNET_INVALID_ID");
-		return toTorrent$1(magnet);
+		return toTorrent$6(magnet);
 	}
 	/** POST /v4/magnet/files — file tree (with `/f/` links to unlock) for the given magnet ids. */
 	getMagnetFiles(ids) {
@@ -823,7 +833,7 @@ var AllDebrid = class AllDebrid extends BaseFetcher {
 	static #public(options = {}) {
 		return new BaseFetcher({
 			...options,
-			baseUrl: API_BASE$1
+			baseUrl: API_BASE$6
 		});
 	}
 	/** GET /v4.1/pin/get — start the PIN flow: show `user_url` (or `pin`), then poll. */
@@ -855,7 +865,7 @@ function unwrap(envelope) {
 	return envelope.data;
 }
 /** statusCode → unified TorrentStatus (5–15 are all errors). */
-function toTorrentStatus$1(statusCode) {
+function toTorrentStatus$4(statusCode) {
 	switch (statusCode) {
 		case 0: return "queued";
 		case 1: return "downloading";
@@ -876,7 +886,7 @@ function flattenTorrentFiles(nodes, out = []) {
 	});
 	return out;
 }
-function toTorrent$1(magnet) {
+function toTorrent$6(magnet) {
 	const files = magnet.files ? flattenTorrentFiles(magnet.files) : void 0;
 	return {
 		id: String(magnet.id),
@@ -884,7 +894,7 @@ function toTorrent$1(magnet) {
 		hash: magnet.hash ?? "",
 		bytes: magnet.size,
 		progress: magnet.statusCode === 4 ? 100 : magnet.size > 0 && magnet.downloaded ? Math.min(100, Math.round(magnet.downloaded / magnet.size * 100)) : 0,
-		status: toTorrentStatus$1(magnet.statusCode),
+		status: toTorrentStatus$4(magnet.statusCode),
 		files,
 		links: (files ?? []).map((f) => f.downloadUrl).filter((link) => !!link),
 		addedAt: magnet.uploadDate > 0 ? /* @__PURE__ */ new Date(magnet.uploadDate * 1e3) : void 0,
@@ -903,7 +913,7 @@ function collectFiles(nodes, out = []) {
 }
 //#endregion
 //#region src/services/premiumize/premiumize.ts
-const API_BASE = "https://www.premiumize.me/api";
+const API_BASE$5 = "https://www.premiumize.me/api";
 const OAUTH_BASE = "https://www.premiumize.me";
 var Premiumize = class Premiumize extends BaseFetcher {
 	/** Kept for the two-step upload (its url is outside the API base). */
@@ -914,7 +924,7 @@ var Premiumize = class Premiumize extends BaseFetcher {
 	constructor(apiKey, options = {}) {
 		super({
 			...options,
-			baseUrl: API_BASE,
+			baseUrl: API_BASE$5,
 			headers: { Authorization: `Bearer ${apiKey}` }
 		});
 		this.#fetch = options.fetch ?? globalThis.fetch.bind(globalThis);
@@ -953,7 +963,7 @@ var Premiumize = class Premiumize extends BaseFetcher {
 	/** /transfer/list has no server-side pagination — slice locally. */
 	async listTorrents(offset = 0, limit = 100) {
 		const { transfers } = await this.listTransfers();
-		return transfers.slice(offset, offset + limit).map(toTorrent);
+		return transfers.slice(offset, offset + limit).map(toTorrent$5);
 	}
 	/**
 	* Direct links for a finished transfer: a single-file source resolves to its
@@ -1075,7 +1085,7 @@ var Premiumize = class Premiumize extends BaseFetcher {
 	}
 	/** GET /transfer/list mapped to the unified Torrent shape. */
 	async getTorrent(torrentId) {
-		return toTorrent(await this.getTransfer(torrentId));
+		return toTorrent$5(await this.getTransfer(torrentId));
 	}
 	/** GET /transfer/list + id lookup — the API has no single-transfer endpoint. */
 	async getTransfer(transferId) {
@@ -1194,7 +1204,7 @@ var Premiumize = class Premiumize extends BaseFetcher {
 		return out;
 	}
 };
-function toTorrentStatus(status) {
+function toTorrentStatus$3(status) {
 	switch (status) {
 		case "queued": return "queued";
 		case "running": return "downloading";
@@ -1207,14 +1217,14 @@ function toTorrentStatus(status) {
 * `/transfer/list` carries no hash, size or file data, so those stay empty —
 * call {@link Premiumize.getDownloadLinks} for the real files.
 */
-function toTorrent(transfer) {
+function toTorrent$5(transfer) {
 	return {
 		id: transfer.id,
 		name: transfer.name,
 		hash: "",
 		bytes: 0,
 		progress: Math.round(transfer.progress * 100),
-		status: toTorrentStatus(transfer.status),
+		status: toTorrentStatus$3(transfer.status),
 		links: [],
 		addedAt: transfer.created_at ? /* @__PURE__ */ new Date(transfer.created_at * 1e3) : void 0
 	};
@@ -1231,4 +1241,645 @@ function toDownloadLink(item) {
 	};
 }
 //#endregion
-export { AllDebrid, BaseFetcher, DebridError, Premiumize, REAL_DEBRID_OPENSOURCE_CLIENT_ID, RealDebrid };
+//#region src/services/torbox/torbox.ts
+const API_BASE$4 = "https://api.torbox.app/v1/api";
+var TorBox = class extends BaseFetcher {
+	/** `/torrents/requestdl` takes the token as a query param, not the header. */
+	#token;
+	/** @param apiKey API key from https://torbox.app/settings */
+	constructor(apiKey, options = {}) {
+		super({
+			...options,
+			baseUrl: API_BASE$4,
+			headers: { Authorization: `Bearer ${apiKey}` }
+		});
+		this.#token = apiKey;
+	}
+	/** Unwraps the `{ success, error, detail, data }` envelope. */
+	async request(method, path, options = {}) {
+		const body = await super.request(method, path, options);
+		if (!body?.success) throw new DebridError(body?.detail ?? "TorBox error", 200, body?.error ?? void 0, body);
+		return body.data;
+	}
+	name = "torbox";
+	async getUser() {
+		const user = await this.get("/user/me");
+		const expiresAt = user.premium_expires_at ? new Date(user.premium_expires_at) : null;
+		return {
+			id: String(user.id),
+			username: user.email,
+			email: user.email,
+			premium: user.plan > 0 && (expiresAt === null || expiresAt.getTime() > Date.now()),
+			expiresAt
+		};
+	}
+	/** Real lookup via `/torrents/checkcached`, no side effects. */
+	async isCached(hashOrMagnet) {
+		return (await this.checkCached([toInfoHash(hashOrMagnet)])).length > 0;
+	}
+	async addMagnet(magnet) {
+		const form = new FormData();
+		form.append("magnet", magnet);
+		return this.getTorrent(requireStarted(await this.#create(form)));
+	}
+	/** Adds a `.torrent` file and returns its torrent id. */
+	async addTorrentFile(file, filename = "upload.torrent") {
+		const form = new FormData();
+		form.append("file", toBlob(file), filename);
+		return requireStarted(await this.#create(form));
+	}
+	#create(form) {
+		return this.postBody("/torrents/createtorrent", form);
+	}
+	async listTorrents(offset = 0, limit = 100) {
+		try {
+			return (await this.get("/torrents/mylist", {
+				offset,
+				limit,
+				bypass_cache: true
+			}) ?? []).map(toTorrent$4);
+		} catch (err) {
+			if (err instanceof DebridError && (err.status === 404 || err.code === "ITEM_NOT_FOUND")) return [];
+			throw err;
+		}
+	}
+	async getTorrent(torrentId) {
+		return toTorrent$4(await this.get("/torrents/mylist", {
+			id: torrentId,
+			bypass_cache: true
+		}));
+	}
+	/** Requests one link per file. */
+	async getDownloadLinks(torrentId) {
+		const torrent = await this.getTorrent(torrentId);
+		const links = [];
+		for (const file of torrent.files ?? []) {
+			const url = await this.requestDownloadLink(torrentId, file.id);
+			links.push({
+				id: String(file.id),
+				filename: file.path.split("/").pop() || file.path,
+				bytes: file.bytes,
+				url,
+				originalUrl: url,
+				streamable: false
+			});
+		}
+		return links;
+	}
+	/** GET /torrents/checkcached — the cached subset of `hashes`. */
+	async checkCached(hashes) {
+		return await this.get("/torrents/checkcached", {
+			hash: hashes.join(","),
+			format: "list"
+		}) ?? [];
+	}
+	/** GET /torrents/requestdl */
+	requestDownloadLink(torrentId, fileId) {
+		return this.get("/torrents/requestdl", {
+			token: this.#token,
+			torrent_id: torrentId,
+			file_id: fileId
+		});
+	}
+	/** POST /torrents/controltorrent with `operation: "delete"` */
+	async deleteTorrent(torrentId) {
+		await this.postBody("/torrents/controltorrent", JSON.stringify({
+			torrent_id: Number(torrentId),
+			operation: "delete"
+		}), { "Content-Type": "application/json" });
+	}
+	/** This instance as the provider-agnostic {@link DebridProvider}. */
+	toProvider() {
+		return this;
+	}
+};
+/** shortcut: a torrent TorBox queued (active-download limit) has no id to poll, so it errors; handle `queued_id` via /torrents/getqueued if users hit this. */
+function requireStarted(created) {
+	if (created.torrent_id == null) throw new DebridError("TorBox queued this torrent because the active download limit was reached. Try again later.", 200, "ACTIVE_LIMIT", created);
+	return String(created.torrent_id);
+}
+function toTorrentStatus$2(torrent) {
+	if (torrent.download_finished && torrent.download_present) return "downloaded";
+	const state = torrent.download_state;
+	if (/error|failed|missing/i.test(state)) return "error";
+	if (state === "metaDL") return "magnet_conversion";
+	if (state === "uploading") return "uploading";
+	if (state === "paused" || state === "checkingResumeData" || state === "queued") return "queued";
+	return "downloading";
+}
+function toTorrent$4(torrent) {
+	return {
+		id: String(torrent.id),
+		name: torrent.name,
+		hash: torrent.hash,
+		bytes: torrent.size,
+		progress: Math.round(torrent.progress * 100),
+		status: toTorrentStatus$2(torrent),
+		files: torrent.files?.map((file) => ({
+			id: file.id,
+			path: file.name,
+			bytes: file.size,
+			selected: true
+		})),
+		links: [],
+		addedAt: torrent.created_at ? new Date(torrent.created_at) : void 0,
+		speed: torrent.download_speed,
+		seeders: torrent.seeds,
+		ratio: torrent.ratio
+	};
+}
+//#endregion
+//#region src/services/debrid-link/debrid-link.ts
+const API_BASE$3 = "https://debrid-link.com/api/v2";
+/** The API's maximum page size. */
+const PER_PAGE = 100;
+const JSON_HEADERS$2 = { "Content-Type": "application/json" };
+var DebridLink = class extends BaseFetcher {
+	/** @param token Private API key from https://debrid-link.com/webapp/apikey, or an OAuth access token */
+	constructor(token, options = {}) {
+		super({
+			...options,
+			baseUrl: API_BASE$3,
+			headers: { Authorization: `Bearer ${token}` }
+		});
+	}
+	/** Unwraps `{ success, value }`. */
+	async request(method, path, options = {}) {
+		const body = await super.request(method, path, options);
+		if (!body?.success) throw new DebridError(body?.error ?? "Debrid-Link error", 200, body?.error, body);
+		return body.value;
+	}
+	name = "debrid-link";
+	async getUser() {
+		const account = await this.get("/account/infos");
+		return {
+			id: account.username,
+			username: account.username,
+			email: account.email,
+			avatar: account.avatarUrl,
+			premium: account.accountType > 0,
+			expiresAt: account.accountType === 1 ? new Date(Date.now() + account.premiumLeft * 1e3) : null
+		};
+	}
+	/**
+	* **Probe:** the API has no cache lookup, but only accepts a bare hash when
+	* it's cached. The probe torrent is removed again; a torrent the account
+	* already had is reported from the list and never touched.
+	*/
+	async isCached(hashOrMagnet) {
+		const hash = toInfoHash(hashOrMagnet);
+		const existing = (await this.#listAll()).find((t) => t.hashString.toLowerCase() === hash);
+		if (existing) return isReady(existing);
+		try {
+			const probe = await this.#add(hash);
+			await this.deleteTorrent(probe.id);
+			return true;
+		} catch (err) {
+			if (err instanceof DebridError && err.code === "notAddTorrent") return false;
+			throw err;
+		}
+	}
+	async addMagnet(magnet) {
+		return toTorrent$3(await this.#add(magnet));
+	}
+	/** Adds a `.torrent` file (multipart). */
+	async addTorrentFile(file, filename = "upload.torrent") {
+		const form = new FormData();
+		form.append("file", toBlob(file), filename);
+		return toTorrent$3(await this.postBody("/seedbox/add", form));
+	}
+	#add(url) {
+		return this.postBody("/seedbox/add", JSON.stringify({ url }), JSON_HEADERS$2);
+	}
+	async listTorrents(offset = 0, limit = 100) {
+		const skip = offset % PER_PAGE;
+		const out = [];
+		for (let page = Math.floor(offset / PER_PAGE);; page++) {
+			const batch = await this.listSeedbox(page);
+			out.push(...batch);
+			if (batch.length < PER_PAGE || out.length >= skip + limit) break;
+		}
+		return out.slice(skip, skip + limit).map(toTorrent$3);
+	}
+	async #listAll() {
+		const out = [];
+		for (let page = 0;; page++) {
+			const batch = await this.listSeedbox(page);
+			out.push(...batch);
+			if (batch.length < PER_PAGE) return out;
+		}
+	}
+	/** GET /seedbox/list */
+	listSeedbox(page = 0) {
+		return this.get("/seedbox/list", {
+			page,
+			perPage: PER_PAGE
+		});
+	}
+	async getTorrent(torrentId) {
+		return toTorrent$3(await this.#getRaw(torrentId));
+	}
+	/** `?ids=` returns every file, even for torrents listed as a single ZIP. */
+	async #getRaw(torrentId) {
+		const [torrent] = await this.get("/seedbox/list", { ids: torrentId });
+		if (!torrent) throw new DebridError(`Torrent ${torrentId} not found`, 200, "badId");
+		return torrent;
+	}
+	/** Direct links of the files that finished downloading. */
+	async getDownloadLinks(torrentId) {
+		const { files } = await this.#getRaw(torrentId);
+		return files.filter((file) => file.downloadPercent === 100).map((file) => ({
+			id: file.id,
+			filename: file.name,
+			bytes: file.size,
+			url: file.downloadUrl,
+			originalUrl: file.downloadUrl,
+			streamable: false
+		}));
+	}
+	/** POST /downloader/add — a folder link yields several files. */
+	async unrestrictLink(url) {
+		const value = await this.postBody("/downloader/add", JSON.stringify({ url }), JSON_HEADERS$2);
+		return Array.isArray(value) ? value : [value];
+	}
+	/** DELETE /seedbox/:id/remove */
+	async deleteTorrent(torrentId) {
+		await this.delete(`/seedbox/${encodeURIComponent(torrentId)}/remove`);
+	}
+	/** This instance as the provider-agnostic {@link DebridProvider}. */
+	toProvider() {
+		return this;
+	}
+};
+function isReady(torrent) {
+	return torrent.status >= 8 || torrent.downloadPercent === 100;
+}
+function toTorrent$3(torrent) {
+	return {
+		id: torrent.id,
+		name: torrent.name,
+		hash: torrent.hashString,
+		bytes: torrent.totalSize,
+		progress: torrent.downloadPercent,
+		status: isReady(torrent) ? "downloaded" : torrent.status === 4 ? "downloading" : "queued",
+		files: (torrent.isZip ? [] : torrent.files).map((file, i) => ({
+			id: i,
+			path: file.name,
+			bytes: file.size,
+			selected: true,
+			downloadUrl: file.downloadUrl || void 0
+		})),
+		links: [],
+		addedAt: torrent.created ? /* @__PURE__ */ new Date(torrent.created * 1e3) : void 0,
+		speed: torrent.downloadSpeed,
+		seeders: torrent.peersConnected,
+		ratio: torrent.uploadRatio
+	};
+}
+//#endregion
+//#region src/services/offcloud/offcloud.ts
+const API_BASE$2 = "https://offcloud.com/api";
+const JSON_HEADERS$1 = { "Content-Type": "application/json" };
+var Offcloud = class extends BaseFetcher {
+	/** @param apiKey API key from your Offcloud account */
+	constructor(apiKey, options = {}) {
+		super({
+			...options,
+			baseUrl: API_BASE$2,
+			headers: { Authorization: `Bearer ${apiKey}` }
+		});
+	}
+	/** Errors can arrive as `{ error }` with HTTP 200. */
+	async request(method, path, options = {}) {
+		const body = await super.request(method, path, options);
+		if (body?.error) throw new DebridError(body.error, 200, body.error, body);
+		return body;
+	}
+	#postJson(path, json) {
+		return this.postBody(path, JSON.stringify(json), JSON_HEADERS$1);
+	}
+	name = "offcloud";
+	async getUser() {
+		const account = await this.get("/account/info");
+		return {
+			id: account.user_id,
+			username: account.user_id,
+			premium: account.is_premium,
+			expiresAt: account.expiration_date ? new Date(account.expiration_date) : null
+		};
+	}
+	/** Real lookup via `/cache/info`, no side effects. */
+	async isCached(hashOrMagnet) {
+		const [item] = await this.#postJson("/cache/info", { urls: [toMagnet(hashOrMagnet)] });
+		return item?.cached === true;
+	}
+	async addMagnet(magnet) {
+		const item = await this.#postJson("/cloud", { url: magnet });
+		if (item.not_available) throw new DebridError(`Offcloud can't start this download on your plan (${item.not_available})`, 200, "not_available", item);
+		return toTorrent$2(item);
+	}
+	/** `/cloud/history` has no server-side pagination, so this slices locally. */
+	async listTorrents(offset = 0, limit = 100) {
+		return (await this.get("/cloud/history")).slice(offset, offset + limit).map(toTorrent$2);
+	}
+	/** POST /cloud/status */
+	async getTorrent(torrentId) {
+		const body = await this.#postJson("/cloud/status", { requestId: torrentId });
+		return toTorrent$2({
+			...typeof body.status === "string" ? { status: body.status } : body.status,
+			requestId: torrentId
+		});
+	}
+	/** Direct links from GET /cloud/explore/:id */
+	async getDownloadLinks(torrentId) {
+		const { files } = await this.get(`/cloud/explore/${encodeURIComponent(torrentId)}`, { format: "detailed" });
+		return files.map((file) => ({
+			id: file.id ?? file.path,
+			filename: file.path,
+			bytes: file.size,
+			url: file.url,
+			originalUrl: file.url,
+			streamable: false
+		}));
+	}
+	/** POST /cloud/remove */
+	async deleteTorrent(torrentId) {
+		await this.#postJson("/cloud/remove", { requestIds: [torrentId] });
+	}
+	/** This instance as the provider-agnostic {@link DebridProvider}. */
+	toProvider() {
+		return this;
+	}
+};
+function toTorrentStatus$1(status) {
+	switch (status) {
+		case "created":
+		case "queued": return "queued";
+		case "downloading": return "downloading";
+		case "downloaded": return "downloaded";
+		default: return "error";
+	}
+}
+/** The API reports only a state, not progress or size. */
+function toTorrent$2(item) {
+	const status = toTorrentStatus$1(item.status);
+	return {
+		id: item.requestId,
+		name: item.fileName ?? "",
+		hash: item.originalLink?.startsWith("magnet:") ? toInfoHash(item.originalLink) : "",
+		bytes: 0,
+		progress: status === "downloaded" ? 100 : 0,
+		status,
+		links: [],
+		addedAt: item.createdOn ? new Date(item.createdOn) : void 0
+	};
+}
+//#endregion
+//#region src/services/putio/putio.ts
+const API_BASE$1 = "https://api.put.io/v2";
+const UPLOAD_BASE = "https://upload.put.io/v2";
+const DIRECTORY = "application/x-directory";
+var Putio = class extends BaseFetcher {
+	#upload;
+	/** @param token OAuth token from https://app.put.io/oauth */
+	constructor(token, options = {}) {
+		const headers = { Authorization: `Bearer ${token}` };
+		super({
+			...options,
+			baseUrl: API_BASE$1,
+			headers
+		});
+		this.#upload = new BaseFetcher({
+			...options,
+			baseUrl: UPLOAD_BASE,
+			headers
+		});
+	}
+	name = "putio";
+	async getUser() {
+		const { info } = await this.get("/account/info");
+		const expiresAt = info.plan_expiration_date ? new Date(info.plan_expiration_date) : null;
+		return {
+			id: String(info.user_id),
+			username: info.username,
+			email: info.mail,
+			avatar: info.avatar_url,
+			premium: info.account_active && expiresAt !== null && expiresAt.getTime() > Date.now(),
+			expiresAt
+		};
+	}
+	/** put.io has no shared cache to look up, so this is always false. */
+	async isCached(_hashOrMagnet) {
+		return false;
+	}
+	async addMagnet(magnet) {
+		const { transfer } = await this.post("/transfers/add", { url: magnet });
+		return toTorrent$1(transfer);
+	}
+	/** Uploads a `.torrent` file, which starts a transfer, and returns its id. */
+	async addTorrentFile(file, filename = "upload.torrent") {
+		const form = new FormData();
+		form.append("file", toBlob(file), filename);
+		const { transfer } = await this.#upload.postBody("/files/upload", form);
+		if (!transfer) throw new DebridError("put.io did not start a transfer for this file", 200);
+		return String(transfer.id);
+	}
+	/** `/transfers/list` has no server-side pagination, so this slices locally. */
+	async listTorrents(offset = 0, limit = 100) {
+		const { transfers } = await this.get("/transfers/list");
+		return transfers.slice(offset, offset + limit).map(toTorrent$1);
+	}
+	async getTorrent(torrentId) {
+		return toTorrent$1(await this.getTransfer(torrentId));
+	}
+	/** GET /transfers/:id */
+	async getTransfer(transferId) {
+		const { transfer } = await this.get(`/transfers/${encodeURIComponent(transferId)}`);
+		return transfer;
+	}
+	/** Requests one link per file. */
+	async getDownloadLinks(torrentId) {
+		const links = [];
+		for (const file of await this.listTransferFiles(torrentId)) {
+			const url = await this.getFileUrl(file.id);
+			links.push({
+				id: String(file.id),
+				filename: file.path,
+				bytes: file.size,
+				url,
+				originalUrl: url,
+				streamable: false
+			});
+		}
+		return links;
+	}
+	/** Every file a finished transfer produced, walking its folder tree. */
+	async listTransferFiles(transferId) {
+		const transfer = await this.getTransfer(transferId);
+		if (!transfer.file_id) throw new DebridError(`Transfer ${transferId} is ${transfer.status} and has produced no files yet`, 200, "not_found");
+		const { file } = await this.get(`/files/${transfer.file_id}`);
+		return this.#walk(file, "");
+	}
+	async #walk(file, prefix) {
+		const path = prefix ? `${prefix}/${file.name}` : file.name;
+		if (file.content_type !== DIRECTORY) return [{
+			id: file.id,
+			path,
+			size: file.size
+		}];
+		const out = [];
+		for (const child of await this.listFolder(file.id)) out.push(...await this.#walk(child, path));
+		return out;
+	}
+	/** GET /files/list, following the cursor. */
+	async listFolder(folderId) {
+		let page = await this.get("/files/list", {
+			parent_id: folderId,
+			per_page: 1e3
+		});
+		const files = [...page.files];
+		while (page.cursor) {
+			page = await this.post("/files/list/continue", {
+				cursor: page.cursor,
+				per_page: 1e3
+			});
+			files.push(...page.files);
+		}
+		return files;
+	}
+	/** GET /files/:id/url */
+	async getFileUrl(fileId) {
+		const { url } = await this.get(`/files/${fileId}/url`);
+		return url;
+	}
+	/**
+	* Removes the transfer and, once finished, the files it produced, so this
+	* matches what "delete" means on the other providers.
+	*/
+	async deleteTorrent(torrentId) {
+		const transfer = await this.getTransfer(torrentId);
+		await this.post("/transfers/cancel", { transfer_ids: torrentId });
+		if (transfer.status === "SEEDING") await this.post("/transfers/remove", { transfer_ids: torrentId });
+		if (transfer.file_id) await this.post("/files/delete", { file_ids: transfer.file_id });
+	}
+	/** This instance as the provider-agnostic {@link DebridProvider}. */
+	toProvider() {
+		return this;
+	}
+};
+/** Unknown states count as in progress, so a new status can't fail a healthy transfer. */
+function toTorrentStatus(status) {
+	switch (status) {
+		case "COMPLETED":
+		case "SEEDING": return "downloaded";
+		case "ERROR": return "error";
+		case "IN_QUEUE":
+		case "WAITING":
+		case "PREPARING_DOWNLOAD": return "queued";
+		default: return "downloading";
+	}
+}
+/** The spec documents `source`; older responses also carry `magneturi`. */
+function magnetOf(transfer) {
+	if (transfer.magneturi) return transfer.magneturi;
+	return transfer.source?.startsWith("magnet:") ? transfer.source : void 0;
+}
+function toTorrent$1(transfer) {
+	return {
+		id: String(transfer.id),
+		name: transfer.name,
+		hash: toInfoHash(magnetOf(transfer) ?? ""),
+		bytes: transfer.size,
+		progress: transfer.percent_done,
+		status: toTorrentStatus(transfer.status),
+		links: [],
+		addedAt: transfer.created_at ? new Date(transfer.created_at) : void 0,
+		speed: transfer.down_speed,
+		seeders: transfer.peers_connected ?? transfer.peers
+	};
+}
+//#endregion
+//#region src/services/easydebrid/easydebrid.ts
+const API_BASE = "https://easydebrid.com/api/v1";
+const JSON_HEADERS = { "Content-Type": "application/json" };
+var EasyDebrid = class extends BaseFetcher {
+	/** @param apiKey API key from your EasyDebrid dashboard */
+	constructor(apiKey, options = {}) {
+		super({
+			...options,
+			baseUrl: API_BASE,
+			headers: {
+				Authorization: `Bearer ${apiKey}`,
+				Accept: "application/json"
+			}
+		});
+	}
+	/** Errors can arrive as `{ error }` with HTTP 200. */
+	async request(method, path, options = {}) {
+		const body = await super.request(method, path, options);
+		if (body?.error) throw new DebridError(body.error, 200, body.error, body);
+		return body;
+	}
+	name = "easydebrid";
+	async getUser() {
+		const user = await this.get("/user/details");
+		const expiresAt = user.paid_until ? new Date(user.paid_until) : null;
+		return {
+			id: user.id,
+			username: user.id,
+			premium: expiresAt !== null && expiresAt.getTime() > Date.now(),
+			expiresAt
+		};
+	}
+	/** Real lookup via `/link/lookup`, no side effects. */
+	async isCached(hashOrMagnet) {
+		const { cached } = await this.postBody("/link/lookup", JSON.stringify({ urls: [toMagnet(hashOrMagnet)] }), JSON_HEADERS);
+		return cached[0] === true;
+	}
+	/** Nothing is added remotely: this checks the cache and returns the hash as the id. */
+	async addMagnet(magnet) {
+		const hash = toInfoHash(magnet);
+		if (!hash) throw new DebridError("Not a valid magnet link", 400, "invalid_magnet");
+		if (!await this.isCached(hash)) throw new DebridError("This torrent isn't cached on EasyDebrid, which only serves cached content.", 200, "not_cached");
+		return toTorrent(hash, new URLSearchParams(magnet.split("?")[1] ?? "").get("dn") ?? "", true);
+	}
+	/** EasyDebrid keeps no list of torrents per account. */
+	async listTorrents(_offset = 0, _limit = 100) {
+		return [];
+	}
+	async getTorrent(torrentId) {
+		return toTorrent(torrentId, "", await this.isCached(torrentId));
+	}
+	/** Direct links from POST /link/generate */
+	async getDownloadLinks(torrentId) {
+		const { files } = await this.postBody("/link/generate", JSON.stringify({ url: toMagnet(torrentId) }), JSON_HEADERS);
+		return files.map((file) => {
+			const path = [...file.directory ?? [], file.filename].join("/");
+			return {
+				id: path,
+				filename: path,
+				bytes: file.size,
+				url: file.url,
+				originalUrl: file.url,
+				streamable: false
+			};
+		});
+	}
+	/** This instance as the provider-agnostic {@link DebridProvider}. */
+	toProvider() {
+		return this;
+	}
+};
+function toTorrent(hash, name, cached) {
+	return {
+		id: hash,
+		name,
+		hash,
+		bytes: 0,
+		progress: cached ? 100 : 0,
+		status: cached ? "downloaded" : "dead",
+		links: []
+	};
+}
+//#endregion
+export { AllDebrid, BaseFetcher, DebridError, DebridLink, EasyDebrid, Offcloud, Premiumize, Putio, REAL_DEBRID_OPENSOURCE_CLIENT_ID, RealDebrid, TorBox };

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "debrid-ts",
   "type": "module",
-  "version": "0.1.0",
-  "description": "Typed API clients for debrid services (Real-Debrid, AllDebrid, Premiumize) behind one provider-agnostic interface.",
+  "version": "0.2.0",
+  "description": "Typed API clients for debrid services (Real-Debrid, AllDebrid, Premiumize, TorBox, Debrid-Link, Offcloud, put.io, EasyDebrid) behind one provider-agnostic interface.",
   "author": "Joshue Abance <iamcoderx@gmail.com>",
   "license": "MIT",
   "homepage": "https://git.tbdh.app/Libraries/debrid-ts#readme",
@@ -19,6 +19,11 @@
     "realdebrid",
     "alldebrid",
     "premiumize",
+    "torbox",
+    "debrid-link",
+    "offcloud",
+    "putio",
+    "easydebrid",
     "torrent",
     "magnet",
     "api",