stophy 0.2.1 → 1.0.0

package/dist/index.js

@@ -1,341 +1,621 @@
-import { createClient, createConfig } from '@hey-api/client-fetch';
-
-// src/generated/client.gen.ts
-var client = createClient(
-  createConfig({
-    baseUrl: "https://api.stophy.dev"
-  })
-);
-
-// src/generated/sdk.gen.ts
-var getVideo = (options) => {
-  return (options.client ?? client).post({
-    security: [
-      {
-        scheme: "bearer",
-        type: "http"
-      }
-    ],
-    url: "/v1/video",
-    ...options,
-    headers: {
-      "Content-Type": "application/json",
-      ...options?.headers
-    }
-  });
-};
-var searchVideos = (options) => {
-  return (options.client ?? client).post({
-    security: [
-      {
-        scheme: "bearer",
-        type: "http"
-      }
-    ],
-    url: "/v1/search",
-    ...options,
-    headers: {
-      "Content-Type": "application/json",
-      ...options?.headers
-    }
-  });
-};
-var getChannel = (options) => {
-  return (options.client ?? client).post({
-    security: [
-      {
-        scheme: "bearer",
-        type: "http"
-      }
-    ],
-    url: "/v1/channel",
-    ...options,
-    headers: {
-      "Content-Type": "application/json",
-      ...options?.headers
-    }
-  });
-};
-var getPlaylist = (options) => {
-  return (options.client ?? client).post({
-    security: [
-      {
-        scheme: "bearer",
-        type: "http"
-      }
-    ],
-    url: "/v1/playlist",
-    ...options,
-    headers: {
-      "Content-Type": "application/json",
-      ...options?.headers
-    }
-  });
-};
-var getSuggestions = (options) => {
-  return (options.client ?? client).get({
-    security: [
-      {
-        scheme: "bearer",
-        type: "http"
-      }
-    ],
-    url: "/v1/suggest",
-    ...options
-  });
-};
-var getCredits = (options) => {
-  return (options?.client ?? client).get({
-    security: [
-      {
-        scheme: "bearer",
-        type: "http"
-      }
-    ],
-    url: "/v1/credits",
-    ...options
-  });
-};
-var getLogs = (options) => {
-  return (options?.client ?? client).get({
-    security: [
-      {
-        scheme: "bearer",
-        type: "http"
-      }
-    ],
-    url: "/v1/logs",
-    ...options
-  });
-};
-var getUsage = (options) => {
-  return (options?.client ?? client).get({
-    security: [
-      {
-        scheme: "bearer",
-        type: "http"
-      }
-    ],
-    url: "/v1/usage",
-    ...options
-  });
-};
-
 // src/errors.ts
 var StophyError = class extends Error {
   code;
+  retryable;
+  retryAfterSeconds;
   status;
   requestId;
-  details;
   constructor(message, options) {
     super(message);
     this.name = "StophyError";
     this.status = options.status;
     this.code = options.code;
+    this.retryable = options.retryable;
+    this.retryAfterSeconds = options.retryAfterSeconds;
     this.requestId = options.requestId;
-    this.details = options.details;
   }
 };
 
-// src/transport.ts
-var DEFAULT_BASE_URL = "https://api.stophy.dev";
-var RETRYABLE_STATUS = /* @__PURE__ */ new Set([429, 500, 502, 503, 504]);
-function createTransport(options) {
-  const baseFetch = options.fetch ?? globalThis.fetch;
-  return createClient(
-    createConfig({
-      baseUrl: options.baseUrl ?? DEFAULT_BASE_URL,
-      auth: () => options.apiKey,
-      headers: options.headers,
-      fetch: withRetries(
-        baseFetch,
-        options.maxRetries ?? 2,
-        options.retryInitialDelayMs ?? 500
-      )
-    })
+// src/account.ts
+function usage(call) {
+  return call({ method: "GET", path: "/v1/usage" }).then(parseUsage);
+}
+function logs(call, query) {
+  const params = {};
+  if (query?.apiKeyId !== void 0) params.apiKeyId = query.apiKeyId;
+  if (query?.days !== void 0) params.days = query.days;
+  if (query?.endpoint !== void 0) params.endpoint = query.endpoint;
+  if (query?.page !== void 0) params.page = query.page;
+  return call({ method: "GET", path: "/v1/logs", query: params }).then(
+    parseLogs
   );
 }
-function withRetries(baseFetch, maxRetries, initialDelayMs) {
-  if (maxRetries <= 0) return baseFetch;
-  return async (input, init) => {
-    for (let attempt = 0; ; attempt++) {
-      const request = input instanceof Request ? input.clone() : input;
-      try {
-        const response = await baseFetch(request, init);
-        if (attempt < maxRetries && RETRYABLE_STATUS.has(response.status)) {
-          await sleep(
-            retryAfterMs(response) ?? backoffMs(attempt, initialDelayMs)
-          );
-          continue;
-        }
-        return response;
-      } catch (error) {
-        if (attempt >= maxRetries) throw error;
-        await sleep(backoffMs(attempt, initialDelayMs));
-      }
-    }
+function parseUsage(value) {
+  if (!isRecord(value)) return unexpected("usage");
+  const balanceMicros = numberField(value, "balanceMicros");
+  const creditsUsed = numberField(value, "creditsUsed");
+  const requestCount = numberField(value, "requestCount");
+  return { balanceMicros, creditsUsed, requestCount };
+}
+function parseLogs(value) {
+  if (!isRecord(value) || !Array.isArray(value.logs) || !Array.isArray(value.endpoints)) {
+    return unexpected("logs");
+  }
+  return {
+    endpoints: value.endpoints.map((item) => {
+      if (typeof item !== "string") return unexpected("logs.endpoints");
+      return item;
+    }),
+    logs: value.logs.map(parseLog),
+    page: numberField(value, "page"),
+    pageSize: numberField(value, "pageSize"),
+    total: numberField(value, "total"),
+    totalPages: numberField(value, "totalPages")
   };
 }
-function backoffMs(attempt, base) {
-  const window = base * 2 ** attempt;
-  return window / 2 + Math.random() * (window / 2);
+function parseLog(value) {
+  if (!isRecord(value)) return unexpected("logs.logs");
+  return {
+    apiKeyId: stringOrNull(value, "apiKeyId"),
+    apiKeyName: stringOrNull(value, "apiKeyName"),
+    createdAt: stringField(value, "createdAt"),
+    credits: numberField(value, "credits"),
+    durationMs: numberOrNull(value, "durationMs"),
+    endpoint: stringField(value, "endpoint"),
+    id: stringField(value, "id"),
+    method: stringField(value, "method"),
+    response: stringField(value, "response"),
+    status: numberField(value, "status")
+  };
 }
-function retryAfterMs(response) {
-  const header = response.headers.get("retry-after");
-  if (!header) return null;
-  const seconds = Number(header);
-  if (!Number.isNaN(seconds)) return seconds * 1e3;
-  const date = Date.parse(header);
-  return Number.isNaN(date) ? null : Math.max(0, date - Date.now());
+function numberField(record, field) {
+  const value = record[field];
+  if (typeof value !== "number") return unexpected(field);
+  return value;
 }
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+function numberOrNull(record, field) {
+  const value = record[field];
+  if (value === null) return null;
+  if (typeof value !== "number") return unexpected(field);
+  return value;
 }
-function unwrap(result) {
-  if (result.error === void 0 && result.data !== void 0)
-    return result.data;
-  const error = result.error ?? {};
-  throw new StophyError(
-    error.error ?? `Stophy request failed with status ${result.response.status}`,
-    {
-      status: result.response.status,
-      code: error.code,
-      requestId: result.response.headers.get("x-request-id") ?? void 0,
-      details: error.details
-    }
-  );
+function stringField(record, field) {
+  const value = record[field];
+  if (typeof value !== "string") return unexpected(field);
+  return value;
 }
-
-// src/methods/account.ts
-function credits(client2) {
-  return getCredits({ client: client2 }).then(unwrap);
+function stringOrNull(record, field) {
+  const value = record[field];
+  if (value === null) return null;
+  if (typeof value !== "string") return unexpected(field);
+  return value;
 }
-function logs(client2, query) {
-  return getLogs({ client: client2, query }).then(unwrap);
+function unexpected(field) {
+  throw new StophyError(`Stophy returned an unexpected ${field}`, {
+    status: 200,
+    retryable: false
+  });
 }
-function usage(client2, query) {
-  return getUsage({ client: client2, query }).then(unwrap);
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
-// src/methods/channel.ts
-function channel(client2, urlOrBody, options = {}) {
-  const body = typeof urlOrBody === "string" ? { channelUrl: urlOrBody, ...options } : urlOrBody;
-  return getChannel({ client: client2, body }).then(unwrap);
+// src/bind.ts
+function post(path, call) {
+  function run(body, options) {
+    return call({ method: "POST", path, body, options });
+  }
+  return run;
 }
-
-// src/methods/playlist.ts
-function playlist(client2, urlOrBody, options = {}) {
-  const body = typeof urlOrBody === "string" ? { playlistUrl: urlOrBody, ...options } : urlOrBody;
-  return getPlaylist({ client: client2, body }).then(unwrap);
+function postOptional(path, call) {
+  function run(body, options) {
+    if (isMarkdownOptions(body) && options === void 0) {
+      return call({ method: "POST", path, body: {}, options: body });
+    }
+    return call({ method: "POST", path, body: body ?? {}, options });
+  }
+  return run;
 }
-
-// src/methods/search.ts
-function search(client2, queryOrBody, options = {}) {
-  if (typeof queryOrBody === "string" && !queryOrBody.trim()) {
-    throw new Error("query cannot be empty");
+function get(path, call) {
+  function run(options) {
+    return call({ method: "GET", path, options });
   }
-  const body = typeof queryOrBody === "string" ? { q: queryOrBody, ...options } : queryOrBody;
-  return searchVideos({ client: client2, body }).then(unwrap);
+  return run;
+}
+function isMarkdownOptions(value) {
+  if (typeof value !== "object" || value === null) return false;
+  return "format" in value && value.format === "markdown";
 }
 
-// src/methods/suggest.ts
-function suggest(client2, queryOrOptions, options = {}) {
-  if (typeof queryOrOptions === "string" && !queryOrOptions.trim()) {
-    throw new Error("query cannot be empty");
-  }
-  const query = typeof queryOrOptions === "string" ? { q: queryOrOptions, ...options } : queryOrOptions;
-  return getSuggestions({ client: client2, query }).then(unwrap);
+// src/generated/surface.gen.ts
+function bindSurface(call) {
+  return {
+    endpoints: get("/v1/endpoints", call),
+    web: {
+      search: post("/v1/web/search", call),
+      news: postOptional("/v1/web/news", call),
+      contacts: post("/v1/web/contacts", call)
+    },
+    youtube: {
+      search: post("/v1/youtube/search", call),
+      video: post("/v1/youtube/video", call),
+      transcript: post("/v1/youtube/transcript", call),
+      comments: Object.assign(post("/v1/youtube/comments", call), {
+        replies: post("/v1/youtube/comments/replies", call)
+      }),
+      channel: post("/v1/youtube/channel", call),
+      playlist: post("/v1/youtube/playlist", call),
+      suggest: post("/v1/youtube/suggest", call)
+    },
+    reddit: {
+      search: post("/v1/reddit/search", call),
+      post: post("/v1/reddit/post", call),
+      comments: {
+        more: post("/v1/reddit/comments/more", call)
+      },
+      subreddit: post("/v1/reddit/subreddit", call),
+      user: post("/v1/reddit/user", call),
+      domain: post("/v1/reddit/domain", call)
+    },
+    maps: {
+      search: post("/v1/maps/search", call),
+      place: post("/v1/maps/place", call),
+      reviews: post("/v1/maps/reviews", call)
+    },
+    instagram: {
+      profile: post("/v1/instagram/profile", call),
+      posts: post("/v1/instagram/posts", call),
+      post: post("/v1/instagram/post", call),
+      url: post("/v1/instagram/url", call),
+      search: post("/v1/instagram/search", call),
+      transcript: post("/v1/instagram/transcript", call),
+      comments: Object.assign(post("/v1/instagram/comments", call), {
+        replies: post("/v1/instagram/comments/replies", call)
+      })
+    },
+    tiktok: {
+      profile: post("/v1/tiktok/profile", call),
+      video: post("/v1/tiktok/video", call),
+      url: post("/v1/tiktok/url", call),
+      transcript: post("/v1/tiktok/transcript", call),
+      posts: post("/v1/tiktok/posts", call),
+      hashtag: post("/v1/tiktok/hashtag", call),
+      comments: Object.assign(post("/v1/tiktok/comments", call), {
+        replies: post("/v1/tiktok/comments/replies", call)
+      }),
+      search: post("/v1/tiktok/search", call),
+      ads: {
+        search: postOptional("/v1/tiktok/ads/search", call),
+        ad: post("/v1/tiktok/ads/ad", call)
+      }
+    },
+    bluesky: {
+      profile: post("/v1/bluesky/profile", call),
+      posts: post("/v1/bluesky/posts", call),
+      post: post("/v1/bluesky/post", call),
+      followers: post("/v1/bluesky/followers", call)
+    },
+    mastodon: {
+      profile: post("/v1/mastodon/profile", call),
+      posts: post("/v1/mastodon/posts", call),
+      post: post("/v1/mastodon/post", call),
+      hashtag: post("/v1/mastodon/hashtag", call)
+    },
+    threads: {
+      profile: post("/v1/threads/profile", call),
+      posts: post("/v1/threads/posts", call),
+      post: post("/v1/threads/post", call),
+      search: post("/v1/threads/search", call)
+    },
+    telegram: {
+      channel: post("/v1/telegram/channel", call),
+      posts: post("/v1/telegram/posts", call),
+      post: post("/v1/telegram/post", call)
+    },
+    meta: {
+      ads: {
+        search: post("/v1/meta/ads/search", call),
+        page: post("/v1/meta/ads/page", call),
+        ad: post("/v1/meta/ads/ad", call)
+      }
+    },
+    linkedin: {
+      jobs: {
+        search: postOptional("/v1/linkedin/jobs/search", call),
+        job: post("/v1/linkedin/jobs/job", call)
+      },
+      ads: {
+        search: postOptional("/v1/linkedin/ads/search", call),
+        ad: post("/v1/linkedin/ads/ad", call)
+      },
+      company: Object.assign(post("/v1/linkedin/company", call), {
+        posts: post("/v1/linkedin/company/posts", call)
+      }),
+      profile: post("/v1/linkedin/profile", call),
+      posts: postOptional("/v1/linkedin/posts", call)
+    },
+    zillow: {
+      search: postOptional("/v1/zillow/search", call),
+      property: post("/v1/zillow/property", call)
+    },
+    google: {
+      ads: {
+        advertisers: post("/v1/google/ads/advertisers", call),
+        search: postOptional("/v1/google/ads/search", call),
+        ad: post("/v1/google/ads/ad", call)
+      },
+      suggest: post("/v1/google/suggest", call),
+      trends: {
+        interest: post("/v1/google/trends/interest", call),
+        regions: post("/v1/google/trends/regions", call),
+        related: post("/v1/google/trends/related", call),
+        trending: postOptional("/v1/google/trends/trending", call)
+      }
+    },
+    upwork: {
+      search: postOptional("/v1/upwork/search", call),
+      job: post("/v1/upwork/job", call)
+    },
+    amazon: {
+      suggest: post("/v1/amazon/suggest", call),
+      search: postOptional("/v1/amazon/search", call),
+      product: post("/v1/amazon/product", call),
+      bestsellers: post("/v1/amazon/bestsellers", call)
+    },
+    site: {
+      map: post("/v1/site/map", call),
+      seo: post("/v1/site/seo", call)
+    },
+    domain: {
+      whois: post("/v1/domain/whois", call),
+      dns: post("/v1/domain/dns", call),
+      tech: post("/v1/domain/tech", call)
+    },
+    email: {
+      check: post("/v1/email/check", call)
+    },
+    crypto: {
+      coins: postOptional("/v1/crypto/coins", call),
+      coin: post("/v1/crypto/coin", call),
+      history: post("/v1/crypto/history", call),
+      trending: postOptional("/v1/crypto/trending", call),
+      categories: postOptional("/v1/crypto/categories", call),
+      movers: postOptional("/v1/crypto/movers", call),
+      new: postOptional("/v1/crypto/new", call),
+      dex: {
+        search: post("/v1/crypto/dex/search", call),
+        pairs: post("/v1/crypto/dex/pairs", call),
+        token: post("/v1/crypto/dex/token", call),
+        new: postOptional("/v1/crypto/dex/new", call)
+      },
+      pump: {
+        coins: postOptional("/v1/crypto/pump/coins", call),
+        coin: post("/v1/crypto/pump/coin", call),
+        trades: post("/v1/crypto/pump/trades", call)
+      },
+      wallet: post("/v1/crypto/wallet", call),
+      token: {
+        holders: post("/v1/crypto/token/holders", call)
+      },
+      binance: {
+        announcements: postOptional("/v1/crypto/binance/announcements", call)
+      }
+    },
+    indeed: {
+      search: postOptional("/v1/indeed/search", call),
+      job: post("/v1/indeed/job", call)
+    },
+    tripadvisor: {
+      search: post("/v1/tripadvisor/search", call),
+      place: post("/v1/tripadvisor/place", call),
+      reviews: post("/v1/tripadvisor/reviews", call)
+    },
+    googletravel: {
+      flights: post("/v1/googletravel/flights", call)
+    },
+    shopify: {
+      products: post("/v1/shopify/products", call),
+      collections: post("/v1/shopify/collections", call),
+      store: post("/v1/shopify/store", call)
+    },
+    walmart: {
+      search: post("/v1/walmart/search", call),
+      product: post("/v1/walmart/product", call)
+    },
+    aliexpress: {
+      search: post("/v1/aliexpress/search", call),
+      product: post("/v1/aliexpress/product", call)
+    },
+    appstore: {
+      app: post("/v1/appstore/app", call),
+      search: post("/v1/appstore/search", call),
+      reviews: post("/v1/appstore/reviews", call),
+      top: postOptional("/v1/appstore/top", call)
+    },
+    googleplay: {
+      app: post("/v1/googleplay/app", call),
+      search: post("/v1/googleplay/search", call),
+      reviews: post("/v1/googleplay/reviews", call)
+    },
+    airbnb: {
+      search: post("/v1/airbnb/search", call),
+      listing: post("/v1/airbnb/listing", call),
+      calendar: post("/v1/airbnb/calendar", call),
+      reviews: post("/v1/airbnb/reviews", call)
+    },
+    redfin: {
+      search: post("/v1/redfin/search", call),
+      property: post("/v1/redfin/property", call)
+    },
+    realtor: {
+      search: post("/v1/realtor/search", call),
+      property: post("/v1/realtor/property", call)
+    },
+    rightmove: {
+      search: post("/v1/rightmove/search", call),
+      property: post("/v1/rightmove/property", call)
+    },
+    immoscout: {
+      search: post("/v1/immoscout/search", call),
+      listing: post("/v1/immoscout/listing", call)
+    },
+    pinterest: {
+      search: post("/v1/pinterest/search", call),
+      pin: post("/v1/pinterest/pin", call),
+      board: post("/v1/pinterest/board", call),
+      user: post("/v1/pinterest/user", call),
+      ads: {
+        search: post("/v1/pinterest/ads/search", call),
+        ad: post("/v1/pinterest/ads/ad", call)
+      }
+    },
+    x: {
+      tweet: post("/v1/x/tweet", call)
+    },
+    kick: {
+      channel: post("/v1/kick/channel", call),
+      videos: post("/v1/kick/videos", call),
+      clips: post("/v1/kick/clips", call)
+    },
+    finance: {
+      quote: post("/v1/finance/quote", call),
+      history: post("/v1/finance/history", call),
+      search: post("/v1/finance/search", call),
+      profile: post("/v1/finance/profile", call)
+    },
+    microsoft: {
+      ads: {
+        search: postOptional("/v1/microsoft/ads/search", call),
+        ad: post("/v1/microsoft/ads/ad", call),
+        advertisers: post("/v1/microsoft/ads/advertisers", call)
+      }
+    },
+    snapchat: {
+      profile: post("/v1/snapchat/profile", call),
+      ads: {
+        search: post("/v1/snapchat/ads/search", call),
+        ad: post("/v1/snapchat/ads/ad", call)
+      }
+    },
+    tumblr: {
+      blog: post("/v1/tumblr/blog", call),
+      posts: post("/v1/tumblr/posts", call),
+      post: post("/v1/tumblr/post", call),
+      search: post("/v1/tumblr/search", call)
+    },
+    quora: {
+      question: post("/v1/quora/question", call)
+    }
+  };
 }
 
-// src/methods/video.ts
-async function video(client2, body) {
-  return unwrap(await getVideo({ client: client2, body }));
+// package.json
+var version = "1.0.0";
+
+// src/transport.ts
+var DEFAULT_BASE_URL = "https://api.stophy.dev";
+var DEFAULT_TIMEOUT_MS = 3e4;
+var MAX_RETRY_WAIT_SECONDS = 60;
+var RETRYABLE_STATUS = /* @__PURE__ */ new Set([429, 500, 502, 503, 504]);
+var USER_AGENT = `stophy-typescript/${version}`;
+function createCaller(options) {
+  const baseFetch = options.fetch ?? globalThis.fetch;
+  const baseUrl = (options.baseUrl ?? DEFAULT_BASE_URL).replace(/\/$/, "");
+  const retry = {
+    maxRetries: options.maxRetries ?? 2,
+    initialDelayMs: options.retryInitialDelayMs ?? 500,
+    timeoutMs: options.timeoutMs ?? DEFAULT_TIMEOUT_MS
+  };
+  return async (spec) => {
+    const markdown = spec.options?.format === "markdown";
+    const headers = new Headers(options.headers);
+    if (typeof document === "undefined" && !headers.has("user-agent")) {
+      headers.set("user-agent", USER_AGENT);
+    }
+    if (options.apiKey) {
+      headers.set("authorization", `Bearer ${options.apiKey}`);
+    }
+    headers.set("accept", markdown ? "text/markdown" : "application/json");
+    if (spec.body !== void 0)
+      headers.set("content-type", "application/json");
+    const url = withQuery(`${baseUrl}${spec.path}`, spec.query);
+    return send(
+      baseFetch,
+      url,
+      (signal) => ({
+        method: spec.method,
+        headers,
+        body: spec.body === void 0 ? void 0 : JSON.stringify(spec.body),
+        signal
+      }),
+      markdown,
+      spec.options?.signal,
+      retry
+    );
+  };
 }
-function videoDetails(client2, videoUrl) {
-  return video(client2, { type: "details", videoUrl });
+async function send(baseFetch, url, init, markdown, signal, retry) {
+  for (let n = 0; ; n += 1) {
+    const deadline = withDeadline(signal, retry.timeoutMs);
+    let waitMs;
+    try {
+      const response = await baseFetch(url, init(deadline.signal)).catch(
+        (error) => {
+          if (deadline.signal.aborted || n >= retry.maxRetries) throw error;
+          return void 0;
+        }
+      );
+      if (response === void 0) {
+        waitMs = backoffMs(n, retry.initialDelayMs);
+      } else if (n < retry.maxRetries && RETRYABLE_STATUS.has(response.status)) {
+        const error = await errorFrom(response);
+        const seconds = error.retryAfterSeconds;
+        if (seconds !== void 0 && seconds > MAX_RETRY_WAIT_SECONDS) {
+          throw error;
+        }
+        waitMs = seconds === void 0 ? backoffMs(n, retry.initialDelayMs) : seconds * 1e3;
+      } else {
+        return await readBody(response, markdown);
+      }
+    } finally {
+      deadline.clear();
+    }
+    await sleep(waitMs);
+  }
 }
-function transcript(client2, videoUrl) {
-  return video(client2, { type: "transcript", videoUrl });
+function withDeadline(signal, timeoutMs) {
+  const controller = new AbortController();
+  const abort = () => controller.abort(signal?.reason);
+  if (signal?.aborted) abort();
+  else signal?.addEventListener("abort", abort, { once: true });
+  const timer = setTimeout(
+    () => controller.abort(
+      new DOMException(
+        `Stophy request timed out after ${timeoutMs} ms`,
+        "TimeoutError"
+      )
+    ),
+    timeoutMs
+  );
+  return {
+    signal: controller.signal,
+    clear: () => {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", abort);
+    }
+  };
 }
-function comments(client2, videoUrl, options = {}) {
-  return video(client2, {
-    type: "comments",
-    videoUrl,
-    ...options
-  });
+async function readBody(response, markdown) {
+  if (!response.ok) throw await errorFrom(response);
+  const text = await response.text();
+  if (markdown) return text;
+  if (!text) {
+    throw failed(response, "Stophy returned an empty response", {});
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw failed(response, "Stophy returned a non-JSON response", {});
+  }
 }
-function replies(client2, continuationToken) {
-  return video(client2, {
-    type: "replies",
-    continuationToken
-  });
+async function errorFrom(response) {
+  const text = await response.text();
+  let body;
+  if (text) {
+    try {
+      body = JSON.parse(text);
+    } catch {
+      body = void 0;
+    }
+  }
+  const error = readError(body);
+  const retryAfterSeconds = error.retryAfterSeconds ?? headerRetryAfter(response);
+  return failed(
+    response,
+    error.message ?? `Stophy request failed with status ${response.status}`,
+    {
+      code: error.code,
+      retryable: error.retryable ?? RETRYABLE_STATUS.has(response.status),
+      retryAfterSeconds,
+      requestId: error.requestId ?? headerRequestId(response)
+    }
+  );
 }
-function liveChat(client2, videoUrl, options = {}) {
-  return video(client2, {
-    type: "livechat",
-    videoUrl,
-    ...options
+function failed(response, message, options) {
+  return new StophyError(message, {
+    status: response.status,
+    code: options.code,
+    retryable: options.retryable ?? false,
+    retryAfterSeconds: options.retryAfterSeconds,
+    requestId: options.requestId ?? headerRequestId(response)
   });
 }
+function readError(body) {
+  if (!isRecord2(body) || !isRecord2(body.error)) return {};
+  const error = body.error;
+  return {
+    code: typeof error.code === "string" ? error.code : void 0,
+    message: typeof error.message === "string" ? error.message : void 0,
+    retryable: typeof error.retryable === "boolean" ? error.retryable : void 0,
+    retryAfterSeconds: typeof error.retryAfterSeconds === "number" ? error.retryAfterSeconds : void 0,
+    requestId: typeof error.requestId === "string" ? error.requestId : void 0
+  };
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function headerRequestId(response) {
+  return response.headers.get("x-request-id") ?? void 0;
+}
+function headerRetryAfter(response) {
+  const header = response.headers.get("retry-after");
+  if (!header) return void 0;
+  const seconds = Number(header);
+  if (Number.isFinite(seconds)) return seconds;
+  const date = Date.parse(header);
+  if (Number.isNaN(date)) return void 0;
+  return Math.max(0, Math.ceil((date - Date.now()) / 1e3));
+}
+function withQuery(url, query) {
+  if (!query) return url;
+  const params = new URLSearchParams();
+  for (const [key, value] of Object.entries(query)) {
+    if (value !== void 0) params.set(key, String(value));
+  }
+  const text = params.toString();
+  return text ? `${url}?${text}` : url;
+}
+function backoffMs(attempt, base) {
+  const window = base * 2 ** attempt;
+  return window / 2 + Math.random() * (window / 2);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
 
 // src/client.ts
 function env(name) {
   return typeof process === "undefined" ? void 0 : process.env[name];
 }
 var Stophy = class {
-  client;
+  #call;
   constructor(input = {}) {
     const options = typeof input === "string" ? { apiKey: input } : input;
     const apiKey = options.apiKey?.trim() || env("STOPHY_API_KEY")?.trim();
-    if (!apiKey) {
-      throw new Error(
-        "Stophy: provide `apiKey` or set the STOPHY_API_KEY environment variable."
-      );
-    }
-    this.client = createTransport({
+    this.#call = createCaller({
       ...options,
       apiKey,
       baseUrl: options.baseUrl ?? env("STOPHY_BASE_URL")
     });
+    Object.assign(this, bindSurface(this.#call));
   }
-  async video(body) {
-    return video(this.client, body);
-  }
-  videoDetails(videoUrl) {
-    return videoDetails(this.client, videoUrl);
-  }
-  transcript(videoUrl) {
-    return transcript(this.client, videoUrl);
-  }
-  comments(videoUrl, options) {
-    return comments(this.client, videoUrl, options);
-  }
-  replies(continuationToken) {
-    return replies(this.client, continuationToken);
-  }
-  liveChat(videoUrl, options) {
-    return liveChat(this.client, videoUrl, options);
-  }
-  async search(queryOrBody, options) {
-    return search(this.client, queryOrBody, options);
-  }
-  async channel(urlOrBody, options) {
-    return channel(this.client, urlOrBody, options);
-  }
-  async playlist(urlOrBody, options) {
-    return playlist(this.client, urlOrBody, options);
-  }
-  async suggest(queryOrOptions, options) {
-    return suggest(this.client, queryOrOptions, options);
-  }
-  credits() {
-    return credits(this.client);
+  /** Current balance and lifetime usage. Requires an API key. */
+  usage() {
+    return usage(this.#call);
   }
+  /** Recent metered requests. Requires an API key. */
   logs(query) {
-    return logs(this.client, query);
-  }
-  usage(query) {
-    return usage(this.client, query);
+    return logs(this.#call, query);
   }
 };