@widecast/sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,788 @@
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+
+// src/index.ts
+var VERSION = "0.1.0";
+var DEFAULT_BASE_URL = typeof process !== "undefined" && process.env?.WIDECAST_BASE_URL || "https://widecast.ai/app/dashboard2";
+var TERMINAL_STATUSES = ["completed", "failed"];
+var SCRIPT_MIN_WORDS = 80;
+var SCRIPT_MAX_WORDS = 500;
+var IDEA_MIN_WORDS = 5;
+var IDEA_MAX_WORDS = 1e3;
+var BLOG_MIN_WORDS = 30;
+var BLOG_MAX_WORDS = 3e3;
+var OUTPUT_TYPES = ["text", "scene", "video"];
+var SOURCES = [
+  "text",
+  "idea",
+  "blog",
+  "video_url",
+  "video_file",
+  "audio_url",
+  "audio_file"
+];
+var FACELESS_SOURCES = ["text", "idea", "blog"];
+var CONTENT_TYPES = ["blog", "facebook", "x", "linkedin"];
+var INTERVENTION_LEVELS = [0, 1, 2];
+var PUBLISH_PLATFORMS = [
+  "youtube",
+  "tiktok",
+  "instagram",
+  "facebook",
+  "linkedin",
+  "x",
+  "threads",
+  "pinterest",
+  "reddit",
+  "bluesky",
+  "google_business"
+];
+var MEDIA_SOURCES = {
+  video_url: { media_type: "video", input_kind: "url", field: "video_url" },
+  video_file: { media_type: "video", input_kind: "file", field: "video_file" },
+  audio_url: { media_type: "audio", input_kind: "url", field: "audio_url" },
+  audio_file: { media_type: "audio", input_kind: "file", field: "audio_file" }
+};
+var MEDIA_MAX_DURATION_SECONDS = 120;
+var MEDIA_MAX_FILE_BYTES = 100 * 1024 * 1024;
+var VIDEO_LENGTHS = ["short", "normal"];
+var LANGUAGES = ["English", "Vietnamese"];
+var WidecastError = class extends Error {
+  constructor(message, opts = {}) {
+    super(message);
+    this.name = "WidecastError";
+    this.code = opts.code ?? "";
+    this.requestId = opts.requestId ?? "";
+    this.status = opts.status ?? 0;
+    this.docUrl = opts.docUrl ?? "";
+    this.param = opts.param;
+    this.responseJson = opts.responseJson;
+  }
+};
+var InvalidRequestError = class extends WidecastError {
+  constructor(m, o = {}) {
+    super(m, o);
+    this.name = "InvalidRequestError";
+  }
+};
+var NotFoundError = class extends WidecastError {
+  constructor(m, o = {}) {
+    super(m, o);
+    this.name = "NotFoundError";
+  }
+};
+var PreconditionFailedError = class extends WidecastError {
+  constructor(m, o = {}) {
+    super(m, o);
+    this.name = "PreconditionFailedError";
+  }
+};
+var RateLimitError = class extends WidecastError {
+  constructor(m, o = {}) {
+    super(m, o);
+    this.name = "RateLimitError";
+  }
+};
+var APIError = class extends WidecastError {
+  constructor(m, o = {}) {
+    super(m, o);
+    this.name = "APIError";
+  }
+};
+var ERROR_CLASSES = {
+  invalid_request_error: InvalidRequestError,
+  not_found_error: NotFoundError,
+  precondition_failed: PreconditionFailedError,
+  rate_limit_error: RateLimitError,
+  api_error: APIError,
+  authentication_error: WidecastError,
+  permission_error: WidecastError
+};
+var _client;
+var Video = class {
+  constructor(data, client) {
+    __privateAdd(this, _client);
+    Object.assign(this, data);
+    __privateSet(this, _client, client);
+  }
+  get isTerminal() {
+    return TERMINAL_STATUSES.includes(this.status);
+  }
+  // ── Ergonomic unwrapper for `result` ─────────────────────────────────────
+  /** URL where the user reviews the rendered scenes + audio. Present from the
+   *  first response (pending / processing / completed) — the review page
+   *  handles early arrival itself (spinner + in-page polling), so this is
+   *  safe to share with the user before status='completed'. */
+  get review_url() {
+    return this.result?.review_url ?? null;
+  }
+  /** Direct MP4 URL — present only when status='completed' AND the video was
+   *  created with output_type='video' (or exported via client.export_video). */
+  get video_url() {
+    return this.result?.video_url ?? null;
+  }
+  /** Poll /v1/status until terminal or timeout.
+   *  Default: fixed 5-second polling (no backoff). Override kwargs for
+   *  long-running polls where backoff is preferred. */
+  async wait(opts = {}) {
+    const timeoutMs = opts.timeoutMs ?? 6e5;
+    const maxIntervalMs = opts.maxIntervalMs ?? 5e3;
+    const backoff = opts.backoffMultiplier ?? 1;
+    let interval = opts.initialIntervalMs ?? 5e3;
+    const deadline = Date.now() + timeoutMs;
+    let latest = this;
+    while (!latest.isTerminal && Date.now() < deadline) {
+      const remaining = deadline - Date.now();
+      await sleep(Math.min(interval, Math.max(100, remaining)));
+      latest = await __privateGet(this, _client).get_status(this.id);
+      interval = Math.min(interval * backoff, maxIntervalMs);
+    }
+    return latest;
+  }
+};
+_client = new WeakMap();
+var _fetch, _Widecast_instances, get_fn, request_fn, requestMultipart_fn;
+var Widecast = class {
+  constructor(cfg = {}) {
+    __privateAdd(this, _Widecast_instances);
+    __privateAdd(this, _fetch);
+    this.apiKey = cfg.apiKey ?? (typeof process !== "undefined" ? process.env?.WIDECAST_API_KEY : void 0);
+    this.baseUrl = (cfg.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+    this.timeoutMs = cfg.timeoutMs ?? 6e4;
+    this.maxRetries = cfg.maxRetries ?? 3;
+    this.userAgent = cfg.userAgent ?? `widecast-js/${VERSION}`;
+    __privateSet(this, _fetch, cfg.fetchImpl ?? globalThis.fetch);
+    if (!__privateGet(this, _fetch)) {
+      throw new Error("No fetch implementation found. Pass `fetchImpl` for environments without global fetch.");
+    }
+  }
+  // ── Public methods ──────────────────────────────────────────────────────
+  async create_video(opts) {
+    if (!opts) {
+      throw new InvalidRequestError(
+        "create_video requires options.",
+        { code: "missing_field", param: "options" }
+      );
+    }
+    const source = opts.source ?? "text";
+    if (!SOURCES.includes(source)) {
+      throw new InvalidRequestError(
+        `source must be one of ${JSON.stringify(SOURCES)} (got ${JSON.stringify(opts.source)}).`,
+        { code: "invalid_source", param: "source" }
+      );
+    }
+    const outputType = opts.output_type ?? "scene";
+    if (!OUTPUT_TYPES.includes(outputType)) {
+      throw new InvalidRequestError(
+        `output_type must be one of ${JSON.stringify(OUTPUT_TYPES)} (got ${JSON.stringify(opts.output_type)}).`,
+        { code: "invalid_output_type", param: "output_type" }
+      );
+    }
+    if (outputType === "text" && source === "text") {
+      throw new InvalidRequestError(
+        "output_type='text' requires a generative source (e.g. source='idea'). With source='text' you already supplied the script \u2014 use output_type 'scene' or 'video'.",
+        { code: "invalid_output_type", param: "output_type" }
+      );
+    }
+    const faceless = opts.faceless === true;
+    if (opts.faceless !== void 0 && typeof opts.faceless !== "boolean") {
+      throw new InvalidRequestError(
+        `faceless must be a boolean (got ${JSON.stringify(opts.faceless)}).`,
+        { code: "invalid_faceless", param: "faceless" }
+      );
+    }
+    if (faceless) {
+      if (outputType === "text") {
+        throw new InvalidRequestError(
+          "faceless controls A/B-roll for generated scenes; it has no effect with output_type='text'. Use output_type 'scene' or 'video'.",
+          { code: "invalid_faceless", param: "faceless" }
+        );
+      }
+      if (!FACELESS_SOURCES.includes(source)) {
+        throw new InvalidRequestError(
+          `faceless is only supported for source in ${JSON.stringify(FACELESS_SOURCES)} (got source=${JSON.stringify(source)}).`,
+          { code: "invalid_faceless", param: "faceless" }
+        );
+      }
+    }
+    const body = { source, output_type: outputType };
+    if (faceless) body.faceless = true;
+    if (Array.isArray(opts.media_pool) && opts.media_pool.length) {
+      body.media_pool = opts.media_pool.filter((u) => typeof u === "string" && u.trim());
+    }
+    let uploadField;
+    let uploadFile;
+    if (source === "text") {
+      if (typeof opts.script_text !== "string" || !opts.script_text.trim()) {
+        throw new InvalidRequestError(
+          "script_text (non-empty string) is required when source='text'.",
+          { code: "missing_field", param: "script_text" }
+        );
+      }
+      const wordCount = opts.script_text.trim().split(/\s+/).length;
+      if (wordCount < SCRIPT_MIN_WORDS) {
+        throw new InvalidRequestError(
+          `script_text has ${wordCount} words; minimum is ${SCRIPT_MIN_WORDS} (~20s of narration).`,
+          { code: "script_too_short", param: "script_text" }
+        );
+      }
+      if (wordCount > SCRIPT_MAX_WORDS) {
+        throw new InvalidRequestError(
+          `script_text has ${wordCount} words; maximum is ${SCRIPT_MAX_WORDS} (~120s / 2 min of narration).`,
+          { code: "script_too_long", param: "script_text" }
+        );
+      }
+      body.script_text = opts.script_text;
+    } else if (source === "idea" || source === "blog") {
+      const genSpec = source === "idea" ? {
+        field: "idea_text",
+        value: opts.idea_text,
+        min: IDEA_MIN_WORDS,
+        missingCode: "missing_idea_text",
+        tooShortCode: "idea_too_short"
+      } : {
+        field: "blog_text",
+        value: opts.blog_text,
+        min: BLOG_MIN_WORDS,
+        missingCode: "missing_blog_text",
+        tooShortCode: "blog_too_short"
+      };
+      if (typeof genSpec.value !== "string" || !genSpec.value.trim()) {
+        throw new InvalidRequestError(
+          `${genSpec.field} (non-empty string) is required when source='${source}'.`,
+          { code: genSpec.missingCode, param: genSpec.field }
+        );
+      }
+      const wordCount = genSpec.value.trim().split(/\s+/).length;
+      if (wordCount < genSpec.min) {
+        throw new InvalidRequestError(
+          `${genSpec.field} has ${wordCount} words; minimum is ${genSpec.min}.`,
+          { code: genSpec.tooShortCode, param: genSpec.field }
+        );
+      }
+      const language = opts.language ?? "English";
+      if (!LANGUAGES.includes(language)) {
+        throw new InvalidRequestError(
+          `language must be one of ${JSON.stringify(LANGUAGES)} (got ${JSON.stringify(opts.language)}).`,
+          { code: "invalid_language", param: "language" }
+        );
+      }
+      const videoLength = opts.video_length ?? "short";
+      if (!VIDEO_LENGTHS.includes(videoLength)) {
+        throw new InvalidRequestError(
+          `video_length must be one of ${JSON.stringify(VIDEO_LENGTHS)} (got ${JSON.stringify(opts.video_length)}).`,
+          { code: "invalid_video_length", param: "video_length" }
+        );
+      }
+      const researchEnabled = opts.research_enabled ?? true;
+      if (typeof researchEnabled !== "boolean") {
+        throw new InvalidRequestError(
+          `research_enabled must be a boolean (got ${typeof researchEnabled}).`,
+          { code: "invalid_research_enabled", param: "research_enabled" }
+        );
+      }
+      body[genSpec.field] = genSpec.value;
+      body.language = language;
+      body.video_length = videoLength;
+      body.research_enabled = researchEnabled;
+    } else {
+      const media = MEDIA_SOURCES[source];
+      if (media.input_kind === "url") {
+        const value = source === "video_url" ? opts.video_url : opts.audio_url;
+        if (typeof value !== "string" || !value.trim()) {
+          throw new InvalidRequestError(
+            `${media.field} (a media URL) is required when source='${source}'.`,
+            { code: `missing_${media.field}`, param: media.field }
+          );
+        }
+        body[media.field] = value.trim();
+      } else {
+        const file = source === "video_file" ? opts.video_file : opts.audio_file;
+        if (!file) {
+          throw new InvalidRequestError(
+            `${media.field} (a Blob/File) is required when source='${source}'.`,
+            { code: "missing_media_file", param: media.field }
+          );
+        }
+        if (typeof file.size === "number" && file.size > MEDIA_MAX_FILE_BYTES) {
+          throw new InvalidRequestError(
+            `${media.field} is ${(file.size / 1024 / 1024).toFixed(1)} MB; maximum is ${Math.floor(MEDIA_MAX_FILE_BYTES / (1024 * 1024))} MB.`,
+            { code: "file_too_large", param: media.field }
+          );
+        }
+        uploadField = media.field;
+        uploadFile = file;
+      }
+    }
+    if (opts.wait_for_render) body.wait_for_render = true;
+    if (opts.callback_url) body.callback_url = opts.callback_url;
+    if (opts.metadata) body.metadata = opts.metadata;
+    const idem = opts.idempotency_key ?? randomUuid();
+    let data;
+    if (uploadField) {
+      const form = new FormData();
+      for (const [k, v] of Object.entries(body)) {
+        form.set(k, typeof v === "object" && v !== null ? JSON.stringify(v) : String(v));
+      }
+      form.set(
+        uploadField,
+        uploadFile,
+        uploadFile.name ?? "upload"
+      );
+      data = await __privateMethod(this, _Widecast_instances, requestMultipart_fn).call(this, "/v1/create_video", form, idem);
+    } else {
+      data = await __privateMethod(this, _Widecast_instances, request_fn).call(this, "POST", "/v1/create_video", body, idem);
+    }
+    return new Video(data, this);
+  }
+  /** POST /v1/export_video — kick the final-MP4 renderer for an existing
+   *  scene-output video. Idempotent: calling twice is a no-op.
+   *  Throws `PreconditionFailedError` if scenes are not yet ready. */
+  async export_video(videoId) {
+    if (!videoId || typeof videoId !== "string") {
+      throw new InvalidRequestError("video_id must be a non-empty string.", { code: "invalid_id", param: "video_id" });
+    }
+    const data = await __privateMethod(this, _Widecast_instances, request_fn).call(this, "POST", "/v1/export_video", { id: videoId });
+    return new Video(data, this);
+  }
+  async get_status(videoId) {
+    if (!videoId || typeof videoId !== "string") {
+      throw new InvalidRequestError("video_id must be a non-empty string.", { code: "invalid_id", param: "video_id" });
+    }
+    const data = await __privateMethod(this, _Widecast_instances, request_fn).call(this, "GET", `/v1/status/${videoId}`);
+    return new Video(data, this);
+  }
+  /** POST /v1/create_content — generate written content (blog / social post)
+   *  from a URL, an idea/topic, or pasted text. Async: returns a Video with
+   *  `review_url` (the public content viewer) already populated — safe to
+   *  share before completion; the viewer shows a spinner while content
+   *  generates. Poll with `.wait()` for the final state. */
+  async create_content(opts) {
+    if (!opts || typeof opts.content !== "string" || !opts.content.trim()) {
+      throw new InvalidRequestError(
+        "content (a URL, idea, or text) is required.",
+        { code: "missing_field", param: "content" }
+      );
+    }
+    const contentType = opts.content_type ?? "blog";
+    if (!CONTENT_TYPES.includes(contentType)) {
+      throw new InvalidRequestError(
+        `content_type must be one of ${JSON.stringify(CONTENT_TYPES)} (got ${JSON.stringify(opts.content_type)}).`,
+        { code: "invalid_content_type", param: "content_type" }
+      );
+    }
+    const language = opts.language ?? "English";
+    if (typeof language !== "string" || !language.trim()) {
+      throw new InvalidRequestError(
+        'language (e.g. "English") is required.',
+        { code: "missing_field", param: "language" }
+      );
+    }
+    const body = {
+      content: opts.content.trim(),
+      content_type: contentType,
+      language: language.trim()
+    };
+    if (opts.callback_url) body.callback_url = opts.callback_url;
+    if (opts.metadata) body.metadata = opts.metadata;
+    const data = await __privateMethod(this, _Widecast_instances, request_fn).call(this, "POST", "/v1/create_content", body);
+    return new Video(data, this);
+  }
+  /** POST /v1/enhance_script — improve a DRAFT script with AI. Async: returns
+   *  a Video with `review_url` (the Script Editor) already populated — safe
+   *  to share before completion; the editor shows a spinner while enhancing.
+   *  Poll with `.wait()` for the final enhanced script. */
+  async enhance_script(opts) {
+    if (!opts || typeof opts.script_text !== "string" || !opts.script_text.trim()) {
+      throw new InvalidRequestError(
+        "script_text (the draft to enhance) is required.",
+        { code: "missing_field", param: "script_text" }
+      );
+    }
+    const level = opts.intervention_level ?? 1;
+    if (!INTERVENTION_LEVELS.includes(level)) {
+      throw new InvalidRequestError(
+        `intervention_level must be one of ${JSON.stringify(INTERVENTION_LEVELS)} (got ${JSON.stringify(opts.intervention_level)}).`,
+        { code: "invalid_intervention_level", param: "intervention_level" }
+      );
+    }
+    const body = {
+      script_text: opts.script_text.trim(),
+      intervention_level: level
+    };
+    if (typeof opts.language === "string" && opts.language.trim()) body.language = opts.language.trim();
+    if (opts.callback_url) body.callback_url = opts.callback_url;
+    if (opts.metadata) body.metadata = opts.metadata;
+    const data = await __privateMethod(this, _Widecast_instances, request_fn).call(this, "POST", "/v1/enhance_script", body);
+    return new Video(data, this);
+  }
+  /** POST /v1/suggest_ideas — SYNCHRONOUS. Returns video topic ideas for an
+   *  industry immediately (no polling). `industry_id` falls back to your
+   *  account industry if omitted. Consumes credits. */
+  async suggest_ideas(opts = {}) {
+    const body = { num_topics: opts.num_topics ?? 5 };
+    if (opts.industry_id) body.industry_id = opts.industry_id;
+    if (opts.sub_industry) body.sub_industry = opts.sub_industry;
+    if (opts.user_location) body.user_location = opts.user_location;
+    return await __privateMethod(this, _Widecast_instances, request_fn).call(this, "POST", "/v1/suggest_ideas", body);
+  }
+  /** POST /v1/collect_ideas — SYNCHRONOUS. Returns video ideas derived from a
+   *  product/service description (≥10 chars) immediately. Consumes credits. */
+  async collect_ideas(opts) {
+    if (!opts || typeof opts.product_service_input !== "string" || opts.product_service_input.trim().length < 10) {
+      throw new InvalidRequestError(
+        "product_service_input is required (\u226510 chars).",
+        { code: "missing_field", param: "product_service_input" }
+      );
+    }
+    const body = { product_service_input: opts.product_service_input.trim() };
+    if (opts.sub_industry) body.sub_industry = opts.sub_industry;
+    if (opts.user_location) body.user_location = opts.user_location;
+    return await __privateMethod(this, _Widecast_instances, request_fn).call(this, "POST", "/v1/collect_ideas", body);
+  }
+  /** POST /v1/publish — distribute content to connected social platforms.
+   *  Provide EXACTLY ONE of topic_id / text / video_url. `platforms` defaults
+   *  to ALL connected. Charges 1 credit. Returns the accepted-publish envelope
+   *  (HTTP 202) — publishing is async on the platform side, so poll
+   *  get_status(id) (with any of `request_ids`) for per-platform post URLs. */
+  async publish(opts) {
+    const modes = [opts.topic_id, opts.text, opts.video_url].filter(Boolean);
+    if (modes.length !== 1) {
+      throw new InvalidRequestError(
+        "Provide exactly one of topic_id, text, or video_url.",
+        { code: "invalid_publish_input" }
+      );
+    }
+    if (opts.video_url && !(typeof opts.title === "string" && opts.title.trim())) {
+      throw new InvalidRequestError(
+        "title is required when posting an external video_url.",
+        { code: "missing_field", param: "title" }
+      );
+    }
+    if (opts.platforms !== void 0) {
+      const bad = opts.platforms.filter(
+        (p) => !PUBLISH_PLATFORMS.includes(p)
+      );
+      if (bad.length) {
+        throw new InvalidRequestError(
+          `Unknown platform(s) ${JSON.stringify(bad)}. Valid: ${JSON.stringify(PUBLISH_PLATFORMS)}.`,
+          { code: "invalid_platforms", param: "platforms" }
+        );
+      }
+    }
+    const body = {};
+    if (opts.topic_id) body.topic_id = opts.topic_id.trim();
+    if (opts.text) body.text = opts.text.trim();
+    if (opts.video_url) body.video_url = opts.video_url.trim();
+    if (opts.title) body.title = opts.title.trim();
+    if (opts.description) body.description = opts.description.trim();
+    if (opts.photo_urls) body.photo_urls = opts.photo_urls;
+    if (opts.platforms) body.platforms = opts.platforms;
+    if (opts.scheduled_date) body.scheduled_date = opts.scheduled_date;
+    if (opts.timezone) body.timezone = opts.timezone;
+    if (opts.callback_url) body.callback_url = opts.callback_url;
+    if (opts.metadata) body.metadata = opts.metadata;
+    return await __privateMethod(this, _Widecast_instances, request_fn).call(this, "POST", "/v1/publish", body, opts.idempotency_key);
+  }
+  /** GET /v1/videos — list the account's recent videos (20/page). Free. */
+  async list_videos(opts = {}) {
+    return await __privateMethod(this, _Widecast_instances, get_fn).call(this, "/v1/videos", { from_record: opts.from_record ?? 0 });
+  }
+  /** GET /v1/search — search the account's content by keywords. Free. */
+  async search(query, opts = {}) {
+    if (typeof query !== "string" || !query.trim()) {
+      throw new InvalidRequestError("query is required.", { code: "missing_field", param: "q" });
+    }
+    return await __privateMethod(this, _Widecast_instances, get_fn).call(this, "/v1/search", { q: query.trim(), limit: opts.limit ?? 10 });
+  }
+  /** GET /v1/account — account profile + remaining credits. Free. */
+  async account() {
+    return await __privateMethod(this, _Widecast_instances, get_fn).call(this, "/v1/account");
+  }
+  /** GET /v1/analytics — social analytics dashboard. Free but SLOW. */
+  async analytics(opts = {}) {
+    return await __privateMethod(this, _Widecast_instances, get_fn).call(this, "/v1/analytics", {
+      period: opts.period ?? "last_week",
+      start_date: opts.start_date,
+      end_date: opts.end_date
+    });
+  }
+  /** GET /v1/roadmap — the account's content roadmap. Free. */
+  async roadmap(opts = {}) {
+    return await __privateMethod(this, _Widecast_instances, get_fn).call(this, "/v1/roadmap", { cycle: opts.cycle ?? 1 });
+  }
+  /** GET /v1/production_plan — the weekly production plan. Free.
+   *  NOTE: passing both week_start + week_end may backfill rows upstream. */
+  async production_plan(opts = {}) {
+    return await __privateMethod(this, _Widecast_instances, get_fn).call(this, "/v1/production_plan", {
+      page: opts.page ?? 0,
+      week_start: opts.week_start,
+      week_end: opts.week_end
+    });
+  }
+  /** GET /v1/foundation_videos — curated foundation-video templates. Free. */
+  async foundation_videos(opts = {}) {
+    return await __privateMethod(this, _Widecast_instances, get_fn).call(this, "/v1/foundation_videos", {
+      industry: opts.industry,
+      sub_industry: opts.sub_industry,
+      page: opts.page ?? 0
+    });
+  }
+  /** GET /v1/recommendations — recommended video ideas for an industry. Free. */
+  async recommendations(opts = {}) {
+    return await __privateMethod(this, _Widecast_instances, get_fn).call(this, "/v1/recommendations", {
+      industry: opts.industry,
+      page: opts.page ?? 0
+    });
+  }
+  // ── Connections (Batch E — connect / accounts / configure, free) ────────
+  /** POST /v1/connect — get an OAuth link to connect a social platform. Free.
+   *  Returns `{object:"connect", url, expires_in, ...}` — the USER opens `url`
+   *  to complete the connection on the web (WideCast never performs the OAuth). */
+  async connect(opts = {}) {
+    if (opts.platform && !PUBLISH_PLATFORMS.includes(opts.platform)) {
+      throw new InvalidRequestError(
+        `Unknown platform ${JSON.stringify(opts.platform)}. Valid: ${JSON.stringify(PUBLISH_PLATFORMS)}.`,
+        { code: "invalid_platforms", param: "platform" }
+      );
+    }
+    const body = {};
+    if (opts.platform) body.platform = opts.platform;
+    return await __privateMethod(this, _Widecast_instances, request_fn).call(this, "POST", "/v1/connect", body);
+  }
+  /** GET /v1/accounts — list the account's connected social platforms. Free. */
+  async accounts() {
+    return await __privateMethod(this, _Widecast_instances, get_fn).call(this, "/v1/accounts");
+  }
+  /** GET /v1/platform_settings — load saved per-platform publish settings. Free. */
+  async platform_settings() {
+    return await __privateMethod(this, _Widecast_instances, get_fn).call(this, "/v1/platform_settings");
+  }
+  /** POST /v1/platform_settings — save one platform's publish settings. Free. */
+  async set_platform_settings(platform, settings) {
+    if (!PUBLISH_PLATFORMS.includes(platform)) {
+      throw new InvalidRequestError(
+        `platform must be one of ${JSON.stringify(PUBLISH_PLATFORMS)} (got ${JSON.stringify(platform)}).`,
+        { code: "invalid_platforms", param: "platform" }
+      );
+    }
+    if (!settings || typeof settings !== "object") {
+      throw new InvalidRequestError(
+        "settings (an object) is required.",
+        { code: "missing_field", param: "settings" }
+      );
+    }
+    return await __privateMethod(this, _Widecast_instances, request_fn).call(this, "POST", "/v1/platform_settings", { platform, settings });
+  }
+};
+_fetch = new WeakMap();
+_Widecast_instances = new WeakSet();
+// ── Read / library (Batch C — GET, synchronous, free) ───────────────────
+get_fn = function(path, params) {
+  const qs = new URLSearchParams();
+  for (const [k, v] of Object.entries(params ?? {})) {
+    if (v !== void 0 && v !== null && v !== "") qs.set(k, String(v));
+  }
+  const q = qs.toString();
+  return __privateMethod(this, _Widecast_instances, request_fn).call(this, "GET", q ? `${path}?${q}` : path);
+};
+request_fn = async function(method, path, body, idempotencyKey) {
+  const url = this.baseUrl + path;
+  const headers = {
+    "Accept": "application/json",
+    "User-Agent": this.userAgent,
+    "X-Widecast-Sdk": `js/${VERSION}`
+  };
+  const disableTel = typeof process !== "undefined" && process.env?.WIDECAST_DISABLE_TELEMETRY || "";
+  if (!["1", "true", "yes"].includes(String(disableTel).toLowerCase())) {
+    headers["X-Widecast-Telemetry"] = `sdk=js/${VERSION}`;
+  }
+  if (body !== void 0) headers["Content-Type"] = "application/json";
+  if (this.apiKey) headers["Authorization"] = `Bearer ${this.apiKey}`;
+  if (idempotencyKey) headers["Idempotency-Key"] = idempotencyKey;
+  let lastErr;
+  for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+    const controller = new AbortController();
+    const tid = setTimeout(() => controller.abort(), this.timeoutMs);
+    try {
+      const resp = await __privateGet(this, _fetch).call(this, url, {
+        method,
+        headers,
+        body: body === void 0 ? void 0 : JSON.stringify(body),
+        signal: controller.signal
+      });
+      clearTimeout(tid);
+      if ((resp.status >= 500 || resp.status === 429) && attempt < this.maxRetries) {
+        const wait = resp.status === 429 ? Number(resp.headers.get("Retry-After") ?? 2) * 1e3 : backoffMs(attempt);
+        await sleep(wait);
+        continue;
+      }
+      return await decodeResponse(resp);
+    } catch (e) {
+      clearTimeout(tid);
+      lastErr = e;
+      if (e instanceof WidecastError) throw e;
+      if (attempt >= this.maxRetries) {
+        throw new APIError(`Network error after ${attempt + 1} attempts: ${String(e)}`);
+      }
+      await sleep(backoffMs(attempt));
+    }
+  }
+  throw new APIError(`Exhausted retries: ${String(lastErr)}`);
+};
+requestMultipart_fn = async function(path, form, idempotencyKey) {
+  const url = this.baseUrl + path;
+  const headers = {
+    "Accept": "application/json",
+    "User-Agent": this.userAgent,
+    "X-Widecast-Sdk": `js/${VERSION}`
+  };
+  const disableTel = typeof process !== "undefined" && process.env?.WIDECAST_DISABLE_TELEMETRY || "";
+  if (!["1", "true", "yes"].includes(String(disableTel).toLowerCase())) {
+    headers["X-Widecast-Telemetry"] = `sdk=js/${VERSION}`;
+  }
+  if (this.apiKey) headers["Authorization"] = `Bearer ${this.apiKey}`;
+  if (idempotencyKey) headers["Idempotency-Key"] = idempotencyKey;
+  const controller = new AbortController();
+  const tid = setTimeout(() => controller.abort(), this.timeoutMs);
+  try {
+    const resp = await __privateGet(this, _fetch).call(this, url, { method: "POST", headers, body: form, signal: controller.signal });
+    clearTimeout(tid);
+    return await decodeResponse(resp);
+  } catch (e) {
+    clearTimeout(tid);
+    if (e instanceof WidecastError) throw e;
+    throw new APIError(`Network error during upload: ${String(e)}`);
+  }
+};
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+function backoffMs(attempt) {
+  const base = Math.min(500 * 2 ** attempt, 8e3);
+  return base + Math.random() * 250;
+}
+function randomUuid() {
+  if (typeof crypto !== "undefined" && crypto.randomUUID) {
+    return crypto.randomUUID();
+  }
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    return (c === "x" ? r : r & 3 | 8).toString(16);
+  });
+}
+async function decodeResponse(resp) {
+  const requestId = resp.headers.get("X-Request-Id") ?? "";
+  let data = null;
+  try {
+    data = await resp.json();
+  } catch (_) {
+    data = null;
+  }
+  if (resp.ok) return data;
+  const err = data?.error ?? {};
+  const ErrClass = ERROR_CLASSES[err.type ?? "api_error"] ?? WidecastError;
+  throw new ErrClass(err.message ?? `HTTP ${resp.status}`, {
+    code: err.code ?? "",
+    requestId: err.request_id ?? requestId,
+    status: resp.status,
+    docUrl: err.doc_url ?? "",
+    param: err.param,
+    responseJson: data
+  });
+}
+var WebhookVerificationError = class extends Error {
+  constructor(m) {
+    super(m);
+    this.name = "WebhookVerificationError";
+  }
+};
+async function verifyWebhook(opts) {
+  const { body, signatureHeader, secret } = opts;
+  const tolerance = opts.toleranceSeconds ?? 300;
+  if (!signatureHeader) throw new WebhookVerificationError("missing X-WideCast-Signature header");
+  const parts = {};
+  for (const piece of signatureHeader.split(",")) {
+    const [k, v] = piece.split("=", 2);
+    if (k && v !== void 0) parts[k.trim()] = v;
+  }
+  const ts = parts["t"];
+  const sig = parts["v1"];
+  if (!ts || !sig) throw new WebhookVerificationError("signature header missing t= or v1=");
+  const tsInt = Number(ts);
+  if (!Number.isFinite(tsInt)) throw new WebhookVerificationError("t= is not an integer");
+  if (Math.abs(Date.now() / 1e3 - tsInt) > tolerance) {
+    throw new WebhookVerificationError(
+      `signature timestamp outside tolerance window (${tolerance}s) \u2014 possible replay`
+    );
+  }
+  const signed = `${ts}.${body}`;
+  const expected = await hmacSha256Hex(secret, signed);
+  if (!timingSafeEqual(expected, sig)) throw new WebhookVerificationError("signature mismatch");
+  try {
+    return JSON.parse(body);
+  } catch (e) {
+    throw new WebhookVerificationError(`body is not valid JSON: ${e?.message}`);
+  }
+}
+async function hmacSha256Hex(secret, msg) {
+  const enc = new TextEncoder();
+  const subtle = globalThis.crypto && globalThis.crypto.subtle || null;
+  if (subtle) {
+    const key = await subtle.importKey(
+      "raw",
+      enc.encode(secret),
+      { name: "HMAC", hash: "SHA-256" },
+      false,
+      ["sign"]
+    );
+    const buf = await subtle.sign("HMAC", key, enc.encode(msg));
+    return Array.from(new Uint8Array(buf)).map((b) => b.toString(16).padStart(2, "0")).join("");
+  }
+  const cryptoMod = await import("crypto");
+  return cryptoMod.createHmac("sha256", secret).update(msg).digest("hex");
+}
+function timingSafeEqual(a, b) {
+  if (a.length !== b.length) return false;
+  let diff = 0;
+  for (let i = 0; i < a.length; i++) diff |= a.charCodeAt(i) ^ b.charCodeAt(i);
+  return diff === 0;
+}
+var index_default = Widecast;
+export {
+  APIError,
+  BLOG_MAX_WORDS,
+  BLOG_MIN_WORDS,
+  CONTENT_TYPES,
+  FACELESS_SOURCES,
+  IDEA_MAX_WORDS,
+  IDEA_MIN_WORDS,
+  INTERVENTION_LEVELS,
+  InvalidRequestError,
+  LANGUAGES,
+  MEDIA_MAX_DURATION_SECONDS,
+  MEDIA_MAX_FILE_BYTES,
+  MEDIA_SOURCES,
+  NotFoundError,
+  OUTPUT_TYPES,
+  PUBLISH_PLATFORMS,
+  PreconditionFailedError,
+  RateLimitError,
+  SCRIPT_MAX_WORDS,
+  SCRIPT_MIN_WORDS,
+  SOURCES,
+  VERSION,
+  VIDEO_LENGTHS,
+  Video,
+  WebhookVerificationError,
+  Widecast,
+  WidecastError,
+  index_default as default,
+  verifyWebhook
+};