npm - emusks - Versions diffs - 2.3.4 → 2.3.6 - Mend

emusks 2.3.4 → 2.3.6

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (15) hide show

package/package.json +1 -1
package/src/castle.js +261 -0
package/src/flow-jetfuel.js +288 -0
package/src/flow.js +2 -2
package/src/helpers/index.js +2 -0
package/src/helpers/report.js +100 -0
package/src/helpers/tweets.js +4 -0
package/src/helpers/users.js +4 -0
package/src/index.js +7 -1
package/src/scripts/castle-mint-test.js +8 -0
package/src/scripts/login-test.js +28 -0
package/src/scripts/verify-session.js +11 -0
package/src/static/graphql.js +1 -1
package/src/static/v1.1.js +1 -1
package/src/vendor/castle-sdk.min.js +3 -0

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "emusks",
-  "version": "2.3.4",
+  "version": "2.3.6",
   "description": "Reverse-engineered Twitter API client. Log in and interact with the unofficial X API using any client identity - web, Android, iOS, or TweetDeck",
   "keywords": [
     "client",

package/src/castle.js ADDED Viewed

@@ -0,0 +1,261 @@
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import vm from "node:vm";
+import { parseHTML } from "linkedom";
+const HERE = dirname(fileURLToPath(import.meta.url));
+export const DEFAULT_CASTLE_PK = "pk_AvRa79bHyJSYSQHnRpcVtzyxetSvFerx";
+export const CASTLE_MODULE_ID = "84197";
+const DEFAULT_UA =
+  "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36";
+function pluginArray() {
+  const names = [
+    "PDF Viewer",
+    "Chrome PDF Viewer",
+    "Chromium PDF Viewer",
+    "Microsoft Edge PDF Viewer",
+    "WebKit built-in PDF",
+  ];
+  const arr = names.map((name) => ({
+    name,
+    description: "Portable Document Format",
+    filename: "internal-pdf-viewer",
+    length: 2,
+  }));
+  arr.item = (i) => arr[i] || null;
+  arr.namedItem = (n) => arr.find((p) => p.name === n) || null;
+  arr.refresh = () => {};
+  return arr;
+}
+function mimeTypeArray() {
+  const arr = [
+    { type: "application/pdf", suffixes: "pdf", description: "Portable Document Format" },
+    { type: "text/pdf", suffixes: "pdf", description: "Portable Document Format" },
+  ];
+  arr.item = (i) => arr[i] || null;
+  arr.namedItem = (n) => arr.find((m) => m.type === n) || null;
+  return arr;
+}
+function buildSandbox(userAgent) {
+  const { document } = parseHTML(
+    "<!DOCTYPE html><html><head><title>X</title></head><body></body></html>",
+  );
+  const define = (prop, value) => {
+    try {
+      Object.defineProperty(document, prop, { get: () => value, configurable: true });
+    } catch {}
+  };
+  define("cookie", "");
+  define("readyState", "complete");
+  define("referrer", "https://x.com/");
+  define("visibilityState", "visible");
+  define("hidden", false);
+  document.hasFocus = () => true;
+  const s = {};
+  s.globalThis = s;
+  s.self = s;
+  s.window = s;
+  s.global = s;
+  s.top = s;
+  s.parent = s;
+  s.frames = s;
+  s.name = "";
+  s.closed = false;
+  s.origin = "https://x.com";
+  s.isSecureContext = true;
+  s.document = document;
+  s.navigator = {
+    userAgent,
+    appVersion: userAgent.replace("Mozilla/", ""),
+    appName: "Netscape",
+    appCodeName: "Mozilla",
+    platform: "MacIntel",
+    vendor: "Google Inc.",
+    vendorSub: "",
+    product: "Gecko",
+    productSub: "20030107",
+    language: "en-US",
+    languages: ["en-US", "en"],
+    hardwareConcurrency: 10,
+    deviceMemory: 8,
+    maxTouchPoints: 0,
+    cookieEnabled: true,
+    onLine: true,
+    doNotTrack: null,
+    webdriver: false,
+    pdfViewerEnabled: true,
+    plugins: pluginArray(),
+    mimeTypes: mimeTypeArray(),
+    userAgentData: {
+      brands: [
+        { brand: "Not(A:Brand", version: "8" },
+        { brand: "Chromium", version: "144" },
+        { brand: "Google Chrome", version: "144" },
+      ],
+      mobile: false,
+      platform: "macOS",
+      getHighEntropyValues: async () => ({
+        platform: "macOS",
+        platformVersion: "15.0.0",
+        architecture: "arm",
+        model: "",
+        uaFullVersion: "144.0.0.0",
+        bitness: "64",
+      }),
+    },
+    permissions: { query: async () => ({ state: "prompt" }) },
+    mediaDevices: { enumerateDevices: async () => [] },
+    connection: { effectiveType: "4g", rtt: 50, downlink: 10, saveData: false },
+    sendBeacon: () => true,
+    javaEnabled: () => false,
+  };
+  s.screen = {
+    width: 1512,
+    height: 982,
+    availWidth: 1512,
+    availHeight: 944,
+    colorDepth: 30,
+    pixelDepth: 30,
+    availLeft: 0,
+    availTop: 0,
+    orientation: { type: "landscape-primary", angle: 0 },
+  };
+  s.location = {
+    href: "https://x.com/i/flow/login",
+    protocol: "https:",
+    host: "x.com",
+    hostname: "x.com",
+    origin: "https://x.com",
+    pathname: "/i/flow/login",
+    search: "",
+    hash: "",
+  };
+  s.history = { length: 2, state: null, pushState: () => {}, replaceState: () => {} };
+  const store = {};
+  s.localStorage = {
+    getItem: (k) => (k in store ? store[k] : null),
+    setItem: (k, v) => {
+      store[k] = String(v);
+    },
+    removeItem: (k) => {
+      delete store[k];
+    },
+    clear: () => {
+      for (const k in store) delete store[k];
+    },
+    key: (i) => Object.keys(store)[i] ?? null,
+    get length() {
+      return Object.keys(store).length;
+    },
+  };
+  s.sessionStorage = { getItem: () => null, setItem: () => {}, removeItem: () => {}, clear: () => {} };
+  s.innerWidth = 1512;
+  s.innerHeight = 850;
+  s.outerWidth = 1512;
+  s.outerHeight = 944;
+  s.screenX = 0;
+  s.screenY = 0;
+  s.pageXOffset = 0;
+  s.pageYOffset = 0;
+  s.devicePixelRatio = 2;
+  s.chrome = { app: { isInstalled: false }, runtime: {}, csi: () => ({}), loadTimes: () => ({}) };
+  s.Intl = Intl;
+  s.matchMedia = (q) => ({
+    matches: false,
+    media: q,
+    addEventListener: () => {},
+    removeEventListener: () => {},
+    addListener: () => {},
+    removeListener: () => {},
+  });
+  s.addEventListener = () => {};
+  s.removeEventListener = () => {};
+  s.dispatchEvent = () => true;
+  s.requestAnimationFrame = (cb) => setTimeout(() => cb(performance.now()), 0);
+  s.cancelAnimationFrame = (id) => clearTimeout(id);
+  s.requestIdleCallback = (cb) => setTimeout(() => cb({ timeRemaining: () => 50, didTimeout: false }), 0);
+  s.cancelIdleCallback = (id) => clearTimeout(id);
+  s.setTimeout = setTimeout;
+  s.clearTimeout = clearTimeout;
+  s.setInterval = setInterval;
+  s.clearInterval = clearInterval;
+  s.setImmediate = setImmediate;
+  s.queueMicrotask = queueMicrotask;
+  s.performance = performance;
+  s.crypto = globalThis.crypto;
+  s.btoa = (str) => Buffer.from(str, "binary").toString("base64");
+  s.atob = (str) => Buffer.from(str, "base64").toString("binary");
+  s.TextEncoder = TextEncoder;
+  s.TextDecoder = TextDecoder;
+  s.console = { log: () => {}, warn: () => {}, error: () => {}, info: () => {}, debug: () => {} };
+  s.Image = class {
+    set src(_v) {}
+  };
+  s.XMLHttpRequest = class {
+    open() {}
+    setRequestHeader() {}
+    send() {}
+    addEventListener() {}
+  };
+  s.getComputedStyle = () => ({ getPropertyValue: () => "" });
+  return s;
+}
+export function createCastleMinter(opts = {}) {
+  const {
+    pk = DEFAULT_CASTLE_PK,
+    userAgent = DEFAULT_UA,
+    sdkPath = join(HERE, "vendor", "castle-sdk.min.js"),
+    sdkSource,
+  } = opts;
+  const src = sdkSource ?? readFileSync(sdkPath, "utf8");
+  const sandbox = buildSandbox(userAgent);
+  let factory = null;
+  sandbox.webpackChunk_twitter_responsive_web = {
+    push: (entry) => {
+      const modules = entry?.[1];
+      if (modules && modules[CASTLE_MODULE_ID]) factory = modules[CASTLE_MODULE_ID];
+    },
+  };
+  const ctx = vm.createContext(sandbox);
+  vm.runInContext(src, ctx, { filename: "castle-sdk.min.js" });
+  if (!factory) throw new Error(`castle sdk module ${CASTLE_MODULE_ID} not found (X may have rotated the chunk)`);
+  const moduleObj = { exports: {} };
+  factory(moduleObj, moduleObj.exports);
+  const api = moduleObj.exports;
+  if (typeof api.configure !== "function" || typeof api.createRequestToken !== "function") {
+    throw new Error("castle sdk did not expose configure/createRequestToken (chunk changed)");
+  }
+  const configured = api.configure({ pk });
+  return async function mint() {
+    const instance = await Promise.resolve(configured);
+    const token = instance?.createRequestToken
+      ? await instance.createRequestToken()
+      : await api.createRequestToken();
+    if (!token) throw new Error("castle createRequestToken returned empty");
+    return token;
+  };
+}
+let sharedMinter = null;
+export async function mintCastleToken(opts = {}) {
+  if (!sharedMinter || opts.fresh) sharedMinter = createCastleMinter(opts);
+  return sharedMinter();
+}

package/src/flow-jetfuel.js ADDED Viewed

@@ -0,0 +1,288 @@
+import { ClientTransaction, handleXMigration } from "x-client-transaction-id";
+import { mintCastleToken } from "./castle.js";
+import clients from "./clients.js";
+import getCycleTLS from "./cycletls.js";
+import { decodeJetfuel } from "./parsers/jetfuel.js";
+const GUEST_ACTIVATE_URL = "https://api.x.com/1.1/guest/activate.json";
+const JFAPI_BASE = "https://x.com/i/jfapi";
+const SURFACE = "onboarding/web";
+const UA =
+  "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36";
+const MAX_STEPS = 15;
+class CookieSession {
+  constructor(cycleTLS, proxy, timeout) {
+    this.cycleTLS = cycleTLS;
+    this.cookies = {};
+    this.proxy = proxy;
+    this.timeout = timeout;
+  }
+  cookieString() {
+    return Object.entries(this.cookies)
+      .map(([k, v]) => `${k}=${v}`)
+      .join("; ");
+  }
+  eat(res) {
+    const setCookie = res.headers?.["set-cookie"] || res.headers?.["Set-Cookie"];
+    if (!setCookie) return;
+    for (const cookie of Array.isArray(setCookie) ? setCookie : [setCookie]) {
+      const [key, ...rest] = cookie.split(";")[0].split("=");
+      if (rest.length) this.cookies[key.trim()] = rest.join("=").trim();
+    }
+  }
+  async request(url, method, { headers = {}, body, responseType } = {}) {
+    const h = { ...headers };
+    const cookieStr = this.cookieString();
+    if (cookieStr) h.Cookie = cookieStr;
+    const res = await this.cycleTLS(
+      url,
+      {
+        body,
+        ja3: clients.web.fingerprints.ja3,
+        ja4r: clients.web.fingerprints.ja4r,
+        userAgent: UA,
+        headers: h,
+        proxy: this.proxy || undefined,
+        responseType,
+        timeout: this.timeout,
+      },
+      method,
+    );
+    this.eat(res);
+    return res;
+  }
+}
+function jfHeaders(guestToken, tid, theme) {
+  const headers = {
+    authorization: `Bearer ${clients.web.bearer}`,
+    "x-guest-token": guestToken,
+    "x-jf-v": "JP-5",
+    "x-jf-client-theme": theme,
+    "x-twitter-active-user": "yes",
+    "x-twitter-client-language": "en",
+    "accept-language": "en",
+    accept: "*/*",
+    timezone: Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC",
+    Origin: "https://x.com",
+    Referer: "https://x.com/i/flow/login",
+  };
+  if (tid) headers["x-client-transaction-id"] = tid;
+  return headers;
+}
+async function getGuestToken(session) {
+  const res = await session.request(GUEST_ACTIVATE_URL, "post", {
+    headers: { Authorization: `Bearer ${clients.web.bearer}` },
+  });
+  let body = res.body ?? res.data;
+  if (typeof body === "string") body = JSON.parse(body);
+  if (!body?.guest_token) throw new Error("failed to obtain guest token");
+  return body.guest_token;
+}
+async function toBuffer(res) {
+  if (typeof res.arrayBuffer === "function") return Buffer.from(await res.arrayBuffer());
+  const body = res.body ?? res.data;
+  if (Buffer.isBuffer(body)) return body;
+  if (body && typeof body === "object" && body.data) return Buffer.from(body.data);
+  return Buffer.from(String(body ?? ""), "utf8");
+}
+function decodeStrings(buffer) {
+  try {
+    return decodeJetfuel(buffer).strings || [];
+  } catch {
+    return [];
+  }
+}
+function extractActionIds(strings) {
+  const ids = new Set();
+  for (const s of strings) {
+    const m = String(s).match(/onboarding\/web\/actions\/([a-z0-9_]+)/i);
+    if (m) ids.add(m[1]);
+  }
+  return [...ids];
+}
+function extractServerError(strings) {
+  const idx = strings.findIndex((s) => /^errors?$/i.test(String(s).trim()));
+  if (idx === -1) return null;
+  for (let i = idx + 1; i < strings.length; i++) {
+    const s = String(strings[i]).trim();
+    if (s.length > 8 && /[a-z]\s[a-z]/i.test(s) && !/^error$/i.test(s)) return s;
+  }
+  return null;
+}
+function extractUserId(cookies) {
+  const twid = (cookies.twid || "").replace(/"/g, "");
+  for (const prefix of ["u=", "u%3D"]) {
+    if (twid.includes(prefix)) return twid.split(prefix)[1].split("&")[0].replace(/"/g, "");
+  }
+  return null;
+}
+async function resolve(value, onRequest, type) {
+  if (value != null && value !== "") return value;
+  if (onRequest) {
+    const v = await onRequest(type);
+    if (v != null && v !== "") return v;
+  }
+  throw new Error(
+    `the login flow needs "${type}" but none was provided. pass it directly or handle it in onRequest.`,
+  );
+}
+export default async function flowLoginJetfuel(opts) {
+  const {
+    username,
+    password,
+    email,
+    phone,
+    onRequest,
+    getCastleToken = () => mintCastleToken(),
+    proxy,
+    timeout,
+    theme = "light",
+    debug,
+  } = opts;
+  const log = debug ? (...a) => console.error("[jf-flow]", ...a) : () => {};
+  const identifier = username || email;
+  if (!identifier) throw new Error("username or email is required for login");
+  if (!password) throw new Error("password is required for login");
+  const cycleTLS = await getCycleTLS();
+  const session = new CookieSession(cycleTLS, proxy, timeout);
+  const migrationDoc = await handleXMigration();
+  const transaction = new ClientTransaction(migrationDoc);
+  await transaction.initialize();
+  const tid = (method, path) => transaction.generateTransactionId(method, path);
+  const guestToken = await getGuestToken(session);
+  log("guest token", guestToken);
+  const landingPath = `/i/jfapi/${SURFACE}?mode=login`;
+  const landing = await session.request(`${JFAPI_BASE}/${SURFACE}?mode=login`, "get", {
+    headers: jfHeaders(guestToken, await tid("GET", landingPath), theme),
+    responseType: "arraybuffer",
+  });
+  if (landing.status !== 200) throw new Error(`landing failed: ${landing.status}`);
+  let strings = decodeStrings(await toBuffer(landing));
+  log("landing actions", extractActionIds(strings));
+  const post = async (action, fields) => {
+    const path = `/i/jfapi/${SURFACE}/actions/${action}`;
+    const castle = await getCastleToken(action);
+    const form = new URLSearchParams({ ...fields, $castle_token: castle }).toString();
+    const headers = jfHeaders(guestToken, await tid("POST", path), theme);
+    headers["content-type"] = "application/x-www-form-urlencoded";
+    if (session.cookies.ct0) headers["x-csrf-token"] = session.cookies.ct0;
+    const res = await session.request(`${JFAPI_BASE}/${SURFACE}/actions/${action}`, "post", {
+      headers,
+      body: form,
+      responseType: "arraybuffer",
+    });
+    const buffer = await toBuffer(res);
+    const responseStrings = decodeStrings(buffer);
+    log(`POST ${action} -> ${res.status}`, extractActionIds(responseStrings));
+    if (res.status !== 200) {
+      throw new Error(`action ${action} failed: ${res.status} - ${buffer.toString("utf8").slice(0, 200)}`);
+    }
+    const genericError = responseStrings.find((s) => /something went wrong/i.test(s));
+    if (genericError && responseStrings.length < 6) {
+      throw new Error(
+        `action ${action} rejected ("${genericError}") - usually an invalid or missing $castle_token.`,
+      );
+    }
+    const serverError = extractServerError(responseStrings);
+    if (serverError) {
+      if (/temporarily limited|rate.?limit|try again later/i.test(serverError)) {
+        throw new Error(`login rate-limited by X: "${serverError.trim()}" (back off this account/IP)`);
+      }
+      throw new Error(`action ${action} error: "${serverError.trim()}"`);
+    }
+    return responseStrings;
+  };
+  const sessionTokenFrom = (arr) => {
+    const i = arr.findIndex((s) => /^session_token$/i.test(String(s).trim()));
+    if (i === -1) return null;
+    const v = String(arr[i + 1] || "").trim();
+    return /^[0-9a-f-]{20,}$/i.test(v) ? v : null;
+  };
+  let sessionToken = null;
+  const withSession = (fields) => (sessionToken ? { session_token: sessionToken, ...fields } : fields);
+  strings = await post("begin_login", { username_or_email: identifier });
+  sessionToken = sessionTokenFrom(strings) || sessionToken;
+  let step = 0;
+  while (!session.cookies.auth_token && step < MAX_STEPS) {
+    step++;
+    const lower = strings.map((s) => String(s).toLowerCase());
+    const has = (needle) => lower.some((s) => s.includes(needle));
+    if (has("incorrect") || has("wrong password")) {
+      throw new Error("login denied: the password was incorrect");
+    }
+    if (has("suspend") || has("locked") || has("denied")) {
+      throw new Error("login denied: account locked or suspended");
+    }
+    const wantsPasswordEntry = has("enter your password") || has("login_enter_password");
+    const wantsTwoFactor = has("two_factor") || has("2fa") || has("authentication code");
+    const wantsEmailCode = has("acid") || has("verifycode") || has("verification code") ||
+      (has("verification") && has("code"));
+    const wantsAlternate = has("alternate") || has("login_enter_alternate_identifier");
+    if (wantsTwoFactor) {
+      const code = await resolve(null, onRequest, "two_factor_code");
+      strings = await post("login_enter_two_factor", withSession({ text: code }));
+      sessionToken = sessionTokenFrom(strings) || sessionToken;
+      continue;
+    }
+    if (wantsEmailCode) {
+      const code = await resolve(null, onRequest, "email_code");
+      strings = await post("login_acid", withSession({ text: code }));
+      sessionToken = sessionTokenFrom(strings) || sessionToken;
+      continue;
+    }
+    if (wantsAlternate) {
+      const value = await resolve(email || phone, onRequest, "alternate_identifier");
+      strings = await post("login_enter_alternate_identifier", withSession({ text: value }));
+      sessionToken = sessionTokenFrom(strings) || sessionToken;
+      continue;
+    }
+    if (wantsPasswordEntry || has("password")) {
+      strings = await post("login_enter_password", withSession({ password }));
+      sessionToken = sessionTokenFrom(strings) || sessionToken;
+      continue;
+    }
+    throw new Error(
+      `unhandled jetfuel login step. decoded actions: [${extractActionIds(strings).join(", ")}]. ` +
+        `strings sample: ${JSON.stringify(strings.slice(0, 20))}`,
+    );
+  }
+  if (!session.cookies.auth_token) {
+    throw new Error(`login did not complete after ${step} steps`);
+  }
+  return {
+    authToken: session.cookies.auth_token,
+    csrfToken: session.cookies.ct0 || null,
+    userId: extractUserId(session.cookies),
+    cookies: { ...session.cookies },
+  };
+}

package/src/flow.js CHANGED Viewed

@@ -135,7 +135,7 @@ class CookieSession {
 function getFlowHeaders(guestToken) {
   const headers = {
-    Authorization: `Bearer ${clients.tweetdeck.bearer}`,
+    Authorization: `Bearer ${clients.web.bearer}`,
     "Content-Type": "application/json",
     Accept: "*/*",
     "Accept-Language": "en-US",
@@ -178,7 +178,7 @@ async function makeRequest(session, headers, flowToken, subtaskData) {
 async function getGuestToken(session) {
   const response = await session.post(GUEST_ACTIVATE_URL, {
-    headers: { Authorization: `Bearer ${clients.tweetdeck.bearer}` },
+    headers: { Authorization: `Bearer ${clients.web.bearer}` },
   });
   if (response.status !== 200) {

package/src/helpers/index.js CHANGED Viewed

@@ -12,6 +12,7 @@ import * as lists from "./lists.js";
 import * as media from "./media.js";
 import * as notes from "./notes.js";
 import * as notifications from "./notifications.js";
+import * as report from "./report.js";
 import * as search from "./search.js";
 import * as spaces from "./spaces.js";
 import * as syndication from "./syndication.js";
@@ -52,6 +53,7 @@ export default function initHelpers(proto) {
   namespace(proto, "spaces", spaces);
   namespace(proto, "account", account);
   namespace(proto, "notifications", notifications);
+  namespace(proto, "report", report);
   namespace(proto, "trends", trends);
   namespace(proto, "topics", topics);
   namespace(proto, "media", media);

package/src/helpers/report.js ADDED Viewed

@@ -0,0 +1,100 @@
+export const REPORT_REASONS = {
+  hate: "HateOrAbuseSimpleOption",
+  abuse: "HateOrAbuseSimpleOption",
+  harassment: "HateOrAbuseSimpleOption",
+  violent_speech: "ViolentSpeechSimpleOption",
+  child_safety: "ChildSafetySimpleOption",
+  private: "PrivateContentSimpleOption",
+  nonconsensual: "PrivateContentSimpleOption",
+  illegal: "IRBSimpleOption",
+  regulated: "IRBSimpleOption",
+  spam: "SpamSimpleOption",
+  self_harm: "SuicideSelfHarmSimpleOption",
+  suicide: "SuicideSelfHarmSimpleOption",
+  adult: "AdultContentSimpleOption",
+  nsfw: "AdultContentSimpleOption",
+  violent_media: "ViolentMediaSimpleOption",
+  graphic: "ViolentMediaSimpleOption",
+  impersonation: "ImpersonationSimpleOption",
+  terrorism: "TerrorismSimpleOption",
+  extremism: "TerrorismSimpleOption",
+};
+function resolveReason(reason) {
+  if (typeof reason !== "string" || !reason) throw new Error("a report reason is required");
+  if (reason.endsWith("SimpleOption")) return reason;
+  const mapped = REPORT_REASONS[reason.toLowerCase().replace(/[\s-]+/g, "_")];
+  if (!mapped) {
+    throw new Error(
+      `unknown report reason "${reason}". use a raw *SimpleOption id or one of: ${Object.keys(REPORT_REASONS).join(", ")}`,
+    );
+  }
+  return mapped;
+}
+async function submitReport(instance, { variant, startLocation, reason }) {
+  const init = await instance.v1_1("report/flow", {
+    params: { flow_name: "report-flow" },
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({
+      input_flow_data: {
+        requested_variant: JSON.stringify(variant),
+        flow_context: { start_location: { location: startLocation } },
+      },
+    }),
+  });
+  const { flow_token } = await init.json();
+  if (!flow_token) throw new Error("failed to start report flow");
+  const res = await instance.v1_1("report/flow", {
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({
+      flow_token,
+      subtask_inputs: [
+        {
+          subtask_id: "single-selection",
+          choice_selection: { link: "next_link", selected_choices: [reason] },
+        },
+      ],
+    }),
+  });
+  return await res.json();
+}
+export async function tweet(tweetId, reason, opts = {}) {
+  if (!tweetId) throw new Error("tweetId is required");
+  return await submitReport(this, {
+    startLocation: opts.startLocation || "home",
+    reason: resolveReason(reason),
+    variant: {
+      client_app_id: "3033300",
+      client_location: "home:home:",
+      client_referer: "/home",
+      is_media: false,
+      is_promoted: false,
+      reported_tweet_id: tweetId,
+      source: "reporttweet",
+      ...opts.variant,
+    },
+  });
+}
+export async function user(userId, reason, opts = {}) {
+  if (!userId) throw new Error("userId is required");
+  return await submitReport(this, {
+    startLocation: opts.startLocation || "profile",
+    reason: resolveReason(reason),
+    variant: {
+      client_app_id: "3033300",
+      client_location: "profile:header:",
+      client_referer: opts.username ? `/${opts.username}` : "/",
+      is_media: false,
+      is_promoted: false,
+      reported_user_id: userId,
+      source: "reportprofile",
+      ...opts.variant,
+    },
+  });
+}