tredi-sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,890 @@
+// src/constants.ts
+var DEFAULT_BASE_URL = "https://graph.threads.net";
+var AUTHORIZATION_BASE_URL = "https://threads.net";
+var DEFAULT_API_VERSION = "v1.0";
+var DEFAULT_TIMEOUT_MS = 3e4;
+var DEFAULT_RETRY = {
+  maxRetries: 2,
+  initialDelayMs: 500,
+  maxDelayMs: 8e3,
+  backoffFactor: 2
+};
+var RATE_LIMIT_ERROR_CODES = /* @__PURE__ */ new Set([4, 17, 32, 613]);
+var INVALID_TOKEN_ERROR_CODE = 190;
+var THREADS_SCOPES = [
+  "threads_basic",
+  "threads_content_publish",
+  "threads_read_replies",
+  "threads_manage_replies",
+  "threads_manage_insights",
+  "threads_keyword_search",
+  "threads_delete",
+  "threads_location_tagging"
+];
+
+// src/errors.ts
+var ThreadsError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = new.target.name;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var ThreadsValidationError = class extends ThreadsError {
+};
+var ThreadsTimeoutError = class extends ThreadsError {
+};
+var ThreadsNetworkError = class extends ThreadsError {
+};
+var ThreadsAPIError = class extends ThreadsError {
+  status;
+  code;
+  subcode;
+  type;
+  fbtraceId;
+  constructor(details, options) {
+    super(details.message, options);
+    this.status = details.status;
+    this.code = details.code;
+    this.subcode = details.subcode;
+    this.type = details.type;
+    this.fbtraceId = details.fbtraceId;
+  }
+};
+var ThreadsAuthError = class extends ThreadsAPIError {
+};
+var ThreadsRateLimitError = class extends ThreadsAPIError {
+  retryAfterMs;
+  constructor(details, options) {
+    super(details, options);
+    this.retryAfterMs = details.retryAfterMs;
+  }
+};
+function parseRetryAfterMs(value) {
+  if (!value) return void 0;
+  const seconds = Number(value);
+  if (Number.isFinite(seconds)) return Math.max(0, seconds * 1e3);
+  const date = Date.parse(value);
+  if (Number.isNaN(date)) return void 0;
+  return Math.max(0, date - Date.now());
+}
+function toApiError(status, body, headers) {
+  const error = body?.error;
+  const details = {
+    message: error?.message ?? `Threads API request failed with HTTP ${status}`,
+    status,
+    code: error?.code,
+    subcode: error?.error_subcode,
+    type: error?.type,
+    fbtraceId: error?.fbtrace_id
+  };
+  if (status === 401 || details.code === INVALID_TOKEN_ERROR_CODE) {
+    return new ThreadsAuthError(details);
+  }
+  if (status === 429 || details.code != null && RATE_LIMIT_ERROR_CODES.has(details.code)) {
+    return new ThreadsRateLimitError({
+      ...details,
+      retryAfterMs: parseRetryAfterMs(headers?.get("retry-after") ?? null)
+    });
+  }
+  return new ThreadsAPIError(details);
+}
+
+// src/logger.ts
+var noopLogger = { log() {
+} };
+var SENSITIVE_KEYS = /* @__PURE__ */ new Set([
+  "access_token",
+  "client_secret",
+  "code"
+]);
+var REDACTED = "REDACTED";
+function redactParams(params) {
+  if (!params) return {};
+  const out = {};
+  for (const [key, value] of Object.entries(params)) {
+    out[key] = SENSITIVE_KEYS.has(key) ? REDACTED : value;
+  }
+  return out;
+}
+function redactUrl(url) {
+  try {
+    const parsed = new URL(url);
+    for (const key of SENSITIVE_KEYS) {
+      if (parsed.searchParams.has(key)) parsed.searchParams.set(key, REDACTED);
+    }
+    return parsed.toString();
+  } catch {
+    return url.replace(
+      /(access_token|client_secret|code)=[^&\s]+/gi,
+      `$1=${REDACTED}`
+    );
+  }
+}
+
+// src/http.ts
+function buildQuery(params) {
+  const query = new URLSearchParams();
+  for (const [key, value] of Object.entries(params)) {
+    if (value === void 0 || value === null) continue;
+    if (Array.isArray(value) || typeof value === "object" && !(value instanceof Date)) {
+      query.set(key, JSON.stringify(value));
+    } else if (value instanceof Date) {
+      query.set(key, String(Math.floor(value.getTime() / 1e3)));
+    } else {
+      query.set(key, String(value));
+    }
+  }
+  return query;
+}
+function appendQuery(url, query) {
+  const qs = query.toString();
+  if (!qs) return url;
+  return url.includes("?") ? `${url}&${qs}` : `${url}?${qs}`;
+}
+function isRetryable(method, error) {
+  if (error instanceof ThreadsRateLimitError) return true;
+  if (error instanceof ThreadsNetworkError) return true;
+  if (error instanceof ThreadsTimeoutError) return method === "GET";
+  if (error instanceof ThreadsAPIError) {
+    return method === "GET" && error.status != null && error.status >= 500;
+  }
+  return false;
+}
+function backoffDelayMs(attempt, config, retryAfterMs) {
+  if (retryAfterMs != null) return Math.min(retryAfterMs, config.maxDelayMs);
+  const exponential = config.initialDelayMs * config.backoffFactor ** attempt;
+  const capped = Math.min(exponential, config.maxDelayMs);
+  return capped / 2 + Math.random() * (capped / 2);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function safeJsonParse(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+}
+async function sendOnce(req) {
+  const { method, url, params = {}, accessToken, timeoutMs, fetchImpl, signal } = req;
+  const controller = new AbortController();
+  let timedOut = false;
+  const onExternalAbort = () => controller.abort();
+  if (signal) {
+    if (signal.aborted) controller.abort();
+    else signal.addEventListener("abort", onExternalAbort, { once: true });
+  }
+  const timer = setTimeout(() => {
+    timedOut = true;
+    controller.abort();
+  }, timeoutMs);
+  try {
+    const withToken = accessToken ? { ...params, access_token: accessToken } : params;
+    let finalUrl = url;
+    const init = { method, signal: controller.signal };
+    if (method === "GET" || method === "DELETE") {
+      finalUrl = appendQuery(url, buildQuery(withToken));
+    } else {
+      init.body = buildQuery(withToken);
+      init.headers = { "content-type": "application/x-www-form-urlencoded" };
+    }
+    let response;
+    try {
+      response = await fetchImpl(finalUrl, init);
+    } catch (cause) {
+      if (controller.signal.aborted && timedOut) {
+        throw new ThreadsTimeoutError(
+          `Threads API request timed out after ${timeoutMs}ms`,
+          { cause }
+        );
+      }
+      throw new ThreadsNetworkError("Threads API request failed at the network layer", {
+        cause
+      });
+    }
+    const text = await response.text();
+    const body = text ? safeJsonParse(text) : void 0;
+    if (!response.ok) throw toApiError(response.status, body, response.headers);
+    return body;
+  } finally {
+    clearTimeout(timer);
+    if (signal) signal.removeEventListener("abort", onExternalAbort);
+  }
+}
+function assertCleanUrl(url) {
+  if (/[?#\s]/.test(url)) {
+    throw new ThreadsValidationError(
+      `Invalid request URL "${url}" \u2014 it contains "?", "#", or whitespace before query params were added. This usually means an unvalidated id (e.g. from a webhook payload) was interpolated into a resource path. Validate ids before passing them to the SDK.`
+    );
+  }
+}
+async function send(req) {
+  assertCleanUrl(req.url);
+  const logger = req.logger ?? noopLogger;
+  const retryConfig = req.retry === false ? { ...DEFAULT_RETRY, maxRetries: 0 } : req.retry;
+  let attempt = 0;
+  for (; ; ) {
+    const startedAt = Date.now();
+    try {
+      const result = await sendOnce(req);
+      logger.log("debug", "threads.request.success", {
+        method: req.method,
+        url: redactUrl(req.url),
+        attempt,
+        durationMs: Date.now() - startedAt
+      });
+      return result;
+    } catch (error) {
+      const willRetry = isRetryable(req.method, error) && attempt < retryConfig.maxRetries && !req.signal?.aborted;
+      logger.log(willRetry ? "warn" : "error", "threads.request.failure", {
+        method: req.method,
+        url: redactUrl(req.url),
+        attempt,
+        durationMs: Date.now() - startedAt,
+        willRetry,
+        error: error instanceof Error ? error.name : "Unknown"
+      });
+      if (!willRetry) throw error;
+      const retryAfterMs = error instanceof ThreadsRateLimitError ? error.retryAfterMs : void 0;
+      await sleep(backoffDelayMs(attempt, retryConfig, retryAfterMs));
+      attempt += 1;
+    }
+  }
+}
+
+// src/resources/base.ts
+function fieldsParam(fields) {
+  return fields && fields.length > 0 ? fields.join(",") : void 0;
+}
+
+// src/resources/insights.ts
+var DEFAULT_MEDIA_METRICS = [
+  "views",
+  "likes",
+  "replies",
+  "reposts",
+  "quotes",
+  "shares"
+];
+var InsightsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /**
+   * Returns engagement metrics for a single post.
+   * Requires the `threads_manage_insights` permission.
+   */
+  media(mediaId, options = {}) {
+    const metrics = options.metrics ?? DEFAULT_MEDIA_METRICS;
+    return this.client.request({
+      method: "GET",
+      path: `/${mediaId}/insights`,
+      params: { metric: metrics.join(",") },
+      signal: options.signal
+    });
+  }
+  /**
+   * Returns account-level metrics for a user.
+   * Requires the `threads_manage_insights` permission.
+   */
+  user(options = {}) {
+    const node = options.userId ?? this.client.userNode;
+    const metrics = options.metrics ?? ["views", "followers_count"];
+    return this.client.request({
+      method: "GET",
+      path: `/${node}/threads_insights`,
+      params: {
+        metric: metrics.join(","),
+        since: options.since,
+        until: options.until,
+        breakdown: options.breakdown
+      },
+      signal: options.signal
+    });
+  }
+};
+
+// src/resources/mentions.ts
+var DEFAULT_MENTION_FIELDS = [
+  "id",
+  "username",
+  "text",
+  "timestamp",
+  "permalink",
+  "media_type"
+];
+var MentionsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /**
+   * Lists posts that mention the user. Requires the mentions permission in
+   * addition to `threads_basic`.
+   */
+  list(options = {}) {
+    const node = options.userId ?? this.client.userNode;
+    return this.client.request({
+      method: "GET",
+      path: `/${node}/mentions`,
+      params: {
+        fields: fieldsParam(options.fields ?? DEFAULT_MENTION_FIELDS),
+        since: options.since,
+        until: options.until,
+        limit: options.limit,
+        before: options.before,
+        after: options.after
+      },
+      signal: options.signal
+    });
+  }
+};
+
+// src/resources/posts.ts
+var DEFAULT_MEDIA_FIELDS = [
+  "id",
+  "media_product_type",
+  "media_type",
+  "media_url",
+  "permalink",
+  "username",
+  "text",
+  "timestamp",
+  "shortcode",
+  "thumbnail_url",
+  "is_quote_post"
+];
+var PostsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /**
+   * Lists a user's posts, most recent first. Cursor-paginated.
+   * Requires the `threads_basic` permission.
+   */
+  list(options = {}) {
+    const node = options.userId ?? this.client.userNode;
+    return this.client.request({
+      method: "GET",
+      path: `/${node}/threads`,
+      params: {
+        fields: fieldsParam(options.fields ?? DEFAULT_MEDIA_FIELDS),
+        since: options.since,
+        until: options.until,
+        limit: options.limit,
+        before: options.before,
+        after: options.after
+      },
+      signal: options.signal
+    });
+  }
+  /**
+   * Reads a single media object (post or reply) by id.
+   * Requires the `threads_basic` permission.
+   */
+  get(mediaId, options = {}) {
+    return this.client.request({
+      method: "GET",
+      path: `/${mediaId}`,
+      params: { fields: fieldsParam(options.fields ?? DEFAULT_MEDIA_FIELDS) },
+      signal: options.signal
+    });
+  }
+};
+
+// src/resources/profile.ts
+var DEFAULT_PROFILE_FIELDS = [
+  "id",
+  "username",
+  "name",
+  "threads_profile_picture_url",
+  "threads_biography",
+  "is_verified"
+];
+var ProfileResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /**
+   * Returns profile information for a Threads user.
+   * Requires the `threads_basic` permission.
+   */
+  get(options = {}) {
+    const node = options.userId ?? this.client.userNode;
+    return this.client.request({
+      method: "GET",
+      path: `/${node}`,
+      params: { fields: fieldsParam(options.fields ?? DEFAULT_PROFILE_FIELDS) },
+      signal: options.signal
+    });
+  }
+};
+
+// src/resources/publishing.ts
+function sleep2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+var PublishingResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /** Step 1: create a media container. Returns its creation id. */
+  createContainer(input) {
+    const node = input.userId ?? this.client.userNode;
+    return this.client.request({
+      method: "POST",
+      path: `/${node}/threads`,
+      params: {
+        media_type: input.mediaType,
+        text: input.text,
+        image_url: input.imageUrl,
+        video_url: input.videoUrl,
+        is_carousel_item: input.isCarouselItem,
+        // The API expects a comma-separated list, not a JSON array.
+        children: input.children?.join(","),
+        reply_to_id: input.replyToId,
+        reply_control: input.replyControl,
+        alt_text: input.altText,
+        link_attachment: input.linkAttachment,
+        location_id: input.locationId,
+        quote_post_id: input.quotePostId,
+        topic_tag: input.topicTag,
+        // The API expects a JSON object string with snake_case option keys.
+        poll_attachment: input.pollAttachment ? JSON.stringify({
+          option_a: input.pollAttachment.optionA,
+          option_b: input.pollAttachment.optionB,
+          option_c: input.pollAttachment.optionC,
+          option_d: input.pollAttachment.optionD
+        }) : void 0
+      },
+      signal: input.signal
+    });
+  }
+  /** Step 2: publish a previously created container. Returns the post id. */
+  publishContainer(creationId, options = {}) {
+    const node = options.userId ?? this.client.userNode;
+    return this.client.request({
+      method: "POST",
+      path: `/${node}/threads_publish`,
+      params: { creation_id: creationId },
+      signal: options.signal
+    });
+  }
+  /** Reads a container's processing status. */
+  getContainerStatus(containerId, options = {}) {
+    return this.client.request({
+      method: "GET",
+      path: `/${containerId}`,
+      params: { fields: fieldsParam(["id", "status", "error_message"]) },
+      signal: options.signal
+    });
+  }
+  /**
+   * Creates a container, optionally waits for media processing, then publishes.
+   * `waitForReady` defaults to `true` for `VIDEO`/`CAROUSEL` (which need
+   * server-side processing) and `false` otherwise.
+   */
+  async createAndPublish(input, wait = {}) {
+    const { id: creationId } = await this.createContainer(input);
+    const shouldWait = wait.waitForReady ?? (input.mediaType === "VIDEO" || input.mediaType === "CAROUSEL");
+    if (shouldWait) {
+      await this.waitForContainer(creationId, wait, input.signal);
+    }
+    return this.publishContainer(creationId, {
+      userId: input.userId,
+      signal: input.signal
+    });
+  }
+  /** Convenience: publish a text-only post. */
+  publishText(text, options = {}) {
+    return this.createAndPublish({ ...options, mediaType: "TEXT", text });
+  }
+  /** Convenience: publish a text post with a poll (2–4 options). */
+  publishPoll(text, poll, options = {}) {
+    return this.createAndPublish({ ...options, mediaType: "TEXT", text, pollAttachment: poll });
+  }
+  /** Delete a published post. Requires the `threads_delete` scope. */
+  deletePost(postId, options = {}) {
+    return this.client.request({
+      method: "DELETE",
+      path: `/${postId}`,
+      signal: options.signal
+    });
+  }
+  /** Convenience: publish a single image post. */
+  publishImage(input) {
+    return this.createAndPublish({ ...input, mediaType: "IMAGE" });
+  }
+  /** Convenience: publish a single video post (waits for processing). */
+  publishVideo(input) {
+    return this.createAndPublish({ ...input, mediaType: "VIDEO" });
+  }
+  /**
+   * Convenience: publish a carousel. Each item becomes a child container, then
+   * a parent `CAROUSEL` container is created and published.
+   */
+  async publishCarousel(input) {
+    if (input.items.length < 2) {
+      throw new ThreadsError("A carousel requires at least 2 items.");
+    }
+    const children = await Promise.all(
+      input.items.map(
+        (item) => this.createContainer({
+          mediaType: item.videoUrl ? "VIDEO" : "IMAGE",
+          imageUrl: item.imageUrl,
+          videoUrl: item.videoUrl,
+          altText: item.altText,
+          isCarouselItem: true,
+          userId: input.userId,
+          signal: input.signal
+        }).then((ref) => ref.id)
+      )
+    );
+    return this.createAndPublish(
+      {
+        mediaType: "CAROUSEL",
+        children,
+        text: input.text,
+        replyControl: input.replyControl,
+        userId: input.userId,
+        signal: input.signal
+      },
+      input.wait ?? {}
+    );
+  }
+  /** Reads remaining publish/reply/delete quotas for the user. */
+  getPublishingLimit(options = {}) {
+    const node = options.userId ?? this.client.userNode;
+    return this.client.request({
+      method: "GET",
+      path: `/${node}/threads_publishing_limit`,
+      params: {
+        fields: fieldsParam([
+          "quota_usage",
+          "config",
+          "reply_quota_usage",
+          "reply_config",
+          "delete_quota_usage",
+          "delete_config"
+        ])
+      },
+      signal: options.signal
+    });
+  }
+  /** Polls a container until it is ready to publish, or throws on failure. */
+  async waitForContainer(containerId, wait, signal) {
+    const pollIntervalMs = wait.pollIntervalMs ?? 2e3;
+    const maxWaitMs = wait.maxWaitMs ?? 6e4;
+    const deadline = Date.now() + maxWaitMs;
+    for (; ; ) {
+      const { status, error_message } = await this.getContainerStatus(containerId, { signal });
+      if (status === "FINISHED" || status === "PUBLISHED") return;
+      if (status === "ERROR" || status === "EXPIRED") {
+        throw new ThreadsError(
+          `Container ${containerId} failed to process: ${status}${error_message ? ` (${error_message})` : ""}`
+        );
+      }
+      if (Date.now() + pollIntervalMs > deadline) {
+        throw new ThreadsError(
+          `Container ${containerId} not ready after ${maxWaitMs}ms (status: ${status}).`
+        );
+      }
+      await sleep2(pollIntervalMs);
+    }
+  }
+};
+
+// src/resources/replies.ts
+var DEFAULT_REPLY_FIELDS = [
+  "id",
+  "text",
+  "username",
+  "timestamp",
+  "media_type",
+  "permalink",
+  "has_replies",
+  "is_reply",
+  "hide_status"
+];
+var RepliesResource = class {
+  constructor(client, publishing) {
+    this.client = client;
+    this.publishing = publishing;
+  }
+  client;
+  publishing;
+  /**
+   * Lists the top-level replies to a post.
+   * Requires `threads_read_replies` (or `threads_manage_replies`).
+   */
+  list(mediaId, options = {}) {
+    return this.client.request({
+      method: "GET",
+      path: `/${mediaId}/replies`,
+      params: {
+        fields: fieldsParam(options.fields ?? DEFAULT_REPLY_FIELDS),
+        reverse: options.reverse
+      },
+      signal: options.signal
+    });
+  }
+  /**
+   * Lists the full conversation (all nested replies) under a post.
+   * Requires `threads_read_replies` (or `threads_manage_replies`).
+   */
+  conversation(mediaId, options = {}) {
+    return this.client.request({
+      method: "GET",
+      path: `/${mediaId}/conversation`,
+      params: {
+        fields: fieldsParam(options.fields ?? DEFAULT_REPLY_FIELDS),
+        reverse: options.reverse
+      },
+      signal: options.signal
+    });
+  }
+  /**
+   * Publishes a reply to an existing post. Requires `threads_content_publish`
+   * (and `threads_manage_replies` for replies you don't own).
+   */
+  publish(replyToId, text, options = {}) {
+    return this.publishing.publishText(text, { replyToId, ...options });
+  }
+  /** Hides a reply. Requires `threads_manage_replies`. */
+  hide(replyId, options = {}) {
+    return this.setHidden(replyId, true, options);
+  }
+  /** Unhides a previously hidden reply. Requires `threads_manage_replies`. */
+  unhide(replyId, options = {}) {
+    return this.setHidden(replyId, false, options);
+  }
+  /**
+   * Lists replies awaiting approval (when reply approvals are enabled).
+   * Requires `threads_manage_replies`.
+   */
+  listPending(mediaId, options = {}) {
+    return this.client.request({
+      method: "GET",
+      path: `/${mediaId}/pending_replies`,
+      params: {
+        fields: fieldsParam(options.fields ?? DEFAULT_REPLY_FIELDS),
+        reverse: options.reverse,
+        approval_status: options.approvalStatus
+      },
+      signal: options.signal
+    });
+  }
+  /**
+   * Approves or rejects a pending reply. Requires `threads_manage_replies`.
+   */
+  managePending(replyId, approve, options = {}) {
+    return this.client.request({
+      method: "POST",
+      path: `/${replyId}/manage_pending_reply`,
+      params: { approve },
+      signal: options.signal
+    });
+  }
+  setHidden(replyId, hide, options) {
+    return this.client.request({
+      method: "POST",
+      path: `/${replyId}/manage_reply`,
+      params: { hide },
+      signal: options.signal
+    });
+  }
+};
+
+// src/resources/search.ts
+var DEFAULT_SEARCH_FIELDS = [
+  "id",
+  "username",
+  "text",
+  "timestamp",
+  "permalink",
+  "media_type",
+  "has_replies",
+  "is_quote_post",
+  "is_reply"
+];
+var SearchResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /**
+   * Searches public Threads posts by keyword or tag. The `owner` field is never
+   * returned for search results. Requires the `threads_keyword_search`
+   * permission (plus `threads_basic`).
+   */
+  keyword(query, options = {}) {
+    return this.client.request({
+      method: "GET",
+      path: "/keyword_search",
+      params: {
+        q: query,
+        search_type: options.searchType,
+        search_mode: options.searchMode,
+        media_type: options.mediaType,
+        since: options.since,
+        until: options.until,
+        limit: options.limit,
+        author_username: options.authorUsername,
+        fields: fieldsParam(options.fields ?? DEFAULT_SEARCH_FIELDS)
+      },
+      signal: options.signal
+    });
+  }
+};
+
+// src/client.ts
+function resolveConfig(config) {
+  if (!config.accessToken) {
+    throw new ThreadsValidationError("`accessToken` is required to create a ThreadsClient.");
+  }
+  const fetchImpl = config.fetch ?? globalThis.fetch;
+  if (!fetchImpl) {
+    throw new ThreadsValidationError(
+      "No fetch implementation available. Pass `fetch` or run on Node 18+ / a runtime with global fetch."
+    );
+  }
+  return {
+    accessToken: config.accessToken,
+    userId: config.userId ?? "me",
+    baseUrl: (config.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, ""),
+    version: config.version ?? DEFAULT_API_VERSION,
+    timeoutMs: config.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+    retry: config.retry === false ? false : { ...DEFAULT_RETRY, ...config.retry },
+    logger: config.logger ?? noopLogger,
+    fetch: fetchImpl
+  };
+}
+var ThreadsClient = class _ThreadsClient {
+  profile;
+  posts;
+  publishing;
+  replies;
+  insights;
+  mentions;
+  search;
+  config;
+  constructor(config) {
+    this.config = resolveConfig(config);
+    this.profile = new ProfileResource(this);
+    this.posts = new PostsResource(this);
+    this.publishing = new PublishingResource(this);
+    this.replies = new RepliesResource(this, this.publishing);
+    this.insights = new InsightsResource(this);
+    this.mentions = new MentionsResource(this);
+    this.search = new SearchResource(this);
+  }
+  /** Default node id for user-scoped endpoints. */
+  get userNode() {
+    return this.config.userId;
+  }
+  /**
+   * Low-level escape hatch: issue a request to any Threads endpoint with full
+   * typing of the response. Prefer the resource methods; use this for endpoints
+   * the SDK doesn't model yet.
+   */
+  request(req) {
+    return send({
+      method: req.method,
+      url: `${this.config.baseUrl}/${this.config.version}${req.path}`,
+      params: req.params,
+      accessToken: this.config.accessToken,
+      timeoutMs: this.config.timeoutMs,
+      retry: this.config.retry,
+      logger: this.config.logger,
+      fetchImpl: this.config.fetch,
+      signal: req.signal
+    });
+  }
+  /** Returns a new client that shares this config but uses a different token. */
+  withToken(accessToken) {
+    return new _ThreadsClient({ ...this.config, accessToken });
+  }
+};
+
+// src/oauth.ts
+function resolveFetch(fetchImpl) {
+  const impl = fetchImpl ?? globalThis.fetch;
+  if (!impl) {
+    throw new ThreadsValidationError(
+      "No fetch implementation available. Pass `fetch` explicitly or run on a runtime with global fetch (Node 18+)."
+    );
+  }
+  return impl;
+}
+function getAuthorizationUrl(options) {
+  if (options.scopes.length === 0) {
+    throw new ThreadsValidationError("At least one scope is required (threads_basic).");
+  }
+  const base = options.baseUrl ?? AUTHORIZATION_BASE_URL;
+  const query = buildQuery({
+    client_id: options.clientId,
+    redirect_uri: options.redirectUri,
+    response_type: "code",
+    scope: options.scopes.join(","),
+    state: options.state
+  });
+  return `${base}/oauth/authorize?${query.toString()}`;
+}
+async function exchangeCodeForToken(options) {
+  const base = options.baseUrl ?? DEFAULT_BASE_URL;
+  return send({
+    method: "POST",
+    url: `${base}/oauth/access_token`,
+    params: {
+      client_id: options.clientId,
+      client_secret: options.clientSecret,
+      grant_type: "authorization_code",
+      redirect_uri: options.redirectUri,
+      code: options.code
+    },
+    timeoutMs: options.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+    retry: false,
+    // code is single-use; never replay it
+    logger: options.logger,
+    fetchImpl: resolveFetch(options.fetch)
+  });
+}
+async function exchangeForLongLivedToken(options) {
+  const base = options.baseUrl ?? DEFAULT_BASE_URL;
+  return send({
+    method: "GET",
+    url: `${base}/access_token`,
+    params: {
+      grant_type: "th_exchange_token",
+      client_secret: options.clientSecret
+    },
+    accessToken: options.shortLivedToken,
+    timeoutMs: options.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+    retry: false,
+    logger: options.logger,
+    fetchImpl: resolveFetch(options.fetch)
+  });
+}
+async function refreshLongLivedToken(options) {
+  const base = options.baseUrl ?? DEFAULT_BASE_URL;
+  return send({
+    method: "GET",
+    url: `${base}/refresh_access_token`,
+    params: { grant_type: "th_refresh_token" },
+    accessToken: options.longLivedToken,
+    timeoutMs: options.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+    retry: false,
+    logger: options.logger,
+    fetchImpl: resolveFetch(options.fetch)
+  });
+}
+
+export { AUTHORIZATION_BASE_URL, DEFAULT_API_VERSION, DEFAULT_BASE_URL, THREADS_SCOPES, ThreadsAPIError, ThreadsAuthError, ThreadsClient, ThreadsError, ThreadsNetworkError, ThreadsRateLimitError, ThreadsTimeoutError, ThreadsValidationError, exchangeCodeForToken, exchangeForLongLivedToken, getAuthorizationUrl, noopLogger, parseRetryAfterMs, redactParams, redactUrl, refreshLongLivedToken, toApiError };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map