x-relay-mcp 1.0.0

package/dist/index.js

@@ -0,0 +1,1977 @@
+// src/output.ts
+function ok(command, data) {
+  return { ok: true, command, data };
+}
+function err(command, code, message, hint) {
+  const error = hint !== void 0 ? { code, message, hint } : { code, message };
+  return { ok: false, command, error };
+}
+function toJson(envelope) {
+  return JSON.stringify(envelope, null, 2);
+}
+
+// src/ids.ts
+var BARE_TWEET_ID_RE = /^\d{6,20}$/;
+var PATH_TWEET_ID_RE = /^\d{1,20}$/;
+var HANDLE_RE = /^[A-Za-z0-9_]{1,15}$/;
+var X_HOSTS = /* @__PURE__ */ new Set([
+  "x.com",
+  "www.x.com",
+  "twitter.com",
+  "www.twitter.com",
+  "mobile.twitter.com",
+  "mobile.x.com"
+]);
+var RESERVED = /* @__PURE__ */ new Set([
+  "i",
+  "home",
+  "search",
+  "explore",
+  "notifications",
+  "messages",
+  "settings",
+  "compose",
+  "hashtag",
+  "status",
+  "intent",
+  "share",
+  "login",
+  "signup",
+  "about"
+]);
+function parseUrl(input) {
+  try {
+    return new URL(input);
+  } catch {
+    return null;
+  }
+}
+function extractTweetId(input) {
+  if (!input) return null;
+  if (BARE_TWEET_ID_RE.test(input)) return input;
+  const url = parseUrl(input);
+  if (!url || !X_HOSTS.has(url.hostname)) return null;
+  const segments = url.pathname.split("/").filter(Boolean);
+  const statusIdx = segments.indexOf("status");
+  if (statusIdx === -1) return null;
+  const id = segments[statusIdx + 1];
+  return id !== void 0 && PATH_TWEET_ID_RE.test(id) ? id : null;
+}
+function extractHandle(input) {
+  if (!input) return null;
+  const bare = input.startsWith("@") ? input.slice(1) : input;
+  if (HANDLE_RE.test(bare)) return bare;
+  const url = parseUrl(input);
+  if (!url || !X_HOSTS.has(url.hostname)) return null;
+  const first2 = url.pathname.split("/").filter(Boolean)[0];
+  if (first2 === void 0 || RESERVED.has(first2.toLowerCase())) return null;
+  return HANDLE_RE.test(first2) ? first2 : null;
+}
+
+// src/engine/auth.ts
+var BEARER_TOKEN = "AAAAAAAAAAAAAAAAAAAAANRILgAAAAAAnNwIzUejRCOuH5E6I8xnZz4puTs%3D1Zv7ttfk8LF81IUq16cHjhLTvJu4FA33AGWWjCpTnA";
+var USER_AGENT = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36";
+function parseJsonForm(input) {
+  try {
+    const parsed = JSON.parse(input);
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+    const out = {};
+    for (const [key, value] of Object.entries(parsed)) {
+      out[key] = String(value);
+    }
+    return out;
+  } catch {
+    return null;
+  }
+}
+function parsePairForm(input) {
+  const out = {};
+  for (const part of input.split(";")) {
+    const eq = part.indexOf("=");
+    if (eq === -1) continue;
+    const key = part.slice(0, eq).trim();
+    const value = part.slice(eq + 1).trim();
+    if (key.length > 0) out[key] = value;
+  }
+  return out;
+}
+function parseCookies(input) {
+  const jar = parseJsonForm(input.trim()) ?? parsePairForm(input);
+  const authToken = jar.auth_token;
+  const ct0 = jar.ct0;
+  if (authToken === void 0) throw new Error("Missing cookie: auth_token");
+  if (ct0 === void 0) throw new Error("Missing cookie: ct0");
+  const extra = {};
+  for (const [key, value] of Object.entries(jar)) {
+    if (key !== "auth_token" && key !== "ct0") extra[key] = value;
+  }
+  const cookies = { authToken, ct0 };
+  if (Object.keys(extra).length > 0) cookies.extra = extra;
+  return cookies;
+}
+function cookieString(cookies) {
+  const parts = [`auth_token=${cookies.authToken}`, `ct0=${cookies.ct0}`];
+  for (const [key, value] of Object.entries(cookies.extra ?? {})) {
+    parts.push(`${key}=${value}`);
+  }
+  return parts.join("; ");
+}
+function buildHeaders(args) {
+  const { cookies, transactionId, clientLanguage = "en" } = args;
+  return {
+    authorization: `Bearer ${BEARER_TOKEN}`,
+    "x-csrf-token": cookies.ct0,
+    "x-twitter-auth-type": "OAuth2Session",
+    "x-twitter-active-user": "yes",
+    "x-twitter-client-language": clientLanguage,
+    "content-type": "application/json",
+    cookie: cookieString(cookies),
+    "x-client-transaction-id": transactionId,
+    referer: "https://x.com/",
+    origin: "https://x.com",
+    "sec-fetch-site": "same-site",
+    "sec-fetch-mode": "cors",
+    "sec-fetch-dest": "empty",
+    "user-agent": USER_AGENT,
+    accept: "*/*",
+    "accept-language": "en-US,en;q=0.9"
+  };
+}
+
+// src/engine/ops.ts
+var OPS = {
+  SearchTimeline: { queryId: "Yw6L66Pw54NHKuq4Dp7b4Q", operationName: "SearchTimeline" },
+  UserByScreenName: { queryId: "IGgvgiOx4QZndDHuD3x9TQ", operationName: "UserByScreenName" },
+  UserByRestId: { queryId: "VQfQ9wwYdk6j_u2O4vt64Q", operationName: "UserByRestId" },
+  UserTweets: { queryId: "36rb3Xj3iJ64Q-9wKDjCcQ", operationName: "UserTweets" },
+  UserTweetsAndReplies: {
+    queryId: "D5eKzDa5ZoJuC1TCeAXbWA",
+    operationName: "UserTweetsAndReplies"
+  },
+  UserMedia: { queryId: "9EovraBTXJYGSEQXZqlLmQ", operationName: "UserMedia" },
+  Bookmarks: { queryId: "XD0ViOeSOW4YoeNTGjVaYw", operationName: "Bookmarks" },
+  TweetDetail: { queryId: "oCon7R-cgWRFy6EfZjaKfg", operationName: "TweetDetail" },
+  Followers: { queryId: "_orfRBQae57vylFPH0Huhg", operationName: "Followers" },
+  Following: { queryId: "F42cDX8PDFxkbjjq6JrM2w", operationName: "Following" },
+  ListLatestTweetsTimeline: {
+    queryId: "7UuJsFvnWuZo0HmxrzU42Q",
+    operationName: "ListLatestTweetsTimeline"
+  }
+};
+var FEATURES = {
+  rweb_video_screen_enabled: false,
+  profile_label_improvements_pcf_label_in_post_enabled: true,
+  rweb_tipjar_consumption_enabled: true,
+  responsive_web_graphql_exclude_directive_enabled: true,
+  verified_phone_label_enabled: false,
+  creator_subscriptions_tweet_preview_api_enabled: true,
+  responsive_web_graphql_timeline_navigation_enabled: true,
+  responsive_web_graphql_skip_user_profile_image_extensions_enabled: false,
+  premium_content_api_read_enabled: false,
+  communities_web_enable_tweet_community_results_fetch: true,
+  c9s_tweet_anatomy_moderator_badge_enabled: true,
+  responsive_web_grok_analyze_button_fetch_trends_enabled: false,
+  responsive_web_grok_analyze_post_followups_enabled: true,
+  responsive_web_jetfuel_frame: false,
+  responsive_web_grok_share_attachment_enabled: true,
+  articles_preview_enabled: true,
+  responsive_web_edit_tweet_api_enabled: true,
+  graphql_is_translatable_rweb_tweet_is_translatable_enabled: true,
+  view_counts_everywhere_api_enabled: true,
+  longform_notetweets_consumption_enabled: true,
+  responsive_web_twitter_article_tweet_consumption_enabled: true,
+  tweet_awards_web_tipping_enabled: false,
+  responsive_web_grok_show_grok_translated_post: false,
+  responsive_web_grok_analysis_button_from_backend: true,
+  creator_subscriptions_quote_tweet_preview_enabled: false,
+  freedom_of_speech_not_reach_fetch_enabled: true,
+  standardized_nudges_misinfo: true,
+  tweet_with_visibility_results_prefer_gql_limited_actions_policy_enabled: true,
+  longform_notetweets_rich_text_read_enabled: true,
+  longform_notetweets_inline_media_enabled: true,
+  responsive_web_grok_image_annotation_enabled: true,
+  responsive_web_grok_imagine_annotation_enabled: true,
+  responsive_web_grok_community_note_auto_translation_is_enabled: false,
+  payments_enabled: false,
+  hidden_profile_subscriptions_enabled: true,
+  subscriptions_verification_info_is_identity_verified_enabled: true,
+  subscriptions_verification_info_verified_since_enabled: true,
+  responsive_web_enhance_cards_enabled: false
+};
+function graphqlUrl(op) {
+  const { queryId, operationName } = OPS[op];
+  return `https://x.com/i/api/graphql/${queryId}/${operationName}`;
+}
+function withCursor(base, cursor) {
+  return cursor === void 0 ? base : { ...base, cursor };
+}
+function searchRequest(params) {
+  const { query, count = 20, product = "Latest", cursor, kv, ft } = params;
+  const variables = withCursor(
+    { rawQuery: query, count, querySource: "typed_query", product },
+    cursor
+  );
+  return {
+    variables: { ...variables, ...kv },
+    features: { ...FEATURES, ...ft },
+    fieldToggles: { withArticleRichContentState: false }
+  };
+}
+function bookmarksRequest(params) {
+  const { count = 20, cursor, kv, ft } = params;
+  const variables = withCursor({ count, includePromotedContent: true }, cursor);
+  return {
+    variables: { ...variables, ...kv },
+    features: { ...FEATURES, graphql_timeline_v2_bookmark_timeline: true, ...ft }
+  };
+}
+function userTweetsRequest(params) {
+  const { userId, count = 40, cursor, replies = false, kv, ft } = params;
+  const op = replies ? "UserTweetsAndReplies" : "UserTweets";
+  const variables = withCursor(
+    {
+      userId,
+      count,
+      includePromotedContent: false,
+      withQuickPromoteEligibilityTweetFields: true,
+      withVoice: true,
+      withV2Timeline: true
+    },
+    cursor
+  );
+  return {
+    op,
+    variables: { ...variables, ...kv },
+    features: { ...FEATURES, ...ft },
+    fieldToggles: { withArticlePlainText: false }
+  };
+}
+function userByScreenNameRequest(params) {
+  const { screenName, kv, ft } = params;
+  return {
+    variables: { screen_name: screenName, withGrokTranslatedBio: false, ...kv },
+    features: { ...FEATURES, ...ft },
+    fieldToggles: { withPayments: false, withAuxiliaryUserLabels: true }
+  };
+}
+function tweetDetailRequest(params) {
+  const { focalTweetId, cursor, kv, ft } = params;
+  const variables = withCursor(
+    {
+      focalTweetId,
+      with_rux_injections: false,
+      rankingMode: "Relevance",
+      includePromotedContent: true,
+      withCommunity: true,
+      withQuickPromoteEligibilityTweetFields: true,
+      withBirdwatchNotes: true,
+      withVoice: true
+    },
+    cursor
+  );
+  return {
+    variables: { ...variables, ...kv },
+    features: { ...FEATURES, ...ft },
+    fieldToggles: { withArticleRichContentState: false, withArticlePlainText: false }
+  };
+}
+function stableStringify(value) {
+  if (Array.isArray(value)) {
+    return `[${value.map(stableStringify).join(",")}]`;
+  }
+  if (value !== null && typeof value === "object") {
+    const obj = value;
+    const keys = Object.keys(obj).sort();
+    const body = keys.map((k) => `${JSON.stringify(k)}:${stableStringify(obj[k])}`).join(",");
+    return `{${body}}`;
+  }
+  return JSON.stringify(value) ?? "null";
+}
+function encodeParams(req) {
+  const params = new URLSearchParams();
+  params.set("variables", stableStringify(req.variables));
+  params.set("features", stableStringify(req.features));
+  if (req.fieldToggles !== void 0) {
+    params.set("fieldToggles", stableStringify(req.fieldToggles));
+  }
+  return params.toString();
+}
+
+// src/engine/client.ts
+var DEFAULT_BACKOFF_MS = 1e3;
+var defaultSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+function isFeatureDrift(body) {
+  if (body === null || typeof body !== "object") return false;
+  const errors = body.errors;
+  if (!Array.isArray(errors)) return false;
+  return errors.some((err2) => {
+    if (err2 === null || typeof err2 !== "object") return false;
+    const code = err2.code;
+    const message = err2.message;
+    if (code === 336) return true;
+    return typeof message === "string" && /features cannot be null/i.test(message);
+  });
+}
+function featureDrift(op) {
+  return {
+    ok: false,
+    error: {
+      code: "FEATURE_DRIFT",
+      message: `Feature drift on ${op}: X rejected the features blob \u2014 refresh src/engine/ops.ts features/query-ids.`
+    }
+  };
+}
+async function safeJson(res) {
+  try {
+    return await res.json();
+  } catch {
+    return null;
+  }
+}
+function backoffMs(res) {
+  const resetHeader = res.headers.get("x-rate-limit-reset");
+  const reset = resetHeader === null ? null : Number(resetHeader);
+  if (reset === null || !Number.isFinite(reset)) return DEFAULT_BACKOFF_MS;
+  const until = reset * 1e3 - Date.now();
+  return until > 0 ? until : DEFAULT_BACKOFF_MS;
+}
+var RETRY_NOW = { retry: true, waitMs: 0 };
+function isRetry(value) {
+  return "retry" in value;
+}
+function terminalError(op, status, body) {
+  if (status === 400) {
+    if (isFeatureDrift(body)) return featureDrift(op);
+    return { ok: false, error: { code: "BAD_REQUEST", status: 400, message: "Bad request." } };
+  }
+  if (status === 401 || status === 403) {
+    return {
+      ok: false,
+      error: {
+        code: "AUTH_FAILED",
+        status,
+        message: "Auth failed \u2014 session cookies expired or invalid."
+      }
+    };
+  }
+  return {
+    ok: false,
+    error: { code: "FETCH_FAILED", status, message: `Request failed with status ${status}.` }
+  };
+}
+function createClient(args) {
+  const {
+    cookies,
+    transaction,
+    fetchImpl = fetch,
+    sleep = defaultSleep,
+    maxRetries = 3,
+    clientLanguage
+  } = args;
+  async function fetchOnce(op, request) {
+    const url = `${graphqlUrl(op)}?${encodeParams(request)}`;
+    const path = new URL(url).pathname;
+    const txid = await transaction("GET", path);
+    const headers = buildHeaders({ cookies, transactionId: txid, clientLanguage });
+    return fetchImpl(url, { method: "GET", headers });
+  }
+  async function classify(op, res, retries) {
+    const { status } = res;
+    if (status === 200) {
+      const body2 = await safeJson(res);
+      return isFeatureDrift(body2) ? featureDrift(op) : { ok: true, value: body2 };
+    }
+    if (status === 429) {
+      if (retries.rateLimit >= maxRetries) {
+        return {
+          ok: false,
+          error: { code: "RATE_LIMITED", status: 429, message: "Rate limited; retries exhausted." }
+        };
+      }
+      retries.rateLimit += 1;
+      return { retry: true, waitMs: backoffMs(res) };
+    }
+    if (status === 404) {
+      if (retries.notFound >= maxRetries) {
+        return {
+          ok: false,
+          error: {
+            code: "NOT_FOUND",
+            status: 404,
+            message: "Not found; retries exhausted (stale txid?)."
+          }
+        };
+      }
+      retries.notFound += 1;
+      return RETRY_NOW;
+    }
+    const body = status === 400 ? await safeJson(res) : null;
+    return terminalError(op, status, body);
+  }
+  async function get(op, request) {
+    const retries = { rateLimit: 0, notFound: 0 };
+    for (; ; ) {
+      let res;
+      try {
+        res = await fetchOnce(op, request);
+      } catch (err2) {
+        const message = err2 instanceof Error ? err2.message : String(err2);
+        return { ok: false, error: { code: "FETCH_FAILED", message } };
+      }
+      const outcome = await classify(op, res, retries);
+      if (!isRetry(outcome)) return outcome;
+      if (outcome.waitMs > 0) await sleep(outcome.waitMs);
+    }
+  }
+  return { get };
+}
+
+// src/engine/cookies.ts
+import { execFileSync } from "child_process";
+import { createDecipheriv, pbkdf2Sync } from "crypto";
+import { copyFileSync, existsSync, mkdtempSync, readdirSync } from "fs";
+import { homedir, tmpdir } from "os";
+import { join } from "path";
+function deriveKey(keychainSecret2) {
+  return pbkdf2Sync(keychainSecret2, "saltysalt", 1003, 16, "sha1");
+}
+function isPrintableAscii(s) {
+  return /^[\x20-\x7e]*$/.test(s);
+}
+function decryptCookieValue(encrypted, key) {
+  if (encrypted.length === 0) return "";
+  const prefix = encrypted.subarray(0, 3).toString("latin1");
+  if (prefix !== "v10" && prefix !== "v11") return encrypted.toString("utf8");
+  const iv = Buffer.alloc(16, " ");
+  const decipher = createDecipheriv("aes-128-cbc", key, iv);
+  decipher.setAutoPadding(false);
+  let out;
+  try {
+    out = Buffer.concat([decipher.update(encrypted.subarray(3)), decipher.final()]);
+  } catch {
+    return null;
+  }
+  const pad = out[out.length - 1] ?? 0;
+  if (pad > 0 && pad <= 16) out = out.subarray(0, out.length - pad);
+  const direct = out.toString("utf8");
+  if (isPrintableAscii(direct)) return direct;
+  const stripped = out.subarray(32).toString("utf8");
+  if (isPrintableAscii(stripped)) return stripped;
+  return direct;
+}
+function pickAuthCookies(rows) {
+  let authToken;
+  let ct0;
+  const extra = {};
+  for (const row of rows) {
+    if (!row.name || !row.value) continue;
+    if (row.name === "auth_token") authToken = row.value;
+    else if (row.name === "ct0") ct0 = row.value;
+    else extra[row.name] = row.value;
+  }
+  if (authToken === void 0 || ct0 === void 0) return null;
+  const cookies = { authToken, ct0 };
+  if (Object.keys(extra).length > 0) cookies.extra = extra;
+  return cookies;
+}
+var BROWSERS = [
+  { name: "arc", keychain: "Arc", base: "Arc/User Data" },
+  { name: "chrome", keychain: "Chrome", base: "Google/Chrome" },
+  { name: "brave", keychain: "Brave", base: "BraveSoftware/Brave-Browser" },
+  { name: "edge", keychain: "Microsoft Edge", base: "Microsoft Edge" }
+];
+function browserOrder() {
+  const pref = (process.env.XRELAY_BROWSER ?? "").trim().toLowerCase();
+  if (!pref) return BROWSERS;
+  const first2 = BROWSERS.filter((b) => b.name === pref);
+  return first2.length ? [...first2, ...BROWSERS.filter((b) => b.name !== pref)] : BROWSERS;
+}
+function keychainSecret(browser) {
+  try {
+    return execFileSync(
+      "security",
+      ["find-generic-password", "-w", "-s", `${browser.keychain} Safe Storage`],
+      { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }
+    ).trim();
+  } catch {
+    return null;
+  }
+}
+function profileCookieDbs(browser) {
+  const root = join(homedir(), "Library", "Application Support", browser.base);
+  if (!existsSync(root)) return [];
+  const dbs = [];
+  const defaultDb = join(root, "Default", "Cookies");
+  if (existsSync(defaultDb)) dbs.push(defaultDb);
+  for (const entry of readdirSync(root)) {
+    if (entry.startsWith("Profile ")) {
+      const db = join(root, entry, "Cookies");
+      if (existsSync(db)) dbs.push(db);
+    }
+  }
+  return dbs;
+}
+function readCookieRows(dbPath) {
+  const tmp = join(mkdtempSync(join(tmpdir(), "xrelay-")), "Cookies");
+  copyFileSync(dbPath, tmp);
+  for (const suffix of ["-wal", "-shm"]) {
+    if (existsSync(dbPath + suffix)) copyFileSync(dbPath + suffix, tmp + suffix);
+  }
+  const sql = "SELECT host_key AS hostKey, name, hex(encrypted_value) AS hexValue FROM cookies WHERE host_key LIKE '%x.com' OR host_key LIKE '%twitter.com'";
+  try {
+    const out = execFileSync("sqlite3", ["-readonly", "-json", tmp, sql], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    if (!out) return [];
+    return JSON.parse(out);
+  } catch {
+    return [];
+  }
+}
+function extractCookies() {
+  if (process.platform !== "darwin") return null;
+  for (const browser of browserOrder()) {
+    const dbs = profileCookieDbs(browser);
+    if (dbs.length === 0) continue;
+    const secret = keychainSecret(browser);
+    if (!secret) continue;
+    const key = deriveKey(secret);
+    for (const db of dbs) {
+      const rows = readCookieRows(db).map((r) => ({
+        hostKey: r.hostKey,
+        name: r.name,
+        value: decryptCookieValue(Buffer.from(r.hexValue, "hex"), key) ?? ""
+      }));
+      const cookies = pickAuthCookies(rows);
+      if (cookies) return cookies;
+    }
+  }
+  return null;
+}
+function getCookies() {
+  const env = process.env.XRELAY_COOKIES;
+  if (env) return parseCookies(env);
+  const cookies = extractCookies();
+  if (cookies) return cookies;
+  throw new Error(
+    'No X cookies found. Log into x.com in Arc/Chrome/Brave/Edge (macOS), or set XRELAY_COOKIES="auth_token=...; ct0=...". If a Keychain prompt appeared, click "Always Allow".'
+  );
+}
+
+// src/engine/parse.ts
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function child(node, key) {
+  const value = node[key];
+  return isRecord(value) ? value : void 0;
+}
+function asString(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function asNumber(value) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string" && value.trim() !== "") {
+    const parsed = Number(value);
+    if (Number.isFinite(parsed)) return parsed;
+  }
+  return void 0;
+}
+function asBool(value) {
+  return typeof value === "boolean" ? value : void 0;
+}
+function findDict(obj, key, findFirst = false) {
+  const out = [];
+  const walk = (node) => {
+    if (Array.isArray(node)) {
+      return node.some(walk);
+    }
+    if (!isRecord(node)) return false;
+    for (const [k, value] of Object.entries(node)) {
+      if (k === key) {
+        out.push(value);
+        if (findFirst) return true;
+      }
+      if (walk(value)) return true;
+    }
+    return false;
+  };
+  walk(obj);
+  return out;
+}
+function parseUserResult(result) {
+  if (!isRecord(result)) return null;
+  if (result.__typename !== void 0 && result.__typename !== "User") return null;
+  const legacy = child(result, "legacy");
+  const core = child(result, "core");
+  const handle = asString(core?.screen_name) ?? asString(legacy?.screen_name);
+  const id = asString(result.rest_id) ?? asString(legacy?.id_str);
+  if (handle === void 0 || id === void 0) return null;
+  const name = asString(core?.name) ?? asString(legacy?.name) ?? handle;
+  const verification = child(result, "verification");
+  const verified = asBool(result.is_blue_verified) === true || asBool(verification?.verified) === true || asBool(legacy?.verified) === true;
+  const followers = asNumber(legacy?.followers_count) ?? asNumber(result.followers_count) ?? 0;
+  const following = asNumber(legacy?.friends_count) ?? asNumber(result.friends_count) ?? 0;
+  const tweets = asNumber(legacy?.statuses_count) ?? asNumber(result.statuses_count) ?? 0;
+  const profile = {
+    id,
+    handle,
+    name,
+    verified,
+    followers,
+    following,
+    tweets,
+    url: `https://x.com/${handle}`
+  };
+  applyUserOptionals(profile, result, legacy, core);
+  return profile;
+}
+function applyUserOptionals(profile, result, legacy, core) {
+  const profileBio = child(result, "profile_bio");
+  const bio = asString(legacy?.description) ?? asString(profileBio?.description);
+  if (bio !== void 0) profile.bio = bio;
+  const createdAt = asString(core?.created_at) ?? asString(legacy?.created_at);
+  if (createdAt !== void 0) profile.createdAt = createdAt;
+  const locationObj = child(result, "location");
+  const location = asString(legacy?.location) ?? asString(locationObj?.location);
+  if (location !== void 0) profile.location = location;
+  const avatarObj = child(result, "avatar");
+  const avatar = asString(legacy?.profile_image_url_https) ?? asString(avatarObj?.image_url);
+  if (avatar !== void 0) profile.avatar = avatar;
+}
+function authorFromProfile(profile) {
+  const author = {
+    id: profile.id,
+    handle: profile.handle,
+    name: profile.name,
+    verified: profile.verified,
+    followers: profile.followers
+  };
+  if (profile.avatar !== void 0) author.avatar = profile.avatar;
+  return author;
+}
+function parseAuthor(result) {
+  const core = child(result, "core");
+  const userResults = core ? child(core, "user_results") : void 0;
+  const userNode = userResults ? userResults.result : void 0;
+  const profile = parseUserResult(userNode);
+  return profile ? authorFromProfile(profile) : null;
+}
+function tweetText(result, legacy) {
+  const note = child(result, "note_tweet");
+  const noteResults = note ? child(note, "note_tweet_results") : void 0;
+  const noteResult = noteResults ? child(noteResults, "result") : void 0;
+  const noteText = noteResult ? asString(noteResult.text) : void 0;
+  if (noteText !== void 0) return noteText;
+  return asString(legacy?.full_text) ?? asString(result.full_text) ?? "";
+}
+function tweetViews(result, legacy) {
+  const views = child(result, "views") ?? child(result, "ext_views");
+  const extFromLegacy = legacy ? child(legacy, "ext_views") : void 0;
+  return asNumber(views?.count) ?? asNumber(extFromLegacy?.count);
+}
+function tweetMetrics(result, legacy) {
+  const pick = (key) => asNumber(legacy?.[key]) ?? asNumber(result[key]);
+  const metrics = {};
+  const likes = pick("favorite_count");
+  const retweets = pick("retweet_count");
+  const replies = pick("reply_count");
+  const quotes = pick("quote_count");
+  const bookmarks = pick("bookmark_count");
+  const views = tweetViews(result, legacy);
+  if (likes !== void 0) metrics.likes = likes;
+  if (retweets !== void 0) metrics.retweets = retweets;
+  if (replies !== void 0) metrics.replies = replies;
+  if (quotes !== void 0) metrics.quotes = quotes;
+  if (bookmarks !== void 0) metrics.bookmarks = bookmarks;
+  if (views !== void 0) metrics.views = views;
+  return metrics;
+}
+function entityStrings(entities, arrayKey, field) {
+  const arr = entities?.[arrayKey];
+  if (!Array.isArray(arr)) return void 0;
+  const out = [];
+  for (const item of arr) {
+    if (isRecord(item)) {
+      const value = asString(item[field]);
+      if (value !== void 0) out.push(value);
+    }
+  }
+  return out.length > 0 ? out : void 0;
+}
+var MEDIA_MAP = {
+  photo: "photo",
+  video: "video",
+  animated_gif: "gif"
+};
+function tweetMedia(extended) {
+  const arr = extended?.media;
+  if (!Array.isArray(arr)) return void 0;
+  const out = [];
+  for (const item of arr) {
+    if (isRecord(item)) {
+      const kind = asString(item.type);
+      if (kind !== void 0 && kind in MEDIA_MAP) {
+        const mapped = MEDIA_MAP[kind];
+        if (mapped !== void 0) out.push(mapped);
+      }
+    }
+  }
+  return out.length > 0 ? out : void 0;
+}
+function dualString(result, legacy, key) {
+  return asString(legacy?.[key]) ?? asString(result[key]);
+}
+function applyTweetDetails(tweet, result, legacy) {
+  const lang = dualString(result, legacy, "lang");
+  if (lang !== void 0) tweet.lang = lang;
+  const createdAt = dualString(result, legacy, "created_at");
+  if (createdAt !== void 0) tweet.createdAt = createdAt;
+  const conversationId = dualString(result, legacy, "conversation_id_str");
+  if (conversationId !== void 0) tweet.conversationId = conversationId;
+  const entities = child(result, "entities") ?? (legacy ? child(legacy, "entities") : void 0);
+  const extended = child(result, "extended_entities") ?? (legacy ? child(legacy, "extended_entities") : void 0);
+  const hashtags = entityStrings(entities, "hashtags", "text");
+  if (hashtags !== void 0) tweet.hashtags = hashtags;
+  const mentions = entityStrings(entities, "user_mentions", "screen_name");
+  if (mentions !== void 0) tweet.mentions = mentions;
+  const urls = entityStrings(entities, "urls", "expanded_url");
+  if (urls !== void 0) tweet.urls = urls;
+  const media = tweetMedia(extended);
+  if (media !== void 0) tweet.media = media;
+}
+function applyTweetRelations(tweet, result, legacy) {
+  if (dualString(result, legacy, "in_reply_to_status_id_str") !== void 0) tweet.isReply = true;
+  const isRetweet = child(result, "retweeted_status_result") !== void 0 || (legacy ? child(legacy, "retweeted_status_result") !== void 0 : false);
+  if (isRetweet) tweet.isRetweet = true;
+  const quoteId = dualString(result, legacy, "quoted_status_id_str");
+  const quotedNode = child(result, "quoted_status_result") ?? (legacy ? child(legacy, "quoted_status_result") : void 0);
+  if (quoteId !== void 0 || quotedNode !== void 0) tweet.isQuote = true;
+  if (quotedNode !== void 0) {
+    const quoted = parseTweetResult(quotedNode.result);
+    if (quoted !== null) tweet.quoted = quoted;
+  }
+}
+function parseTweetResult(result) {
+  if (!isRecord(result)) return null;
+  if (result.__typename === "TweetWithVisibilityResults") {
+    return parseTweetResult(result.tweet);
+  }
+  if (result.__typename === "TweetTombstone") return null;
+  const legacy = child(result, "legacy");
+  const id = asString(result.rest_id) ?? asString(legacy?.id_str);
+  if (id === void 0) return null;
+  const author = parseAuthor(result);
+  if (author === null) return null;
+  const tweet = {
+    id,
+    url: `https://x.com/${author.handle}/status/${id}`,
+    text: tweetText(result, legacy),
+    author,
+    metrics: tweetMetrics(result, legacy)
+  };
+  applyTweetDetails(tweet, result, legacy);
+  applyTweetRelations(tweet, result, legacy);
+  return tweet;
+}
+var TWEET_ENTRY_PREFIXES = ["tweet", "search-grid", "profile-conversation"];
+var DROP_ENTRY_PREFIXES = ["cursor-", "promoted", "who-to-follow", "module-"];
+function startsWithAny(value, prefixes) {
+  return prefixes.some((prefix) => value.startsWith(prefix));
+}
+function locateInstructions(json) {
+  const found = findDict(json, "instructions", true)[0];
+  return Array.isArray(found) ? found : [];
+}
+function collectEntries(instructions) {
+  const entries = [];
+  for (const instruction of instructions) {
+    if (isRecord(instruction) && Array.isArray(instruction.entries)) {
+      for (const entry of instruction.entries) {
+        if (isRecord(entry)) entries.push(entry);
+      }
+    }
+  }
+  return entries;
+}
+function entryBottomCursor(entry, entryId) {
+  const content = child(entry, "content");
+  const itemContent = content ? child(content, "itemContent") : void 0;
+  const cursorType = asString(content?.cursorType) ?? asString(itemContent?.cursorType);
+  const isBottom = cursorType === "Bottom" || cursorType === "ShowMoreThreads" || entryId.startsWith("cursor-bottom") || entryId.startsWith("cursor-showmore");
+  if (!isBottom) return void 0;
+  return asString(content?.value) ?? asString(itemContent?.value);
+}
+function entryTweetNodes(entry) {
+  return findDict(entry, "tweet_results").map((node) => isRecord(node) ? node.result : void 0);
+}
+function parseTimeline(json, _opts) {
+  const entries = collectEntries(locateInstructions(json));
+  const tweets = [];
+  const seen = /* @__PURE__ */ new Set();
+  let nextCursor;
+  for (const entry of entries) {
+    const entryId = asString(entry.entryId) ?? "";
+    const cursor = entryBottomCursor(entry, entryId);
+    if (cursor !== void 0) nextCursor = cursor;
+    if (startsWithAny(entryId, DROP_ENTRY_PREFIXES)) continue;
+    if (!startsWithAny(entryId, TWEET_ENTRY_PREFIXES)) continue;
+    for (const node of entryTweetNodes(entry)) {
+      try {
+        const tweet = parseTweetResult(node);
+        if (tweet !== null && !seen.has(tweet.id)) {
+          seen.add(tweet.id);
+          tweets.push(tweet);
+        }
+      } catch {
+      }
+    }
+  }
+  const page = { tweets };
+  if (nextCursor !== void 0) page.nextCursor = nextCursor;
+  return page;
+}
+function parseThread(json, focalTweetId) {
+  const page = parseTimeline(json);
+  const root = page.tweets.find((tweet) => tweet.id === focalTweetId);
+  const replies = page.tweets.filter((tweet) => tweet.id !== focalTweetId);
+  const result = {
+    root: root ?? {
+      id: focalTweetId,
+      url: `https://x.com/i/status/${focalTweetId}`,
+      text: "",
+      author: { id: "", handle: "", name: "", verified: false },
+      metrics: {}
+    },
+    replies
+  };
+  if (page.nextCursor !== void 0) result.nextCursor = page.nextCursor;
+  return result;
+}
+
+// src/engine/xctid/transaction.ts
+import { createHash } from "crypto";
+
+// src/engine/xctid/cubic.ts
+var Cubic = class {
+  curves;
+  constructor(curves) {
+    this.curves = curves;
+  }
+  getValue(time) {
+    const [c0 = 0, c1 = 0, c2 = 0, c3 = 0] = this.curves;
+    let startGradient = 0;
+    let endGradient = 0;
+    let start = 0;
+    let mid = 0;
+    const endInit = 1;
+    let end = endInit;
+    if (time <= 0) {
+      if (c0 > 0) {
+        startGradient = c1 / c0;
+      } else if (c1 === 0 && c2 > 0) {
+        startGradient = c3 / c2;
+      }
+      return startGradient * time;
+    }
+    if (time >= 1) {
+      if (c2 < 1) {
+        endGradient = (c3 - 1) / (c2 - 1);
+      } else if (c2 === 1 && c0 < 1) {
+        endGradient = (c1 - 1) / (c0 - 1);
+      }
+      return 1 + endGradient * (time - 1);
+    }
+    while (start < end) {
+      mid = (start + end) / 2;
+      const xEst = this.calculate(c0, c2, mid);
+      if (Math.abs(time - xEst) < 1e-5) {
+        return this.calculate(c1, c3, mid);
+      }
+      if (xEst < time) {
+        start = mid;
+      } else {
+        end = mid;
+      }
+    }
+    return this.calculate(c1, c3, mid);
+  }
+  calculate(a, b, m) {
+    return 3 * a * (1 - m) * (1 - m) * m + 3 * b * (1 - m) * m * m + m * m * m;
+  }
+};
+
+// src/engine/xctid/errors.ts
+var ClientTransactionError = class extends Error {
+  code;
+  constructor(message, options = {}) {
+    super(message, options.cause ? { cause: options.cause } : void 0);
+    this.name = new.target.name;
+    this.code = options.code ?? "CLIENT_TRANSACTION_ERROR";
+  }
+};
+var ClientTransactionInitializationError = class extends ClientTransactionError {
+  constructor(message, options = {}) {
+    super(message, {
+      code: options.code ?? "CLIENT_TRANSACTION_INITIALIZATION_ERROR",
+      cause: options.cause
+    });
+  }
+};
+var OnDemandFileUrlResolutionError = class extends ClientTransactionInitializationError {
+  constructor() {
+    super("Unable to resolve the X ondemand chunk URL from the homepage runtime.", {
+      code: "ONDEMAND_FILE_URL_RESOLUTION_ERROR"
+    });
+  }
+};
+var OnDemandFileFetchError = class extends ClientTransactionInitializationError {
+  url;
+  status;
+  statusText;
+  constructor(url, status, statusText) {
+    super(`Unable to fetch the X ondemand chunk from "${url}": ${status} ${statusText}.`, {
+      code: "ONDEMAND_FILE_FETCH_ERROR"
+    });
+    this.url = url;
+    this.status = status;
+    this.statusText = statusText;
+  }
+};
+var KeyByteIndicesExtractionError = class extends ClientTransactionInitializationError {
+  constructor() {
+    super("Unable to extract key byte indices from the X ondemand chunk.", {
+      code: "KEY_BYTE_INDICES_EXTRACTION_ERROR"
+    });
+  }
+};
+var SiteVerificationKeyNotFoundError = class extends ClientTransactionInitializationError {
+  constructor() {
+    super("Unable to find the twitter-site-verification meta tag in the homepage document.", {
+      code: "SITE_VERIFICATION_KEY_NOT_FOUND_ERROR"
+    });
+  }
+};
+var IndicesNotInitializedError = class extends ClientTransactionError {
+  constructor() {
+    super(
+      "ClientTransaction indices are not initialized. Call initialize() before generating animation data.",
+      { code: "INDICES_NOT_INITIALIZED_ERROR" }
+    );
+  }
+};
+var AnimationFrameDataError = class extends ClientTransactionInitializationError {
+  rowIndex;
+  constructor(rowIndex) {
+    super(
+      `Unable to build animation data for row ${rowIndex}. The homepage animation markup may have changed.`,
+      { code: "ANIMATION_FRAME_DATA_ERROR" }
+    );
+    this.rowIndex = rowIndex;
+  }
+};
+var ClientTransactionNotInitializedError = class extends ClientTransactionError {
+  constructor() {
+    super(
+      "ClientTransaction has not been initialized. Call initialize() or use ClientTransaction.create() first.",
+      { code: "CLIENT_TRANSACTION_NOT_INITIALIZED_ERROR" }
+    );
+  }
+};
+var HandleXMigrationError = class extends ClientTransactionError {
+  constructor(message, options = {}) {
+    super(message, { code: options.code ?? "HANDLE_X_MIGRATION_ERROR", cause: options.cause });
+  }
+};
+var XHomePageFetchError = class extends HandleXMigrationError {
+  status;
+  statusText;
+  constructor(status, statusText) {
+    super(`Unable to fetch the X homepage: ${status} ${statusText}.`, {
+      code: "X_HOMEPAGE_FETCH_ERROR"
+    });
+    this.status = status;
+    this.statusText = statusText;
+  }
+};
+var XMigrationRedirectionError = class extends HandleXMigrationError {
+  status;
+  statusText;
+  constructor(status, statusText) {
+    super(`Unable to follow the X migration redirect: ${status} ${statusText}.`, {
+      code: "X_MIGRATION_REDIRECTION_ERROR"
+    });
+    this.status = status;
+    this.statusText = statusText;
+  }
+};
+var XMigrationFormError = class extends HandleXMigrationError {
+  status;
+  statusText;
+  constructor(status, statusText) {
+    super(`Unable to submit the X migration form: ${status} ${statusText}.`, {
+      code: "X_MIGRATION_FORM_ERROR"
+    });
+    this.status = status;
+    this.statusText = statusText;
+  }
+};
+var InterpolationInputError = class extends ClientTransactionError {
+  fromLength;
+  toLength;
+  constructor(fromLength, toLength) {
+    super(
+      `Interpolation requires arrays of the same length, but received ${fromLength} and ${toLength}.`,
+      { code: "INTERPOLATION_INPUT_ERROR" }
+    );
+    this.fromLength = fromLength;
+    this.toLength = toLength;
+  }
+};
+
+// src/engine/xctid/interpolate.ts
+function interpolate(fromList, toList, f) {
+  if (fromList.length !== toList.length) {
+    throw new InterpolationInputError(fromList.length, toList.length);
+  }
+  const out = [];
+  for (let i = 0; i < fromList.length; i++) {
+    out.push(interpolateNum(fromList[i] ?? 0, toList[i] ?? 0, f));
+  }
+  return out;
+}
+function interpolateNum(fromVal, toVal, f) {
+  if (typeof fromVal === "number" && typeof toVal === "number") {
+    return fromVal * (1 - f) + toVal * f;
+  }
+  if (typeof fromVal === "boolean" && typeof toVal === "boolean") {
+    return f < 0.5 ? fromVal ? 1 : 0 : toVal ? 1 : 0;
+  }
+  return 0;
+}
+
+// src/engine/xctid/rotation.ts
+function convertRotationToMatrix(rotation) {
+  const rad = rotation * Math.PI / 180;
+  return [Math.cos(rad), -Math.sin(rad), Math.sin(rad), Math.cos(rad)];
+}
+
+// src/engine/xctid/utils.ts
+import { parseHTML } from "linkedom";
+var BROWSER_HEADERS = {
+  accept: "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7",
+  "accept-language": "en-US,en;q=0.9",
+  "cache-control": "no-cache",
+  pragma: "no-cache",
+  priority: "u=0, i",
+  "sec-ch-ua": '"Google Chrome";v="135", "Not-A.Brand";v="8", "Chromium";v="135"',
+  "sec-ch-ua-mobile": "?0",
+  "sec-ch-ua-platform": '"Windows"',
+  "sec-fetch-dest": "document",
+  "sec-fetch-mode": "navigate",
+  "sec-fetch-site": "none",
+  "sec-fetch-user": "?1",
+  "upgrade-insecure-requests": "1",
+  "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36"
+};
+async function handleXMigration(fetchImpl = fetch) {
+  const response = await fetchImpl("https://x.com", { headers: BROWSER_HEADERS });
+  if (!response.ok) {
+    throw new XHomePageFetchError(response.status, response.statusText);
+  }
+  const htmlText = await response.text();
+  let document = parseHTML(htmlText).window.document;
+  const migrationRedirectionRegex = /(http(?:s)?:\/\/(?:www\.)?(twitter|x){1}\.com(\/x)?\/migrate([/?])?tok=[a-zA-Z0-9%\-_]+)+/i;
+  const metaRefresh = document.querySelector("meta[http-equiv='refresh']");
+  const metaContent = metaRefresh ? metaRefresh.getAttribute("content") || "" : "";
+  const migrationRedirectionUrl = migrationRedirectionRegex.exec(metaContent) || migrationRedirectionRegex.exec(htmlText);
+  if (migrationRedirectionUrl) {
+    const redirectResponse = await fetchImpl(migrationRedirectionUrl[0]);
+    if (!redirectResponse.ok) {
+      throw new XMigrationRedirectionError(redirectResponse.status, redirectResponse.statusText);
+    }
+    document = parseHTML(await redirectResponse.text()).window.document;
+  }
+  const migrationForm = document.querySelector("form[name='f']") || document.querySelector("form[action='https://x.com/x/migrate']");
+  if (migrationForm) {
+    const url = migrationForm.getAttribute("action") || "https://x.com/x/migrate";
+    const method = migrationForm.getAttribute("method") || "POST";
+    const requestPayload = new FormData();
+    for (const element of Array.from(migrationForm.querySelectorAll("input"))) {
+      const name = element.getAttribute("name");
+      const value = element.getAttribute("value");
+      if (name && value) requestPayload.append(name, value);
+    }
+    const formResponse = await fetchImpl(url, { method, body: requestPayload });
+    if (!formResponse.ok) {
+      throw new XMigrationFormError(formResponse.status, formResponse.statusText);
+    }
+    document = parseHTML(await formResponse.text()).window.document;
+  }
+  return document;
+}
+function floatToHex(x) {
+  const result = [];
+  let n = x;
+  let quotient = Math.floor(n);
+  const fraction = n - quotient;
+  while (quotient > 0) {
+    quotient = Math.floor(n / 16);
+    const remainder = Math.floor(n - quotient * 16);
+    if (remainder > 9) {
+      result.unshift(String.fromCharCode(remainder + 55));
+    } else {
+      result.unshift(remainder.toString());
+    }
+    n = quotient;
+  }
+  if (fraction === 0) return result.join("");
+  result.push(".");
+  let frac = fraction;
+  while (frac > 0) {
+    frac *= 16;
+    const integer = Math.floor(frac);
+    frac -= integer;
+    if (integer > 9) {
+      result.push(String.fromCharCode(integer + 55));
+    } else {
+      result.push(integer.toString());
+    }
+  }
+  return result.join("");
+}
+function isOdd(num2) {
+  return num2 % 2 ? -1 : 0;
+}
+
+// src/engine/xctid/transaction.ts
+var ON_DEMAND_CHUNK_NAME = "ondemand.s";
+var INDICES_REGEX = /\(\w\[(\d{1,2})\],\s*16\)/g;
+var ON_DEMAND_FILE_HASH_REGEX = /(\d+):\s*["']ondemand\.s["'][\s\S]*?\}\)\[e\]\s*\|\|\s*e\)\s*\+\s*["']\.["']\s*\+\s*\(\{[\s\S]*?\b\1:\s*["']([a-zA-Z0-9_-]+)["']/s;
+var DEFAULT_KEYWORD = "obfiowerehiring";
+var ADDITIONAL_RANDOM_NUMBER = 3;
+var EPOCH_SECONDS = 1682924400;
+function resolveOnDemandFileUrlFromRuntime(runtimeSource) {
+  const match = ON_DEMAND_FILE_HASH_REGEX.exec(runtimeSource);
+  if (!match) return null;
+  return `https://abs.twimg.com/responsive-web/client-web/${ON_DEMAND_CHUNK_NAME}.${match[2]}a.js`;
+}
+async function assembleTransactionId(keyBytes, animationKey, method, path, timeNow, randomNum) {
+  const timeNowBytes = [
+    timeNow & 255,
+    timeNow >> 8 & 255,
+    timeNow >> 16 & 255,
+    timeNow >> 24 & 255
+  ];
+  const data = `${method}!${path}!${timeNow}${DEFAULT_KEYWORD}${animationKey}`;
+  const hashBytes = [...createHash("sha256").update(data, "utf8").digest()];
+  const rnd = randomNum ?? Math.floor(Math.random() * 256);
+  const bytesArr = [
+    ...keyBytes,
+    ...timeNowBytes,
+    ...hashBytes.slice(0, 16),
+    ADDITIONAL_RANDOM_NUMBER
+  ];
+  const out = Uint8Array.from([rnd, ...bytesArr.map((b) => b ^ rnd)]);
+  return Buffer.from(out).toString("base64").replace(/=/g, "");
+}
+var ClientTransaction = class _ClientTransaction {
+  homePageDocument;
+  rowIndex = null;
+  keyByteIndices = null;
+  key = null;
+  keyBytes = null;
+  animationKey = null;
+  isInitialized = false;
+  constructor(homePageDocument) {
+    this.homePageDocument = homePageDocument;
+  }
+  static async create(homePageDocument) {
+    const instance = new _ClientTransaction(homePageDocument);
+    await instance.initialize();
+    return instance;
+  }
+  async initialize() {
+    if (this.isInitialized) return;
+    [this.rowIndex, this.keyByteIndices] = await this.getIndices();
+    this.key = this.getKey();
+    this.keyBytes = getKeyBytes(this.key);
+    this.animationKey = this.getAnimationKey(this.keyBytes);
+    this.isInitialized = true;
+  }
+  async getIndices() {
+    const onDemandFileUrl = this.getOnDemandFileUrl();
+    const onDemandFileResponse = await fetch(onDemandFileUrl);
+    if (!onDemandFileResponse.ok) {
+      throw new OnDemandFileFetchError(
+        onDemandFileUrl,
+        onDemandFileResponse.status,
+        onDemandFileResponse.statusText
+      );
+    }
+    const responseText = await onDemandFileResponse.text();
+    const indices = [];
+    INDICES_REGEX.lastIndex = 0;
+    let match = INDICES_REGEX.exec(responseText);
+    while (match !== null) {
+      if (match[1] !== void 0) indices.push(Number.parseInt(match[1], 10));
+      match = INDICES_REGEX.exec(responseText);
+    }
+    if (!indices.length) throw new KeyByteIndicesExtractionError();
+    return [indices[0] ?? 0, indices.slice(1)];
+  }
+  getOnDemandFileUrl() {
+    const doc = this.homePageDocument;
+    const runtimeSources = Array.from(doc.querySelectorAll("script")).map((script) => script.textContent || "").filter((text) => text.includes(ON_DEMAND_CHUNK_NAME));
+    runtimeSources.push(doc.documentElement.outerHTML);
+    for (const runtimeSource of runtimeSources) {
+      const url = resolveOnDemandFileUrlFromRuntime(runtimeSource);
+      if (url) return url;
+    }
+    throw new OnDemandFileUrlResolutionError();
+  }
+  getKey() {
+    const element = this.homePageDocument.querySelector("[name='twitter-site-verification']");
+    const content = element ? element.getAttribute("content") ?? "" : "";
+    if (!content) throw new SiteVerificationKeyNotFoundError();
+    return content;
+  }
+  getFrames() {
+    return Array.from(this.homePageDocument.querySelectorAll("[id^='loading-x-anim']"));
+  }
+  get2dArray(keyBytes) {
+    const frames = this.getFrames();
+    if (!frames.length) return [[]];
+    const frame = frames[(keyBytes[5] ?? 0) % 4];
+    const firstChild = frame?.children[0];
+    const targetChild = firstChild?.children[1];
+    const dAttr = targetChild?.getAttribute("d") ?? null;
+    if (dAttr === null) return [];
+    const items = dAttr.substring(9).split("C");
+    return items.map((item) => {
+      const cleaned = item.replace(/[^\d]+/g, " ").trim();
+      const parts = cleaned === "" ? [] : cleaned.split(/\s+/);
+      return parts.map((str) => Number.parseInt(str, 10));
+    });
+  }
+  solve(value, minVal, maxVal, rounding) {
+    const result = value * (maxVal - minVal) / 255 + minVal;
+    return rounding ? Math.floor(result) : Math.round(result * 100) / 100;
+  }
+  animate(frames, targetTime) {
+    const fromColor = frames.slice(0, 3).concat(1).map(Number);
+    const toColor = frames.slice(3, 6).concat(1).map(Number);
+    const fromRotation = [0];
+    const toRotation = [this.solve(frames[6] ?? 0, 60, 360, true)];
+    const curves = frames.slice(7).map((item, counter) => this.solve(item, isOdd(counter), 1, false));
+    const val = new Cubic(curves).getValue(targetTime);
+    const color = interpolate(fromColor, toColor, val).map((value) => value > 0 ? value : 0);
+    const rotation = interpolate(fromRotation, toRotation, val);
+    const matrix = convertRotationToMatrix(rotation[0] ?? 0);
+    const strArr = color.slice(0, -1).map((value) => Math.round(value).toString(16));
+    for (const value of matrix) {
+      let rounded = Math.round(value * 100) / 100;
+      if (rounded < 0) rounded = -rounded;
+      const hexValue = floatToHex(rounded);
+      strArr.push(hexValue.startsWith(".") ? `0${hexValue}`.toLowerCase() : hexValue || "0");
+    }
+    strArr.push("0", "0");
+    return strArr.join("").replace(/[.-]/g, "");
+  }
+  getAnimationKey(keyBytes) {
+    const totalTime = 4096;
+    if (this.rowIndex == null || this.keyByteIndices == null) {
+      throw new IndicesNotInitializedError();
+    }
+    const rowIndex = (keyBytes[this.rowIndex] ?? 0) % 16;
+    let frameTime = this.keyByteIndices.reduce((acc, idx) => acc * ((keyBytes[idx] ?? 0) % 16), 1);
+    frameTime = Math.round(frameTime / 10) * 10;
+    const arr = this.get2dArray(keyBytes);
+    const frameRow = arr[rowIndex];
+    if (!frameRow) throw new AnimationFrameDataError(rowIndex);
+    return this.animate(frameRow, frameTime / totalTime);
+  }
+  /** Generates a transaction id for the given (method, path). Requires initialize(). */
+  async generateTransactionId(method, path, timeNow) {
+    if (!this.isInitialized || this.keyBytes == null || this.animationKey == null) {
+      throw new ClientTransactionNotInitializedError();
+    }
+    const t = timeNow ?? Math.floor((Date.now() - EPOCH_SECONDS * 1e3) / 1e3);
+    return assembleTransactionId(this.keyBytes, this.animationKey, method, path, t);
+  }
+};
+function getKeyBytes(key) {
+  return Array.from(Buffer.from(key, "base64"));
+}
+
+// src/engine/index.ts
+var DEFAULT_LIMIT = 40;
+var EMPTY_PAGE_TOLERANCE = 3;
+var EngineError = class extends Error {
+  code;
+  status;
+  constructor(code, message, status) {
+    super(message);
+    this.name = "EngineError";
+    this.code = code;
+    if (status !== void 0) this.status = status;
+  }
+};
+function idLte(a, b) {
+  try {
+    return BigInt(a) <= BigInt(b);
+  } catch {
+    return a.length === b.length ? a <= b : a.length < b.length;
+  }
+}
+function createTransactionProvider(fetchImpl) {
+  let ctPromise;
+  const init = async () => ClientTransaction.create(await handleXMigration(fetchImpl));
+  const get = () => {
+    if (ctPromise === void 0) ctPromise = init();
+    return ctPromise;
+  };
+  return {
+    provider: async (method, path) => (await get()).generateTransactionId(method, path),
+    refresh: async () => {
+      ctPromise = init();
+      await ctPromise;
+    }
+  };
+}
+async function paginate(fetchPage, limit, stopAtId) {
+  const tweets = [];
+  const seen = /* @__PURE__ */ new Set();
+  let cursor;
+  let emptyStreak = 0;
+  let reachedWatermark = false;
+  while (tweets.length < limit && !reachedWatermark) {
+    const page = await fetchPage(cursor);
+    let fresh = 0;
+    for (const t of page.tweets) {
+      if (stopAtId !== void 0 && idLte(t.id, stopAtId)) {
+        reachedWatermark = true;
+        break;
+      }
+      if (seen.has(t.id)) continue;
+      seen.add(t.id);
+      tweets.push(t);
+      fresh += 1;
+    }
+    if (reachedWatermark) break;
+    if (fresh === 0) {
+      emptyStreak += 1;
+      if (emptyStreak >= EMPTY_PAGE_TOLERANCE) break;
+    } else {
+      emptyStreak = 0;
+    }
+    if (page.nextCursor === void 0 || page.nextCursor === cursor) break;
+    cursor = page.nextCursor;
+  }
+  const out = { tweets: tweets.slice(0, limit) };
+  if (cursor !== void 0 && !reachedWatermark) out.nextCursor = cursor;
+  return out;
+}
+function createEngine(deps) {
+  const txn = deps.transaction ? { provider: deps.transaction, refresh: async () => {
+  } } : createTransactionProvider(deps.fetchImpl);
+  const client = deps.client ?? createClient({
+    cookies: deps.cookies ?? getCookies(),
+    transaction: txn.provider,
+    ...deps.fetchImpl ? { fetchImpl: deps.fetchImpl } : {}
+  });
+  async function call(op, request, retried = false) {
+    const res = await client.get(op, request);
+    if (res.ok) return res.value;
+    if (res.error.code === "NOT_FOUND" && !retried) {
+      await txn.refresh();
+      return call(op, request, true);
+    }
+    throw new EngineError(res.error.code, res.error.message, res.error.status);
+  }
+  async function getUser(handle) {
+    const value = await call("UserByScreenName", userByScreenNameRequest({ screenName: handle }));
+    const result = findDict(value, "result", true)[0];
+    return parseUserResult(result);
+  }
+  return {
+    async search(query, opts) {
+      const product = opts?.product ?? "Top";
+      const limit = opts?.limit ?? DEFAULT_LIMIT;
+      const page = await paginate(async (cursor) => {
+        const value = await call("SearchTimeline", searchRequest({ query, product, cursor }));
+        return parseTimeline(value);
+      }, limit);
+      const out = { query, product, tweets: page.tweets };
+      if (page.nextCursor !== void 0) out.nextCursor = page.nextCursor;
+      return out;
+    },
+    user: getUser,
+    async userTweets(handle, opts) {
+      const profile = await getUser(handle);
+      if (!profile) throw new EngineError("NOT_FOUND", `user @${handle} not found`);
+      const limit = opts?.limit ?? DEFAULT_LIMIT;
+      return paginate(
+        async (cursor) => {
+          const req = userTweetsRequest({ userId: profile.id, replies: opts?.replies, cursor });
+          const value = await call(req.op, req);
+          return parseTimeline(value);
+        },
+        limit,
+        opts?.stopAtId
+      );
+    },
+    async bookmarks(opts) {
+      const limit = opts?.limit ?? DEFAULT_LIMIT;
+      return paginate(
+        async (cursor) => {
+          const value = await call("Bookmarks", bookmarksRequest({ cursor }));
+          return parseTimeline(value);
+        },
+        limit,
+        opts?.stopAtId
+      );
+    },
+    async thread(id) {
+      const value = await call("TweetDetail", tweetDetailRequest({ focalTweetId: id }));
+      return parseThread(value, id);
+    }
+  };
+}
+
+// src/commands/registry.ts
+var COMMANDS = [
+  {
+    name: "search",
+    cost: "cheap \u2014 the net",
+    summary: "Live X search. Cast a wide net; rank on engagement/recency metadata.",
+    usage: 'xrelay search "<query>" [--limit N] [--product Top|Latest|Media|People]\n       [--from <h>] [--to <h>] [--since YYYY-MM-DD] [--until YYYY-MM-DD]\n       [--lang xx] [--min-faves N] [--min-retweets N] [--filter media|links|replies|-replies ...]'
+  },
+  {
+    name: "user",
+    cost: "1 call",
+    summary: "Profile lookup: bio, followers, verified, counts, joined.",
+    usage: "xrelay user <handle|url>"
+  },
+  {
+    name: "user-posts",
+    cost: "medium",
+    summary: "A user's timeline (optionally including replies).",
+    usage: "xrelay user-posts <handle|url> [--replies] [--limit N]"
+  },
+  {
+    name: "thread",
+    cost: "expensive \u2014 full read",
+    summary: "A tweet plus its reply thread. Read only the finalists.",
+    usage: "xrelay thread <id|url>"
+  },
+  {
+    name: "bookmarks",
+    cost: "cheap \u2014 local cache",
+    summary: "Search your saved posts in the local cache. --sync to refresh, --live to hit X.",
+    usage: 'xrelay bookmarks [-q "<query>"] [--limit N] [--sort relevance|newest|likes|views|bookmarks]\n       [--sync] [--repair] [--live]'
+  },
+  {
+    name: "my-posts",
+    cost: "cheap \u2014 local cache",
+    summary: "Search your own posts in the local cache. --sync to refresh, --live to hit X.",
+    usage: 'xrelay my-posts [-q "<query>"] [--limit N] [--sort ...] [--handle <you>] [--sync] [--live]'
+  },
+  {
+    name: "sync",
+    cost: "medium \u2014 incremental",
+    summary: "Pull only NEW bookmarks/posts since the last sync into the local cache.",
+    usage: "xrelay sync bookmarks|posts|all [--handle <you>] [--repair]"
+  }
+];
+var commandNames = COMMANDS.map((c) => c.name);
+
+// src/cache/store.ts
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+function cacheDir() {
+  return process.env.XRELAY_CACHE_DIR ?? join2(homedir2(), ".xrelay");
+}
+function cachePath(source, dir) {
+  return join2(dir ?? cacheDir(), `${source}.json`);
+}
+function loadCache(source, dir) {
+  try {
+    const raw = readFileSync(cachePath(source, dir), "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return { source, tweets: {} };
+  }
+}
+function saveCache(file, dir) {
+  const target = cachePath(file.source, dir);
+  mkdirSync(dir ?? cacheDir(), { recursive: true });
+  const tmp = `${target}.${process.pid}.tmp`;
+  writeFileSync(tmp, `${JSON.stringify(file, null, 2)}
+`);
+  renameSync(tmp, target);
+}
+function isHigherId(a, b) {
+  try {
+    return BigInt(a) > BigInt(b);
+  } catch {
+    if (a.length !== b.length) return a.length > b.length;
+    return a > b;
+  }
+}
+function mergeTweets(file, fresh) {
+  let added = 0;
+  for (const t of fresh) {
+    if (!(t.id in file.tweets)) added += 1;
+    file.tweets[t.id] = t;
+  }
+  let watermark;
+  for (const id of Object.keys(file.tweets)) {
+    if (watermark === void 0 || isHigherId(id, watermark)) watermark = id;
+  }
+  if (watermark !== void 0) file.watermark = watermark;
+  return { added };
+}
+function allTweets(file) {
+  return Object.values(file.tweets);
+}
+
+// src/cache/search.ts
+var DEFAULT_LIMIT2 = 20;
+function tokenize(query) {
+  return query.toLowerCase().split(/\s+/).filter((token) => token.length > 0);
+}
+function countOccurrences(haystack, needle) {
+  if (needle.length === 0) return 0;
+  let count = 0;
+  let from = 0;
+  for (; ; ) {
+    const idx = haystack.indexOf(needle, from);
+    if (idx === -1) break;
+    count += 1;
+    from = idx + needle.length;
+  }
+  return count;
+}
+function scoreTweet(tweet, tokens) {
+  const haystack = `${tweet.text} ${tweet.author.handle} ${tweet.author.name}`.toLowerCase();
+  let score = 0;
+  for (const token of tokens) {
+    score += countOccurrences(haystack, token);
+  }
+  return score;
+}
+function compareIds(a, b) {
+  const ai = BigInt(a);
+  const bi = BigInt(b);
+  if (ai < bi) return -1;
+  if (ai > bi) return 1;
+  return 0;
+}
+function metric(tweet, key) {
+  return tweet.metrics[key] ?? 0;
+}
+function comparator(sort) {
+  switch (sort) {
+    case "newest":
+      return (a, b) => compareIds(b.tweet.id, a.tweet.id);
+    case "oldest":
+      return (a, b) => compareIds(a.tweet.id, b.tweet.id);
+    case "likes":
+      return (a, b) => metric(b.tweet, "likes") - metric(a.tweet, "likes");
+    case "views":
+      return (a, b) => metric(b.tweet, "views") - metric(a.tweet, "views");
+    case "bookmarks":
+      return (a, b) => metric(b.tweet, "bookmarks") - metric(a.tweet, "bookmarks");
+    default:
+      return (a, b) => b.score - a.score || compareIds(b.tweet.id, a.tweet.id);
+  }
+}
+function searchCache(tweets, query, opts = {}) {
+  const tokens = tokenize(query);
+  const sort = opts.sort ?? "relevance";
+  const limit = opts.limit ?? DEFAULT_LIMIT2;
+  const scored = [];
+  for (const tweet of tweets) {
+    const score = scoreTweet(tweet, tokens);
+    if (tokens.length > 0 && score === 0) continue;
+    scored.push({ tweet, score });
+  }
+  scored.sort(comparator(sort));
+  return scored.slice(0, limit).map((s) => s.tweet);
+}
+
+// src/cache/sync.ts
+var DEFAULT_MAX = 1e5;
+async function syncInto(file, fetchPage, opts) {
+  const max = opts.max ?? DEFAULT_MAX;
+  const stopAtId = opts.repair ? void 0 : file.watermark;
+  const page = await fetchPage(max, stopAtId);
+  const { added } = mergeTweets(file, page.tweets);
+  file.syncedAt = (/* @__PURE__ */ new Date()).toISOString();
+  saveCache(file, opts.dir);
+  const result = {
+    source: file.source,
+    added,
+    total: Object.keys(file.tweets).length
+  };
+  if (file.handle !== void 0) result.handle = file.handle;
+  if (file.watermark !== void 0) result.watermark = file.watermark;
+  return result;
+}
+function syncBookmarks(engine, opts = {}) {
+  const file = loadCache("bookmarks", opts.dir);
+  return syncInto(
+    file,
+    (limit, stopAtId) => engine.bookmarks({ limit, ...stopAtId !== void 0 ? { stopAtId } : {} }),
+    opts
+  );
+}
+function syncPosts(engine, handle, opts = {}) {
+  const file = loadCache("posts", opts.dir);
+  if (handle) file.handle = handle;
+  const h = file.handle;
+  if (!h) {
+    return Promise.reject(
+      new Error("posts sync needs your handle once: `xrelay sync posts --handle <you>`")
+    );
+  }
+  return syncInto(
+    file,
+    (limit, stopAtId) => engine.userTweets(h, { limit, ...stopAtId !== void 0 ? { stopAtId } : {} }),
+    opts
+  );
+}
+
+// src/commands/query.ts
+function buildSearchQuery(flags) {
+  const parts = [];
+  const base = flags.query.trim();
+  if (base) parts.push(base);
+  if (flags.from) parts.push(`from:${flags.from}`);
+  if (flags.to) parts.push(`to:${flags.to}`);
+  if (flags.since) parts.push(`since:${flags.since}`);
+  if (flags.until) parts.push(`until:${flags.until}`);
+  if (flags.lang) parts.push(`lang:${flags.lang}`);
+  if (flags.minFaves !== void 0) parts.push(`min_faves:${flags.minFaves}`);
+  if (flags.minRetweets !== void 0) parts.push(`min_retweets:${flags.minRetweets}`);
+  for (const f of flags.filter ?? []) {
+    const v = f.trim();
+    if (!v) continue;
+    parts.push(v.startsWith("-") ? `-filter:${v.slice(1)}` : `filter:${v}`);
+  }
+  return parts.join(" ");
+}
+
+// src/commands/runners.ts
+async function guard(command, fn) {
+  try {
+    return ok(command, await fn());
+  } catch (e) {
+    if (e instanceof EngineError) {
+      const hint = e.code === "AUTH_FAILED" ? "Re-log into x.com in your browser, or set XRELAY_COOKIES." : e.code === "FEATURE_DRIFT" ? "X rotated its API; refresh the query-ids/features in src/engine/ops.ts." : void 0;
+      return err(command, e.code, e.message, hint);
+    }
+    return err(command, "FETCH_FAILED", e instanceof Error ? e.message : String(e));
+  }
+}
+function runSearch(engine, opts) {
+  const raw = buildSearchQuery(opts);
+  if (!raw) return Promise.resolve(err("search", "INVALID_INPUT", "empty query"));
+  return guard(
+    "search",
+    () => engine.search(raw, {
+      ...opts.product ? { product: opts.product } : {},
+      ...opts.limit !== void 0 ? { limit: opts.limit } : {}
+    })
+  );
+}
+function runUser(engine, handle) {
+  if (!handle) return Promise.resolve(err("user", "INVALID_INPUT", "missing handle"));
+  return guard("user", () => engine.user(handle));
+}
+function runUserPosts(engine, opts) {
+  if (!opts.handle) return Promise.resolve(err("user-posts", "INVALID_INPUT", "missing handle"));
+  return guard(
+    "user-posts",
+    () => engine.userTweets(opts.handle, {
+      ...opts.replies ? { replies: true } : {},
+      ...opts.limit !== void 0 ? { limit: opts.limit } : {}
+    })
+  );
+}
+function runThread(engine, id) {
+  if (!id) return Promise.resolve(err("thread", "INVALID_INPUT", "missing tweet id/url"));
+  return guard("thread", () => engine.thread(id));
+}
+function syncOpts(opts) {
+  return {
+    ...opts.repair ? { repair: true } : {},
+    ...opts.max !== void 0 ? { max: opts.max } : {}
+  };
+}
+function runBookmarks(engine, opts = {}) {
+  if (opts.live) {
+    return guard(
+      "bookmarks",
+      () => engine.bookmarks({ ...opts.limit !== void 0 ? { limit: opts.limit } : {} })
+    );
+  }
+  return guard("bookmarks", async () => {
+    let added;
+    if (opts.sync || opts.repair) {
+      const r = await syncBookmarks(engine, syncOpts(opts));
+      added = r.added;
+    }
+    return viewCache("bookmarks", opts, added);
+  });
+}
+function runMyPosts(engine, opts = {}) {
+  if (opts.live) {
+    if (!opts.handle) {
+      return Promise.resolve(err("my-posts", "INVALID_INPUT", "--live needs --handle <you>"));
+    }
+    return guard(
+      "my-posts",
+      () => engine.userTweets(opts.handle, {
+        ...opts.limit !== void 0 ? { limit: opts.limit } : {}
+      })
+    );
+  }
+  return guard("my-posts", async () => {
+    let added;
+    if (opts.sync || opts.repair) {
+      const r = await syncPosts(engine, opts.handle, syncOpts(opts));
+      added = r.added;
+    }
+    return viewCache("posts", opts, added);
+  });
+}
+function viewCache(source, opts, added) {
+  const file = loadCache(source);
+  const tweets = searchCache(allTweets(file), opts.query ?? "", {
+    ...opts.limit !== void 0 ? { limit: opts.limit } : {},
+    ...opts.sort ? { sort: opts.sort } : {}
+  });
+  const total = Object.keys(file.tweets).length;
+  const view = { source, cached: true, total, tweets };
+  if (file.syncedAt !== void 0) view.syncedAt = file.syncedAt;
+  if (added !== void 0) view.added = added;
+  if (total === 0) {
+    view.hint = `cache is empty \u2014 run \`xrelay sync ${source}${source === "posts" ? " --handle <you>" : ""}\` first (or pass --live).`;
+  }
+  return view;
+}
+function runSync(engine, opts) {
+  const so = syncOpts(opts);
+  return guard("sync", async () => {
+    const results = [];
+    if (opts.source === "bookmarks" || opts.source === "all") {
+      results.push(await syncBookmarks(engine, so));
+    }
+    if (opts.source === "posts" || opts.source === "all") {
+      results.push(await syncPosts(engine, opts.handle, so));
+    }
+    return results;
+  });
+}
+
+// src/cli.ts
+import { fileURLToPath } from "url";
+var VALUE_FLAGS = /* @__PURE__ */ new Set([
+  "limit",
+  "product",
+  "from",
+  "to",
+  "since",
+  "until",
+  "lang",
+  "min-faves",
+  "min-retweets",
+  "filter",
+  "query",
+  "sort",
+  "handle",
+  "max"
+]);
+var BOOL_FLAGS = /* @__PURE__ */ new Set(["replies", "sync", "live", "repair"]);
+var SHORT_FLAGS = { q: "query" };
+function parseArgs(argv) {
+  const positionals = [];
+  const flags = {};
+  const bools = /* @__PURE__ */ new Set();
+  let command;
+  for (let i = 0; i < argv.length; i++) {
+    const token = argv[i];
+    if (token === void 0) continue;
+    const name = token.startsWith("--") ? token.slice(2) : token.startsWith("-") && token.length > 1 ? SHORT_FLAGS[token.slice(1)] : void 0;
+    if (name !== void 0) {
+      if (BOOL_FLAGS.has(name)) {
+        bools.add(name);
+      } else if (VALUE_FLAGS.has(name)) {
+        const value = argv[i + 1];
+        if (value !== void 0) {
+          const existing = flags[name] ?? [];
+          existing.push(value);
+          flags[name] = existing;
+          i += 1;
+        }
+      }
+      continue;
+    }
+    if (command === void 0) command = token;
+    else positionals.push(token);
+  }
+  return { command, positionals, flags, bools };
+}
+var first = (p, name) => p.flags[name]?.[0];
+var num = (p, name) => {
+  const v = first(p, name);
+  if (v === void 0) return void 0;
+  const n = Number(v);
+  return Number.isFinite(n) ? n : void 0;
+};
+var PRODUCTS = /* @__PURE__ */ new Set(["Top", "Latest", "Media", "People"]);
+var SORTS = /* @__PURE__ */ new Set(["relevance", "newest", "oldest", "likes", "views", "bookmarks"]);
+function buildCacheOpts(parsed) {
+  const limit = num(parsed, "limit");
+  const sort = first(parsed, "sort");
+  return {
+    ...first(parsed, "query") ? { query: first(parsed, "query") } : {},
+    ...limit !== void 0 ? { limit } : {},
+    ...sort && SORTS.has(sort) ? { sort } : {},
+    ...parsed.bools.has("live") ? { live: true } : {},
+    ...parsed.bools.has("sync") ? { sync: true } : {},
+    ...parsed.bools.has("repair") ? { repair: true } : {},
+    ...num(parsed, "max") !== void 0 ? { max: num(parsed, "max") } : {}
+  };
+}
+function helpText() {
+  const lines = ["xrelay \u2014 deep-research over X/Twitter", "", "Commands:"];
+  for (const c of COMMANDS) {
+    lines.push(`  ${c.name.padEnd(11)} ${c.summary}  [${c.cost}]`);
+  }
+  lines.push("", "Run `xrelay <command>` with --help-style usage in SKILL.md.");
+  return lines.join("\n");
+}
+function buildSearchOpts(parsed) {
+  const product = first(parsed, "product");
+  const limit = num(parsed, "limit");
+  const minFaves = num(parsed, "min-faves");
+  const minRetweets = num(parsed, "min-retweets");
+  return {
+    query: parsed.positionals.join(" "),
+    ...limit !== void 0 ? { limit } : {},
+    ...product && PRODUCTS.has(product) ? { product } : {},
+    ...first(parsed, "from") ? { from: first(parsed, "from") } : {},
+    ...first(parsed, "to") ? { to: first(parsed, "to") } : {},
+    ...first(parsed, "since") ? { since: first(parsed, "since") } : {},
+    ...first(parsed, "until") ? { until: first(parsed, "until") } : {},
+    ...first(parsed, "lang") ? { lang: first(parsed, "lang") } : {},
+    ...minFaves !== void 0 ? { minFaves } : {},
+    ...minRetweets !== void 0 ? { minRetweets } : {},
+    ...parsed.flags.filter ? { filter: parsed.flags.filter } : {}
+  };
+}
+async function dispatch(parsed, engine) {
+  const { command } = parsed;
+  const target = parsed.positionals[0] ?? "";
+  switch (command) {
+    case "search":
+      return runSearch(engine, buildSearchOpts(parsed));
+    case "user":
+      return runUser(engine, extractHandle(target) ?? target);
+    case "user-posts":
+      return runUserPosts(engine, {
+        handle: extractHandle(target) ?? target,
+        replies: parsed.bools.has("replies"),
+        ...num(parsed, "limit") !== void 0 ? { limit: num(parsed, "limit") } : {}
+      });
+    case "thread":
+      return runThread(engine, extractTweetId(target) ?? target);
+    case "bookmarks":
+      return runBookmarks(engine, buildCacheOpts(parsed));
+    case "my-posts":
+      return runMyPosts(engine, {
+        ...buildCacheOpts(parsed),
+        ...first(parsed, "handle") ? { handle: first(parsed, "handle") } : {}
+      });
+    case "sync": {
+      const source = target === "posts" || target === "all" ? target : "bookmarks";
+      return runSync(engine, {
+        source,
+        ...first(parsed, "handle") ? { handle: first(parsed, "handle") } : {},
+        repair: parsed.bools.has("repair"),
+        ...num(parsed, "max") !== void 0 ? { max: num(parsed, "max") } : {}
+      });
+    }
+    default:
+      return err("cli", "UNKNOWN_COMMAND", `unknown command: ${command ?? "(none)"}`);
+  }
+}
+async function run(argv, engine) {
+  const parsed = parseArgs(argv);
+  if (parsed.command === void 0 || parsed.command === "help") {
+    process.stdout.write(`${helpText()}
+`);
+    return 0;
+  }
+  if (!commandNames.includes(parsed.command)) {
+    process.stdout.write(
+      `${toJson(err("cli", "UNKNOWN_COMMAND", `unknown command: ${parsed.command}`))}
+`
+    );
+    return 2;
+  }
+  const eng = engine ?? createEngine({});
+  const envelope = await dispatch(parsed, eng);
+  process.stdout.write(`${toJson(envelope)}
+`);
+  return envelope.ok ? 0 : 1;
+}
+var isEntry = import.meta.main === true || process.argv[1] !== void 0 && fileURLToPath(import.meta.url) === process.argv[1];
+if (isEntry) {
+  run(process.argv.slice(2)).then(
+    (code) => {
+      process.exitCode = code;
+    },
+    (e) => {
+      process.stdout.write(
+        `${toJson(err("cli", "FATAL", e instanceof Error ? e.message : String(e)))}
+`
+      );
+      process.exitCode = 1;
+    }
+  );
+}
+export {
+  COMMANDS,
+  EngineError,
+  buildSearchQuery,
+  commandNames,
+  createEngine,
+  dispatch,
+  err,
+  extractCookies,
+  extractHandle,
+  extractTweetId,
+  getCookies,
+  loadCache,
+  ok,
+  parseArgs,
+  parseCookies,
+  run,
+  runBookmarks,
+  runSearch,
+  runThread,
+  runUser,
+  runUserPosts,
+  saveCache,
+  searchCache,
+  syncBookmarks,
+  syncPosts,
+  toJson
+};
+//# sourceMappingURL=index.js.map