@ikenxuan/amagi 6.5.0 → 6.6.0

package/dist/default/index.cjs

@@ -2,7 +2,7 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_rolldown_runtime = require("../rolldown-runtime-VH7oDXx4.cjs");
+const require_rolldown_runtime = require("../rolldown-runtime-C0BPl7ul.cjs");
 let node_url = require("node:url");
 node_url = require_rolldown_runtime.__toESM(node_url, 1);
 let node_events = require("node:events");
@@ -2151,6 +2151,1695 @@ const bilibiliFetcher = {
 	fetchEmojiList: fetchEmojiList$3
 };
 //#endregion
+//#region src/platform/douyin/passport/sm3.ts
+/**
+* SM3 摘要（GM/T 0004-2012），抖音 bdms 签名链使用的变体
+*
+* 与标准实现的唯一差异：字符串按 `charCodeAt` 逐字符取字节（非 UTF-8 编码），
+* 与浏览器里 bdms 的 `strToBytes` 行为一致。签名输入均为 ASCII，实际不会踩到多字节分支，
+* 但仍保留该分支以保证与浏览器实现逐位一致。
+*/
+/** 循环左移 32 位 */
+const rotl = (x, n) => {
+	const shift = n % 32;
+	return (x << shift | x >>> 32 - shift) >>> 0;
+};
+/** 轮常量 Tj */
+const tj = (j) => j < 16 ? 2043430169 : 2055708042;
+/** 布尔函数 FFj */
+const ff = (j, x, y, z) => j < 16 ? (x ^ y ^ z) >>> 0 : (x & y | x & z | y & z) >>> 0;
+/** 布尔函数 GGj */
+const gg = (j, x, y, z) => j < 16 ? (x ^ y ^ z) >>> 0 : (x & y | ~x & z) >>> 0;
+/** 初始向量 IV */
+const IV = [
+	1937774191,
+	1226093241,
+	388252375,
+	3666478592,
+	2842636476,
+	372324522,
+	3817729613,
+	2969243214
+];
+/** 字符串转字节数组：逐字符 charCodeAt，大于一字节时按大端拆分 */
+const strToBytes = (input) => {
+	const bytes = [];
+	for (let i = 0; i < input.length; i++) {
+		let code = input.charCodeAt(i);
+		const chunk = [];
+		do {
+			chunk.push(code & 255);
+			code >>= 8;
+		} while (code);
+		bytes.push(...chunk.reverse());
+	}
+	return bytes;
+};
+/** 消息扩展：生成 W[0..67] 与 W'[0..63]（后者放在 68 之后） */
+const expand = (block) => {
+	const w = new Array(132);
+	for (let i = 0; i < 16; i++) w[i] = (block[i * 4] << 24 | block[i * 4 + 1] << 16 | block[i * 4 + 2] << 8 | block[i * 4 + 3]) >>> 0;
+	for (let j = 16; j < 68; j++) {
+		let x = w[j - 16] ^ w[j - 9] ^ rotl(w[j - 3], 15);
+		x = x ^ rotl(x, 15) ^ rotl(x, 23);
+		w[j] = (x ^ rotl(w[j - 13], 7) ^ w[j - 6]) >>> 0;
+	}
+	for (let j = 0; j < 64; j++) w[j + 68] = (w[j] ^ w[j + 4]) >>> 0;
+	return w;
+};
+/** SM3 压缩函数：就地更新寄存器 */
+const compress = (reg, block) => {
+	const w = expand(block);
+	const r = reg.slice();
+	for (let j = 0; j < 64; j++) {
+		let ss1 = rotl(r[0], 12) + r[4] + rotl(tj(j), j) & 4294967295;
+		ss1 = rotl(ss1 >>> 0, 7);
+		const ss2 = (ss1 ^ rotl(r[0], 12)) >>> 0;
+		const tt1 = ff(j, r[0], r[1], r[2]) + r[3] + ss2 + w[j + 68] >>> 0;
+		const tt2 = gg(j, r[4], r[5], r[6]) + r[7] + ss1 + w[j] >>> 0;
+		r[3] = r[2];
+		r[2] = rotl(r[1], 9);
+		r[1] = r[0];
+		r[0] = tt1;
+		r[7] = r[6];
+		r[6] = rotl(r[5], 19);
+		r[5] = r[4];
+		r[4] = (tt2 ^ rotl(tt2, 9) ^ rotl(tt2, 17)) >>> 0;
+	}
+	for (let i = 0; i < 8; i++) reg[i] = (reg[i] ^ r[i]) >>> 0;
+};
+/** 按 SM3 规则填充消息（0x80 + 0 + 64 位比特长度） */
+const pad = (bytes) => {
+	const padded = bytes.slice();
+	const bitLength = bytes.length * 8;
+	padded.push(128);
+	while (padded.length % 64 !== 56) padded.push(0);
+	const high = Math.floor(bitLength / 4294967296);
+	for (let i = 0; i < 4; i++) padded.push(high >>> (3 - i) * 8 & 255);
+	for (let i = 0; i < 4; i++) padded.push(bitLength >>> (3 - i) * 8 & 255);
+	return padded;
+};
+/**
+* 计算 SM3 摘要
+* @param message 待摘要的字符串或字节数组
+* @returns 32 字节摘要
+*/
+const sm3 = (message) => {
+	const bytes = typeof message === "string" ? strToBytes(message) : message;
+	const reg = IV.slice();
+	const padded = pad(bytes);
+	for (let i = 0; i < padded.length; i += 64) compress(reg, padded.slice(i, i + 64));
+	const digest = new Array(32);
+	for (let i = 0; i < 8; i++) {
+		digest[i * 4] = reg[i] >>> 24 & 255;
+		digest[i * 4 + 1] = reg[i] >>> 16 & 255;
+		digest[i * 4 + 2] = reg[i] >>> 8 & 255;
+		digest[i * 4 + 3] = reg[i] & 255;
+	}
+	return digest;
+};
+/**
+* 连续两次 SM3（bdms 对 URL 与盐值的处理方式）
+* @param message 待摘要的字符串或字节数组
+* @returns 32 字节摘要
+*/
+const sm3Twice = (message) => sm3(sm3(message));
+/**
+* 十六进制摘要，仅用于测试与排查
+* @param message 待摘要的字符串或字节数组
+*/
+const sm3Hex = (message) => sm3(message).map((byte) => byte.toString(16).padStart(2, "0")).join("");
+//#endregion
+//#region src/platform/douyin/passport/aBogus.ts
+/**
+* a_bogus 签名（bdms 1.0.1.19 形态，passport 登录接口使用）
+*
+* 抖音同时在线着多个 a_bogus 版本：`@ikenxuan/amagi` 里带的是 web 数据接口用的旧版
+* （盐值 `cus`、pageId 6241），而 login.douyin.com 的 passport SDK 用的是本文件实现的
+* 新版（盐值 `dhzx`、pageId 7571、sdkVersion 1.0.1.19-fix.01）。两者互不通用，
+* 所以这里单独实现一份，不复用 amagi 的签名。
+*
+* 算法为社区公开的逆向结论（见 PR 说明中的参考链接），此处按 kkk 的代码风格重写：
+* - SM3 为抖音变体（连续两次摘要），见 ./sm3
+* - RC4 为变体：S 盒递减初始化 + `j = (j * S[i] + j + K[i]) % 256`
+* - Base64 使用自定义字符表，UA 段用 s3、最终结果用 s4
+* - `random()` 保留了原实现里 `Math.random`（函数对象而非调用）参与位运算的行为，
+*   该表达式恒为 NaN → 位运算结果恒为 0，这里直接写成常量而不是照抄错误代码
+*/
+/** RC4 / S 盒长度 */
+const BOX_SIZE = 256;
+/** bdms 1.0.1.19 的盐值 */
+const SALT = "dhzx";
+/** bdms SDK 版本号，同时也是 passport 通用参数里的 p_bd */
+const BDMS_SDK_VERSION = "1.0.1.19-fix.01";
+/** 版本号基准时间戳（bdms 内部按 14 天为一档计数） */
+const VERSION_EPOCH = 17218368e5;
+/** 模块加载时刻，等价于浏览器里的「进入页面时间」 */
+const ENTER_PAGE_TS = Date.now();
+/** 自定义 Base64 字符表 */
+const BASE64_TABLES = {
+	s0: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=",
+	s1: "Dkdpgh4ZKsQB80/Mfvw36XI1R25+WUAlEi7NLboqYTOPuzmFjJnryx9HVGcaStCe=",
+	s2: "Dkdpgh4ZKsQB80/Mfvw36XI1R25-WUAlEi7NLboqYTOPuzmFjJnryx9HVGcaStCe=",
+	s3: "ckdp1h4ZKsUB80/Mfvw36XIgR25+WQAlEi7NLboqYTOPuzmFjJnryx9HVGDaStCe",
+	s4: "Dkdpgh2ZmsQB80/MfvV36XI1R45-WUAlEixNLwoqYTOPuzKFjJnry79HbGcaStCe"
+};
+/**
+* 浏览器环境快照。服务器上没有真实窗口，这里给出一组常见的桌面分辨率组合；
+* 该值只影响指纹内容本身，不需要与任何真实设备对应。
+*/
+const BROWSER_ENV = {
+	innerWidth: 2048,
+	innerHeight: 960,
+	outerWidth: 2554,
+	outerHeight: 1386,
+	availWidth: 2560,
+	availHeight: 1392,
+	sizeWidth: 2560,
+	sizeHeight: 1440,
+	platform: "Win32"
+};
+/** RC4 密钥：bdms 用 `[1 / 256, 1 % 256, 14 % 256]` 造出 "\x00\x01\x0e" */
+const rc4Key = String.fromCharCode(...[
+	1 / BOX_SIZE,
+	1 % BOX_SIZE,
+	14 % BOX_SIZE
+]);
+/**
+* 变体 RC4
+* @param key 密钥
+* @param text 明文（按 charCode 处理）
+*/
+const rc4 = (key, text) => {
+	const s = new Uint8Array(BOX_SIZE);
+	const k = new Uint8Array(BOX_SIZE);
+	for (let i = 0; i < BOX_SIZE; i++) {
+		s[i] = 255 - i;
+		k[i] = key.charCodeAt(i % key.length);
+	}
+	let j = 0;
+	for (let i = 0; i < BOX_SIZE; i++) {
+		j = (j * s[i] + j + k[i]) % BOX_SIZE;
+		[s[i], s[j]] = [s[j], s[i]];
+	}
+	let x = 0;
+	let y = 0;
+	let cipher = "";
+	for (let n = 0; n < text.length; n++) {
+		x = (x + 1) % BOX_SIZE;
+		y = (y + s[x]) % BOX_SIZE;
+		[s[x], s[y]] = [s[y], s[x]];
+		cipher += String.fromCharCode(text.charCodeAt(n) ^ s[(s[x] + s[y]) % BOX_SIZE]);
+	}
+	return cipher;
+};
+/**
+* 自定义字符表 Base64
+* @param input 明文（按 charCode 取低 8 位）
+* @param table 字符表名（s0 ~ s4）
+*/
+const base64 = (input, table) => {
+	const alphabet = BASE64_TABLES[table];
+	let output = "";
+	let i = 0;
+	while (i < input.length) {
+		const c1 = input.charCodeAt(i++);
+		const c2 = input.charCodeAt(i++);
+		const c3 = input.charCodeAt(i++);
+		const chunk = (c1 & 255) << 16 | (Number.isNaN(c2) ? 0 : (c2 & 255) << 8) | (Number.isNaN(c3) ? 0 : c3 & 255);
+		output += alphabet.charAt(chunk >> 18 & 63);
+		output += alphabet.charAt(chunk >> 12 & 63);
+		output += Number.isNaN(c2) ? "=" : alphabet.charAt(chunk >> 6 & 63);
+		output += Number.isNaN(c3) ? "=" : alphabet.charAt(chunk & 63);
+	}
+	return output;
+};
+/**
+* 生成 4 字节随机混淆段
+* @param seed 两字节的基准值
+* @param flag 0 = 完全随机；1 = 高位固定为 0；2 = 低位受限、高位固定为 178
+*/
+const mix = (seed, flag) => {
+	const r = Math.random() * 65535 | 0;
+	let low = r & 255;
+	let high = r >> 8 & 255;
+	if (flag === 1) high = 0;
+	if (flag === 2) {
+		low = Math.random() * 240 >> 0;
+		if (low > 109) low += low % 2 + 1;
+		high = 178;
+	}
+	return [
+		low & 170 | seed[0] & 85,
+		low & 85 | seed[0] & 170,
+		high & 170 | seed[1] & 85,
+		high & 85 | seed[1] & 170
+	];
+};
+/** SDK 版本号拆成数字数组，非纯数字段（如 `19-fix`）取 0 */
+const versionSegments = (version) => version.split(".").map((segment) => ~~Number(segment));
+/** 每 3 字节扩成 4 字节，掺入随机位 */
+const spread = (bytes) => {
+	const masks = [
+		145,
+		110,
+		66,
+		189,
+		44,
+		211
+	];
+	const out = [];
+	for (let i = 0; i < bytes.length; i += 3) {
+		if (i + 2 >= bytes.length) {
+			out.push(bytes[i]);
+			if (bytes[i + 1] !== void 0) out.push(bytes[i + 1]);
+			continue;
+		}
+		const noise = Math.random() * 1e3 & 255;
+		out.push(noise & masks[0] | bytes[i] & masks[1], noise & masks[2] | bytes[i + 1] & masks[3], noise & masks[4] | bytes[i + 2] & masks[5], bytes[i] & masks[0] | bytes[i + 1] & masks[2] | bytes[i + 2] & masks[4]);
+	}
+	return out;
+};
+/**
+* 生成 a_bogus
+* @param query 除 a_bogus 之外的完整查询串（未加 `?`，保持实际发送顺序）
+* @param userAgent 与请求头一致的 UA
+* @returns a_bogus 参数值（未做 URL 编码）
+*/
+const aBogus = (query, userAgent) => {
+	const salted = query.endsWith(SALT) ? query : query + SALT;
+	const queryDigest = sm3Twice(salted);
+	const saltDigest = sm3Twice(SALT);
+	const uaEncoded = base64(rc4(rc4Key, userAgent), "s3");
+	const uaDigest = sm3(uaEncoded);
+	const now = Date.now();
+	const ink = now - 1;
+	/** 指纹字节表，下标沿用 bdms 内部编号，便于与逆向资料对照 */
+	const b = {};
+	b[24] = 41;
+	b[26] = (now - VERSION_EPOCH) / 1e3 / 60 / 60 / 24 / 14 >> 0;
+	b[27] = 6;
+	b[28] = now - ENTER_PAGE_TS + 3 & 255;
+	b[29] = now & 255;
+	b[30] = now >> 8 & 255;
+	b[31] = now >> 16 & 255;
+	b[32] = now >> 24 & 255;
+	b[33] = now / 2 ** 32 & 255;
+	b[34] = now / 2 ** 40 & 255;
+	b[35] = 1;
+	b[36] = 0;
+	b[38] = 129;
+	b[39] = 0;
+	b[40] = 0;
+	b[41] = 0;
+	b[42] = 0;
+	b[43] = 0;
+	b[44] = 14;
+	b[45] = 0;
+	b[46] = 0;
+	b[47] = 0;
+	b[48] = queryDigest[9];
+	b[49] = queryDigest[18];
+	b[51] = queryDigest[3];
+	b[52] = saltDigest[10];
+	b[53] = saltDigest[19];
+	b[55] = saltDigest[4];
+	b[56] = uaDigest[11];
+	b[57] = uaDigest[21];
+	b[59] = uaDigest[5];
+	b[60] = ink & 255;
+	b[61] = ink >> 8 & 255;
+	b[62] = ink >> 16 & 255;
+	b[63] = ink >> 24 & 255;
+	b[64] = ink / 2 ** 32 & 255;
+	b[65] = ink / 2 ** 40 & 255;
+	b[66] = 3;
+	b[67] = 147;
+	b[68] = 29;
+	b[69] = 0;
+	b[70] = 0;
+	b[71] = 239;
+	b[72] = 24;
+	b[73] = 0;
+	b[74] = 0;
+	const envSnapshot = Object.values(BROWSER_ENV).join("|");
+	const envBytes = Array.from(envSnapshot, (char) => char.charCodeAt(0));
+	b[79] = envBytes.length & 255;
+	b[80] = envBytes.length >> 8 & 255;
+	const tail = `${now + 3 & 255},`;
+	const tailBytes = Array.from(tail, (char) => char.charCodeAt(0));
+	b[84] = tailBytes.length & 255;
+	b[85] = tailBytes.length >> 8 & 255;
+	const version = versionSegments(BDMS_SDK_VERSION);
+	const noise = mix([version[0], version[1]], 0).concat(mix([version[0], version[1]], 2));
+	const checksum = [
+		24,
+		26,
+		27,
+		28,
+		29,
+		30,
+		31,
+		32,
+		33,
+		34,
+		35,
+		36,
+		38,
+		39,
+		40,
+		41,
+		42,
+		43,
+		44,
+		45,
+		46,
+		47,
+		48,
+		49,
+		51,
+		52,
+		53,
+		55,
+		56,
+		57,
+		59,
+		60,
+		61,
+		62,
+		63,
+		64,
+		65,
+		66,
+		67,
+		68,
+		69,
+		70,
+		71,
+		72,
+		73,
+		74,
+		79,
+		80,
+		84,
+		85
+	].reduce((acc, key) => acc ^ b[key], noise.reduce((acc, value) => acc ^ value, 0));
+	/** 打乱后的字节顺序，与 bdms 内部的 tlist 一致 */
+	const shuffled = [
+		34,
+		44,
+		56,
+		61,
+		73,
+		29,
+		70,
+		45,
+		35,
+		49,
+		38,
+		66,
+		51,
+		68,
+		28,
+		48,
+		64,
+		47,
+		30,
+		71,
+		26,
+		55,
+		31,
+		69,
+		59,
+		40,
+		62,
+		63,
+		27,
+		72,
+		41,
+		74,
+		57,
+		52,
+		42,
+		39,
+		33,
+		67,
+		53,
+		43,
+		65,
+		46,
+		36,
+		24,
+		60,
+		32,
+		79,
+		80,
+		84,
+		85
+	].map((key) => b[key]);
+	const payload = spread(shuffled.concat(envBytes, tailBytes, [checksum]));
+	const prefix = String.fromCharCode(...mix([3, 82], 1));
+	const encrypted = rc4(String.fromCharCode(211), String.fromCharCode(...noise.concat(payload)));
+	return base64(prefix + encrypted, "s4");
+};
+//#endregion
+//#region src/platform/douyin/passport/cookieJar.ts
+/**
+* 登录流程用的轻量 CookieJar
+*
+* 登录过程会跨 `www.douyin.com` / `login.douyin.com` / `ttwid.bytedance.com` 三个域，
+* 且同一个 cookie 名会被多次下发（例如 `ttwid` 在换取可信指纹后会被替换、
+* `sessionid` 在二次验证通过后会被升级）。这里只做一件事：**按下发顺序覆盖同名 cookie**，
+* 保证最终拿到的永远是最后一次下发的值，同时正确处理服务端的删除指令。
+*
+* 不做域/路径隔离：整个登录流程都在抖音自己的域下，隔离反而会漏掉跨子域下发的凭证。
+*
+* 另外承载一小部分**本地会话状态**（见 `INTERNAL_PREFIX`）：passport 的几个接口对外是
+* 无状态的，会话全靠 cookie 串在调用之间传递，而 bd-ticket-guard 需要在多次调用之间
+* 记住自己生成的密钥与服务端签发的票据。这些条目以 `__amagi_` 开头，
+* `toString()` 不会把它们放进 Cookie 请求头，只有 `serialize()` 才会带上。
+*/
+/** 本地会话状态的 cookie 名前缀，这些条目永远不会发给服务端 */
+const INTERNAL_PREFIX = "__amagi_";
+/** 是否为本地会话状态条目 */
+const isInternal = (name) => name.startsWith(INTERNAL_PREFIX);
+/** 判断一条 Set-Cookie 是否表示「删除该 cookie」 */
+const isDeletion = (value, attributes) => {
+	if (value === "") return true;
+	for (const attribute of attributes) {
+		const [rawName, ...rest] = attribute.split("=");
+		const name = rawName.trim().toLowerCase();
+		const rawValue = rest.join("=").trim();
+		if (name === "max-age") {
+			const maxAge = Number(rawValue);
+			if (Number.isFinite(maxAge) && maxAge <= 0) return true;
+		}
+		if (name === "expires") {
+			const expires = Date.parse(rawValue);
+			if (Number.isFinite(expires) && expires <= Date.now()) return true;
+		}
+	}
+	return false;
+};
+var CookieJar = class {
+	/** Map 保留插入顺序，重复 set 只更新值、不改变位置 */
+	cookies = /* @__PURE__ */ new Map();
+	/**
+	* @param initial 初始 cookie 串，形如 `a=1; b=2`
+	*/
+	constructor(initial) {
+		if (initial) this.merge(initial);
+	}
+	/** 当前持有的 cookie 数量 */
+	get size() {
+		return this.cookies.size;
+	}
+	/**
+	* 写入一条 cookie
+	* @param name cookie 名
+	* @param value cookie 值
+	*/
+	set(name, value) {
+		this.cookies.set(name, value);
+		return this;
+	}
+	/**
+	* 读取一条 cookie
+	* @param name cookie 名
+	*/
+	get(name) {
+		return this.cookies.get(name);
+	}
+	/**
+	* 是否持有某条 cookie
+	* @param name cookie 名
+	*/
+	has(name) {
+		return this.cookies.has(name);
+	}
+	/**
+	* 合并一段 `name=value; name=value` 形式的 cookie 串
+	* @param cookieString cookie 串，空值直接忽略
+	*/
+	merge(cookieString) {
+		if (!cookieString) return this;
+		for (const pair of cookieString.split(";")) {
+			const index = pair.indexOf("=");
+			if (index <= 0) continue;
+			const name = pair.slice(0, index).trim();
+			const value = pair.slice(index + 1).trim();
+			if (name && value) this.cookies.set(name, value);
+		}
+		return this;
+	}
+	/**
+	* 应用响应的 Set-Cookie 头
+	* @param setCookies 单条或多条 Set-Cookie 原始值
+	*/
+	applySetCookie(setCookies) {
+		if (!setCookies) return this;
+		for (const line of Array.isArray(setCookies) ? setCookies : [setCookies]) {
+			const [pair, ...attributes] = line.split(";");
+			const index = pair.indexOf("=");
+			if (index <= 0) continue;
+			const name = pair.slice(0, index).trim();
+			const value = pair.slice(index + 1).trim();
+			if (!name) continue;
+			if (isDeletion(value, attributes)) {
+				this.cookies.delete(name);
+				continue;
+			}
+			this.cookies.set(name, value);
+		}
+		return this;
+	}
+	/**
+	* 是否已经拿到登录态凭证（`ttwid` 是匿名设备指纹，不算登录）
+	*/
+	isLoggedIn() {
+		return this.has("sessionid") || this.has("sessionid_ss") || this.has("sid_guard");
+	}
+	/** 序列化为可直接放进 Cookie 请求头的字符串，不含本地会话状态 */
+	toString() {
+		return [...this.cookies].filter(([name]) => !isInternal(name)).map(([name, value]) => `${name}=${value}`).join("; ");
+	}
+	/**
+	* 序列化为在两次调用之间传递的会话串，包含本地会话状态
+	*
+	* 登录流程内部用这个；最终落库的登录凭证用 `toString()`，避免把本地密钥写进配置。
+	*/
+	serialize() {
+		return [...this.cookies].map(([name, value]) => `${name}=${value}`).join("; ");
+	}
+	/** 导出为普通对象，便于断言与日志 */
+	toJSON() {
+		return Object.fromEntries(this.cookies);
+	}
+};
+//#endregion
+//#region src/platform/douyin/passport/params.ts
+/**
+* passport 登录 SDK 的参数与签名构造
+*
+* login.douyin.com 的接口一共要过四道签名：
+* - `p_no`：SDK 版本相关参数排序后取 sha256
+* - `sign`：`排序后的前 10 个 query 参数 & 排序后的 body 参数 & app_key` 取 sha256
+* - `qs`：参与 sign 的参数名列表逐字节异或 5 后转十六进制
+* - `x-tt-passport-aid-sign` 请求头：以 appKey 为消息、当日 UTC 正午时间戳为密钥做 HMAC 派生
+*
+* 这些常量都是 SDK 自身的版本号与固定 app_key，属于协议的一部分，不含任何设备/账号信息。
+*/
+/** passport 登录 SDK 的 app_key */
+const APP_KEY = "163e7ce78d58971a41f5b969996d85c2";
+/** 抖音 web 的 aid */
+const PASSPORT_AID = "6383";
+/** 登录接口域名 */
+const LOGIN_HOST = "login.douyin.com";
+/** 抖音主站域名 */
+const WEB_HOST = "www.douyin.com";
+/** 登录 SDK（normal 形态）版本号 */
+const JSSDK_VERSION = "3.1.3";
+/** 验证页 SDK（lite 形态）版本号 */
+const LITE_JSSDK_VERSION = "5.1.2";
+/** 验证页使用的 authn SDK 版本号 */
+const LITE_AUTHN_VERSION = "1.0.0.420-web";
+/** 各子 SDK 版本号，参与 p_no 计算 */
+const SDK_VERSIONS = {
+	pVer: "1.1.3",
+	pZt: "3.3.14",
+	pUi: "2.1.9-alpha.6",
+	pCa: "4.0.17",
+	pCaReal: "1.0.0.874"
+};
+/** 与 aBogus 中 BROWSER_ENV 对应的窗口尺寸，用于生成 account_sdk_source_info */
+const ENV_VIEWPORT = {
+	innerWidth: 2048,
+	innerHeight: 960,
+	outerWidth: 2554,
+	outerHeight: 1386
+};
+const sha256Hex = (input) => node_crypto.default.createHash("sha256").update(input, "utf8").digest("hex");
+const hmacSha256 = (key, message) => node_crypto.default.createHmac("sha256", Buffer.from(key)).update(Buffer.from(message)).digest();
+const hexToBytes = (hex) => Uint8Array.from(hex.match(/.{2}/g)?.map((byte) => parseInt(byte, 16)) ?? []);
+/**
+* 逐字节异或 5 后转十六进制，SDK 用它编码参数名列表、验证码与密码
+* @param input 明文
+*/
+const xor5Hex = (input) => Array.from(Buffer.from(input, "utf8"), (byte) => (byte ^ 5).toString(16).padStart(2, "0")).join("");
+/** 随机十六进制串，用于 biz_trace_id 一类的追踪 ID */
+const randomHex = (length) => node_crypto.default.randomBytes(Math.ceil(length / 2)).toString("hex").slice(0, length);
+/** 当日 UTC 12:00 的秒级时间戳，aid-sign 以此为密钥基准 */
+const utcNoonTimestamp = (now = /* @__PURE__ */ new Date()) => Math.floor(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate(), 12, 0, 0, 0) / 1e3);
+/**
+* 按 SDK 规则序列化参数：键名排序后拼成 `k=v&k=v`
+* @param params 参数对象
+* @param limit 大于等于 0 时只取排序后的前 limit 个键
+*/
+const serializeSorted = (params, limit = -1) => {
+	const keys = Object.keys(params).sort();
+	if (limit >= 0) keys.splice(limit);
+	return {
+		text: keys.map((key) => `${key}=${typeof params[key] === "object" ? JSON.stringify(params[key]) : params[key]}`).join("&"),
+		keys
+	};
+};
+/**
+* 计算 sign 与 qs
+* @param params query 参数（仅排序后的前 10 个参与签名）
+* @param data body 参数，GET 请求传空对象
+*/
+const makeSignAndQs = (params, data = {}) => {
+	const { text: paramsText, keys } = serializeSorted(params, 10);
+	const { text: dataText } = serializeSorted(data);
+	return {
+		sign: sha256Hex(`${paramsText}&${dataText}&app_key=${APP_KEY}`),
+		qs: xor5Hex(keys.join(","))
+	};
+};
+/**
+* 计算 p_no
+* @param pTs 毫秒时间戳，与 query 里的 p_ts 保持一致
+*/
+const makePNo = (pTs) => {
+	const parts = {
+		passport_jssdk_version: JSSDK_VERSION,
+		p_bd: BDMS_SDK_VERSION,
+		p_ca: SDK_VERSIONS.pCa,
+		p_ts: pTs,
+		p_ver: SDK_VERSIONS.pVer,
+		p_zt: SDK_VERSIONS.pZt
+	};
+	return sha256Hex(Object.keys(parts).sort().map((key) => `${key}=${parts[key]}`).join("&"));
+};
+/**
+* HKDF 风格的密钥派生，aid-sign 内部使用
+* @param keyHex 初始密钥（十六进制）
+* @param length 输出长度
+*/
+const deriveKey = (keyHex, length) => {
+	const output = [];
+	let previous = "";
+	let counter = 0;
+	while (output.length < length) {
+		counter++;
+		const message = Uint8Array.from([...hexToBytes(previous), counter]);
+		previous = hmacSha256(hexToBytes(keyHex), message).toString("hex");
+		output.push(...hexToBytes(previous));
+	}
+	return Uint8Array.from(output.slice(0, length));
+};
+/**
+* 计算 `x-tt-passport-aid-sign` 请求头
+* @param urlPath 接口路径，如 `/passport/web/get_qrcode/`
+* @param timestamp 当日 UTC 正午时间戳（秒），默认取当前
+*/
+const makeAidSign = (urlPath, timestamp = utcNoonTimestamp()) => {
+	const encoder = new TextEncoder();
+	const ts = String(timestamp);
+	const seed = hmacSha256(encoder.encode(ts), encoder.encode(APP_KEY)).toString("hex");
+	const key = deriveKey(seed, 32);
+	return hmacSha256(key, encoder.encode(`aid=${PASSPORT_AID}&path=${urlPath}&ts=${ts}`)).toString("hex");
+};
+/**
+* 生成 account_sdk_source_info：SDK 采集的浏览器环境快照，异或 5 后转十六进制。
+*
+* 上游参考实现内联的是作者本机抓包值（含显卡型号、堆内存占用、带 query 的个人主页 URL），
+* 不适合进仓库，这里换成一份等价形态的通用快照。
+*
+* 实测服务端在 `get_qrcode` 阶段不校验该字段内容（删掉、置空、填垃圾值都同样返回
+* `error_code: 0`），保留它只是为了与 SDK 的真实请求形态一致。
+*/
+const makeAccountSdkSourceInfo = () => xor5Hex(JSON.stringify({
+	hardwareConcurrency: 8,
+	webdriver: false,
+	chromedriver: false,
+	shelldriver: false,
+	plugins: 5,
+	innerHeight: ENV_VIEWPORT.innerHeight,
+	innerWidth: ENV_VIEWPORT.innerWidth,
+	outerHeight: ENV_VIEWPORT.outerHeight,
+	outerWidth: ENV_VIEWPORT.outerWidth,
+	webgl: {
+		vendor: "Google Inc. (Intel)",
+		renderer: "ANGLE (Intel, Intel(R) UHD Graphics Direct3D11 vs_5_0 ps_5_0, D3D11)"
+	},
+	performance: {
+		timeOrigin: Date.now(),
+		navigationTiming: {
+			entryType: "navigation",
+			initiatorType: "navigation",
+			name: `https://${WEB_HOST}/`,
+			renderBlockingStatus: "non-blocking"
+		}
+	},
+	browser: {
+		bit_protocol: "false",
+		bit_helper: false
+	}
+}));
+/**
+* 构造 passport 登录 SDK 的通用 query 参数
+*
+* 参数顺序即实际发送顺序：SDK 各拦截器依次注入，`request_host` 在这里先编码一次，
+* 拼 URL 时会再编码一次，所以线上抓包看到的是双重编码。
+* @param extra 业务参数（GET 时并入 query）
+*/
+const makeCommonParams = (extra = {}) => {
+	const pTs = String(Date.now());
+	return {
+		passport_jssdk_version: JSSDK_VERSION,
+		passport_jssdk_type: "normal",
+		is_from_ttaccountsdk: "1",
+		aid: PASSPORT_AID,
+		language: "zh",
+		account_app_language: "zh-CN",
+		ts: String(utcNoonTimestamp()),
+		...Object.fromEntries(Object.entries(extra).map(([key, value]) => [key, String(value)])),
+		is_from_iesaccountsaas: "1",
+		p_ui: SDK_VERSIONS.pUi,
+		p_ca: SDK_VERSIONS.pCa,
+		p_ca_real: SDK_VERSIONS.pCaReal,
+		account_sdk_source: "web",
+		account_sdk_source_info: makeAccountSdkSourceInfo(),
+		p_js_v: JSSDK_VERSION,
+		p_js_t: "pro",
+		p_zt: SDK_VERSIONS.pZt,
+		p_ver: SDK_VERSIONS.pVer,
+		p_ver_real: "0",
+		request_host: encodeURIComponent(`https://${WEB_HOST}`),
+		p_bd: BDMS_SDK_VERSION,
+		p_ts: pTs,
+		p_no: makePNo(pTs),
+		biz_trace_id: randomHex(8),
+		device_platform: "web_app"
+	};
+};
+/**
+* 构造验证页 SDK（lite 形态）的固定 query 参数
+* @param bizTraceId 业务追踪 ID
+*/
+const makeLiteParams = (bizTraceId) => ({
+	passport_jssdk_version: LITE_JSSDK_VERSION,
+	passport_jssdk_type: "lite",
+	is_from_ttaccountsdk: "1",
+	aid: PASSPORT_AID,
+	language: "zh",
+	account_app_language: "zh-CN",
+	new_authn_sdk_version: LITE_AUTHN_VERSION,
+	biz_trace_id: bizTraceId
+});
+/**
+* 按插入顺序序列化为查询串（不排序，`request_host` 因此产生二次编码）
+* @param params 参数对象
+*/
+const serializeQuery = (params) => Object.entries(params).map(([key, value]) => `${key}=${encodeURIComponent(String(value))}`).join("&");
+//#endregion
+//#region src/platform/douyin/passport/ticketGuard.ts
+/**
+* bd-ticket-guard 设备票据
+*
+* 抖音的设备真实性风控。常见的说法是必须从浏览器 localStorage 里导出一对密钥才能用，
+* 但那只适用于「已登录之后」的接口 —— **登录流程本身就是票据的签发入口**：
+*
+* 1. 本地生成一对 P-256 密钥
+* 2. 把公钥写进 `bd_ticket_guard_client_data` cookie，在取二维码**之前**交给服务端
+* 3. 服务端在后续响应的 `bd-ticket-guard-server-data` 头里签发 `{ticket, ts_sign, client_cert}`
+* 4. 之后每个请求用 `ECDH(自己的私钥, client_cert 里的服务端公钥)` 派生的密钥
+*    对 `ticket=…&path=…&timestamp=…` 做 HMAC，放进 `bd-ticket-guard-client-data` 头
+*
+* 全程不需要浏览器，票据是服务端真实签发给我们自己这把密钥的，没有任何伪造数据。
+* 密钥与票据以 `__amagi_` 前缀存在 CookieJar 里，只在调用之间传递，不会发给服务端。
+*/
+/** 交给服务端的公钥所在的 cookie */
+const CLIENT_DATA_COOKIE = "bd_ticket_guard_client_data";
+/** 声明 web 域版本的 cookie */
+const CLIENT_WEB_DOMAIN_COOKIE = "bd_ticket_guard_client_web_domain";
+/** 服务端也可能把签发结果放在这条 cookie 里 */
+const SERVER_DATA_COOKIE = "bd_ticket_guard_server_data";
+/** 服务端签发结果所在的响应头 */
+const SERVER_DATA_HEADER = "bd-ticket-guard-server-data";
+/** 本地会话状态：PKCS#8 私钥（base64） */
+const KEY_ENTRY = `${INTERNAL_PREFIX}tg_key`;
+/** 本地会话状态：服务端签发的票据 */
+const TICKET_ENTRY = `${INTERNAL_PREFIX}tg_ticket`;
+/** 本地会话状态：票据的时间戳签名 */
+const TS_SIGN_ENTRY = `${INTERNAL_PREFIX}tg_ts_sign`;
+/** 本地会话状态：ECDH 派生出的 HMAC 密钥（hex） */
+const ECDH_ENTRY = `${INTERNAL_PREFIX}tg_ecdh`;
+/** SDK 声明的 ticket-guard 版本 */
+const GUARD_VERSION = "2";
+/** SDK 声明的迭代版本 */
+const ITERATION_VERSION = "1";
+/** P-256 公钥的 SubjectPublicKeyInfo 前缀，其后紧跟 65 字节未压缩点 */
+const P256_SPKI_PREFIX = Buffer.from("3059301306072a8648ce3d020106082a8648ce3d030107034200", "hex");
+/** 被签名内容的字段列表，需与实际拼接顺序一致 */
+const REQ_CONTENT = "ticket,path,timestamp";
+/** 紧凑 JSON，与浏览器的 `JSON.stringify` 一致 */
+const compactJson = (value) => JSON.stringify(value);
+/**
+* 从 PEM 证书或 `pub.<base64>` 里取出服务端公钥
+* @param clientCert 服务端下发的 client_cert
+*/
+const readServerPublicKey = (clientCert) => {
+	if (clientCert.startsWith("pub.")) {
+		const point = Buffer.from(clientCert.slice(4), "base64");
+		const body = point.length === 65 ? point.subarray(1) : point;
+		const spki = Buffer.concat([
+			P256_SPKI_PREFIX,
+			Buffer.from([4]),
+			body
+		]);
+		return node_crypto.default.createPublicKey({
+			key: spki,
+			format: "der",
+			type: "spki"
+		});
+	}
+	return new node_crypto.default.X509Certificate(clientCert).publicKey;
+};
+/**
+* bd-ticket-guard 会话
+*
+* 状态全部读写自传入的 CookieJar，因此与 passport 的无状态调用形态天然兼容。
+*/
+var TicketGuard = class {
+	jar;
+	/**
+	* @param jar 当前会话 cookie
+	*/
+	constructor(jar) {
+		this.jar = jar;
+	}
+	/** 本会话的私钥，缺失时生成一把并写回 CookieJar */
+	get privateKey() {
+		const stored = this.jar.get(KEY_ENTRY);
+		if (stored) return node_crypto.default.createPrivateKey({
+			key: Buffer.from(stored, "base64"),
+			format: "der",
+			type: "pkcs8"
+		});
+		const { privateKey } = node_crypto.default.generateKeyPairSync("ec", { namedCurve: "prime256v1" });
+		const der = privateKey.export({
+			format: "der",
+			type: "pkcs8"
+		});
+		this.jar.set(KEY_ENTRY, der.toString("base64"));
+		return privateKey;
+	}
+	/** 未压缩格式的公钥（base64），即 `bd-ticket-guard-ree-public-key` */
+	get reePublicKey() {
+		const spki = node_crypto.default.createPublicKey(this.privateKey).export({
+			format: "der",
+			type: "spki"
+		});
+		return spki.subarray(spki.length - 65).toString("base64");
+	}
+	/** 已签发的票据，未签发时为 undefined */
+	get state() {
+		const ticket = this.jar.get(TICKET_ENTRY);
+		const tsSign = this.jar.get(TS_SIGN_ENTRY);
+		const ecdh = this.jar.get(ECDH_ENTRY);
+		if (!ticket || !tsSign || !ecdh) return void 0;
+		return {
+			ticket,
+			tsSign,
+			ecdhKey: Buffer.from(ecdh, "hex")
+		};
+	}
+	/**
+	* 在首个 passport 请求之前把公钥交给服务端
+	*
+	* 缺了这一步扫码依然能成功，但服务端不会签发票据，后续请求也就无从携带。
+	*/
+	publishPublicKey() {
+		const payload = compactJson({
+			"bd-ticket-guard-version": Number(GUARD_VERSION),
+			"bd-ticket-guard-iteration-version": Number(ITERATION_VERSION),
+			"bd-ticket-guard-ree-public-key": this.reePublicKey,
+			"bd-ticket-guard-web-version": Number(GUARD_VERSION)
+		});
+		this.jar.set(CLIENT_DATA_COOKIE, encodeURIComponent(Buffer.from(payload, "utf8").toString("base64")));
+		this.jar.set(CLIENT_WEB_DOMAIN_COOKIE, GUARD_VERSION);
+	}
+	/**
+	* 消化响应里可能带回的票据签发结果
+	* @param headers 响应头
+	* @returns 是否收到了新票据
+	*/
+	applyServerData(headers) {
+		const fromHeader = headers[SERVER_DATA_HEADER];
+		const raw = typeof fromHeader === "string" && fromHeader ? fromHeader : this.jar.get(SERVER_DATA_COOKIE);
+		if (!raw) return false;
+		let info;
+		try {
+			info = JSON.parse(Buffer.from(decodeURIComponent(raw), "base64").toString("utf8"));
+		} catch {
+			return false;
+		}
+		if (!info.ticket || !info.ts_sign || !info.client_cert) return false;
+		let ecdhKey;
+		try {
+			ecdhKey = this.deriveEcdhKey(info.client_cert);
+		} catch {
+			return false;
+		}
+		this.jar.set(TICKET_ENTRY, info.ticket);
+		this.jar.set(TS_SIGN_ENTRY, info.ts_sign);
+		this.jar.set(ECDH_ENTRY, ecdhKey.toString("hex"));
+		return true;
+	}
+	/**
+	* 生成本次请求的 bd-ticket-guard 请求头
+	*
+	* 尚未拿到票据时只声明公钥，让服务端有机会签发；拿到之后带完整签名。
+	* @param path 请求路径，不含 query
+	* @param timestamp 秒级时间戳，默认取当前
+	*/
+	headers(path, timestamp = Math.floor(Date.now() / 1e3)) {
+		const base = {
+			"bd-ticket-guard-version": GUARD_VERSION,
+			"bd-ticket-guard-iteration-version": ITERATION_VERSION,
+			"bd-ticket-guard-ree-public-key": this.reePublicKey
+		};
+		const state = this.state;
+		if (!state) return base;
+		const signed = `ticket=${state.ticket}&path=${path}&timestamp=${timestamp}`;
+		const clientData = compactJson({
+			ts_sign: state.tsSign,
+			req_content: REQ_CONTENT,
+			req_sign: node_crypto.default.createHmac("sha256", state.ecdhKey).update(signed, "utf8").digest("base64"),
+			timestamp
+		});
+		return {
+			...base,
+			"bd-ticket-guard-client-data": Buffer.from(clientData, "utf8").toString("base64"),
+			"bd-ticket-guard-web-version": state.tsSign.startsWith("ts.1") ? "1" : GUARD_VERSION,
+			"bd-ticket-guard-web-sign-type": "1"
+		};
+	}
+	/**
+	* ECDH + HKDF-SHA256 派生 HMAC 密钥
+	* @param clientCert 服务端下发的证书或裸公钥
+	*/
+	deriveEcdhKey(clientCert) {
+		const shared = node_crypto.default.diffieHellman({
+			privateKey: this.privateKey,
+			publicKey: readServerPublicKey(clientCert)
+		});
+		return Buffer.from(node_crypto.default.hkdfSync("sha256", shared, Buffer.alloc(32), Buffer.alloc(0), 32));
+	}
+};
+//#endregion
+//#region src/platform/douyin/passport/client.ts
+/**
+* passport 登录的 HTTP 客户端
+*
+* 走 amagi 自己的 `fetchResponse`（axios），因此代理、超时、重试与网络事件与其它接口一致。
+*
+* 客户端本身是无状态的：会话状态（`msToken`、`passport_csrf_token`）都以 cookie 形式
+* 随调用方传入的 cookie 串进出，`x-tt-passport-verify-portrait` 则由 `ttwid` 派生，
+* 因此同一份 cookie 在整个登录过程中会得到稳定的 portrait，调用方无需额外保存任何东西。
+*/
+/** 与签名里的浏览器环境保持一致的 UA */
+const PASSPORT_USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36";
+/** 单次请求默认超时 */
+const DEFAULT_TIMEOUT = 15e3;
+/** SSO 跳转最多跟随的次数 */
+const MAX_REDIRECT_HOPS = 5;
+/** 浏览器客户端提示头，服务端会与 UA 交叉校验 */
+const CLIENT_HINTS = {
+	"sec-ch-ua": "\"Not_A Brand\";v=\"99\", \"Chromium\";v=\"142\"",
+	"sec-ch-ua-mobile": "?0",
+	"sec-ch-ua-platform": "\"Windows\""
+};
+/** 安全解析 JSON，失败返回空对象 */
+const parseJson = (text) => {
+	try {
+		return JSON.parse(text);
+	} catch {
+		return {};
+	}
+};
+/**
+* 由 ttwid 派生出稳定的 verify portrait
+*
+* 浏览器里这个值在一次登录页生命周期内固定不变。这里用 cookie 中已有的设备指纹推导，
+* 既保证同一会话内多次调用得到同一个值，又不需要调用方额外携带状态。
+* @param jar 当前会话 cookie
+*/
+const deriveVerifyPortrait = (jar) => {
+	const seed = jar.get("ttwid") ?? jar.get("__ac_nonce") ?? "douyin-passport";
+	const hex = node_crypto.default.createHash("sha256").update(seed).digest("hex");
+	return `${[
+		hex.slice(0, 8),
+		hex.slice(8, 12),
+		`4${hex.slice(13, 16)}`,
+		`8${hex.slice(17, 20)}`,
+		hex.slice(20, 32)
+	].join("-")}.login`;
+};
+var DouyinPassportClient = class {
+	requestConfig;
+	/** 会话 cookie */
+	cookies;
+	/** bd-ticket-guard 设备票据，状态随 cookie 一起流转 */
+	ticketGuard;
+	/**
+	* @param cookie 已有的会话 cookie 串
+	* @param requestConfig amagi 的请求配置（代理、超时、额外请求头）
+	*/
+	constructor(cookie, requestConfig) {
+		this.requestConfig = requestConfig;
+		this.cookies = new CookieJar(cookie);
+		this.ticketGuard = new TicketGuard(this.cookies);
+	}
+	/** CSRF token：优先用服务端下发的，缺失时本地生成并同步写进 cookie（双提交校验） */
+	get csrfToken() {
+		const fromCookie = this.cookies.get("passport_csrf_token");
+		if (fromCookie) return fromCookie;
+		const generated = randomHex(32);
+		this.cookies.set("passport_csrf_token", generated);
+		this.cookies.set("passport_csrf_token_default", generated);
+		return generated;
+	}
+	/**
+	* 初始化登录环境指纹
+	*
+	* 依次请求抖音首页拿 `__ac_nonce`、再向 ttwid 服务注册拿 `ttwid`。两步都是匿名的，
+	* 任意机器、任意系统都能跑；失败不抛错，只会让后续更容易命中风控。
+	*/
+	async bootstrap() {
+		this.ticketGuard.publishPublicKey();
+		if (this.cookies.has("ttwid") && this.cookies.has("__ac_nonce")) return;
+		await this.send({
+			method: "GET",
+			url: `https://${WEB_HOST}/`,
+			headers: {
+				Accept: "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+				...CLIENT_HINTS
+			}
+		});
+		await this.send({
+			method: "POST",
+			url: "https://ttwid.bytedance.com/ttwid/register/",
+			headers: {
+				"Content-Type": "application/json",
+				Origin: `https://${WEB_HOST}`,
+				Referer: `https://${WEB_HOST}/`
+			},
+			data: JSON.stringify({
+				aid: 6383,
+				service: WEB_HOST
+			})
+		});
+		emitLogDebug(`[douyin passport] 环境指纹就绪: ttwid=${this.cookies.has("ttwid")}, ac_nonce=${this.cookies.has("__ac_nonce")}`);
+	}
+	/**
+	* 请求 login.douyin.com 的 passport 接口（四重签名 + a_bogus 形态）
+	* @param path 接口路径，如 `/passport/web/get_qrcode/`
+	* @param params 业务参数，并入 query
+	*/
+	async request(path, params = {}) {
+		const common = makeCommonParams(params);
+		const { sign, qs } = makeSignAndQs(common, {});
+		const query = {
+			...common,
+			sign,
+			qs
+		};
+		const msToken = this.cookies.get("msToken");
+		if (msToken) query.msToken = msToken;
+		const queryString = serializeQuery(query);
+		const url = `https://${LOGIN_HOST}${path}?${queryString}&a_bogus=${encodeURIComponent(aBogus(queryString, PASSPORT_USER_AGENT))}`;
+		return this.send({
+			method: "GET",
+			url,
+			headers: {
+				Accept: "application/json, text/javascript",
+				"Content-Type": "application/x-www-form-urlencoded",
+				Referer: `https://${WEB_HOST}/`,
+				"x-tt-passport-aid-sign": makeAidSign(path),
+				"x-tt-passport-csrf-token": this.csrfToken,
+				"x-tt-passport-verify-portrait": deriveVerifyPortrait(this.cookies),
+				"x-tt-passport-trace-id": String(common.biz_trace_id),
+				...this.ticketGuard.headers(path),
+				...CLIENT_HINTS
+			}
+		});
+	}
+	/**
+	* 请求 www.douyin.com 的验证页接口（lite 形态：固定 query + 表单 body，无签名）
+	* @param path 接口路径，如 `/passport/web/send_code/`
+	* @param params 业务参数，进 body
+	* @param bizTraceId 业务追踪 ID，同一次验证流程内保持一致
+	*/
+	async liteRequest(path, params, bizTraceId) {
+		return this.send({
+			method: "POST",
+			url: `https://${WEB_HOST}${path}?${serializeQuery(makeLiteParams(bizTraceId))}`,
+			headers: {
+				Accept: "application/json, text/javascript",
+				"Content-Type": "application/x-www-form-urlencoded",
+				Origin: `https://${WEB_HOST}`,
+				Referer: `https://${WEB_HOST}/`,
+				"x-tt-passport-aid-sign": makeAidSign(path),
+				"x-tt-passport-csrf-token": this.csrfToken,
+				"x-tt-passport-verify-portrait": deriveVerifyPortrait(this.cookies),
+				"x-tt-passport-trace-id": bizTraceId,
+				...this.ticketGuard.headers(path),
+				...CLIENT_HINTS
+			},
+			data: serializeQuery(params)
+		});
+	}
+	/**
+	* 跟随扫码确认后下发的 SSO 跳转链，把最终的登录凭证收进 CookieJar
+	* @param redirectUrl `check_qrconnect` 返回的 redirect_url
+	* @returns 是否拿到登录态 cookie
+	*/
+	async followSsoRedirect(redirectUrl) {
+		let current = redirectUrl;
+		for (let hop = 0; hop < MAX_REDIRECT_HOPS; hop++) {
+			const response = await this.send({
+				method: "GET",
+				url: current,
+				maxRedirects: 0,
+				headers: {
+					Accept: "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+					Referer: `https://${LOGIN_HOST}/`,
+					...CLIENT_HINTS
+				}
+			});
+			const location = response.location;
+			if (!location || response.status < 300 || response.status >= 400) break;
+			current = new URL(location, current).toString();
+		}
+		return this.cookies.isLoggedIn();
+	}
+	/** 实际发请求：合并 cookie、消化 Set-Cookie 与 msToken */
+	async send(config) {
+		const cookie = this.cookies.toString();
+		const response = await fetchResponse({
+			timeout: this.requestConfig?.timeout ?? DEFAULT_TIMEOUT,
+			proxy: this.requestConfig?.proxy,
+			...config,
+			responseType: "text",
+			maxRedirects: config.maxRedirects ?? 5,
+			headers: {
+				"User-Agent": PASSPORT_USER_AGENT,
+				...config.headers,
+				...cookie ? { Cookie: cookie } : {}
+			}
+		});
+		if (isNetworkErrorResult(response)) throw new Error(response.error.amagiError.errorDescription);
+		const axiosResponse = response;
+		this.cookies.applySetCookie(axiosResponse.headers["set-cookie"]);
+		const refreshed = axiosResponse.headers["x-ms-token"];
+		if (typeof refreshed === "string" && refreshed) this.cookies.set("msToken", refreshed);
+		if (this.ticketGuard.applyServerData(axiosResponse.headers)) emitLogDebug("[douyin passport] 已获得 bd-ticket-guard 票据");
+		const raw = typeof axiosResponse.data === "string" ? axiosResponse.data : JSON.stringify(axiosResponse.data);
+		return {
+			status: axiosResponse.status,
+			raw,
+			body: parseJson(raw),
+			cookie: this.cookies.serialize(),
+			location: axiosResponse.headers.location
+		};
+	}
+};
+//#endregion
+//#region src/platform/douyin/passport/parser.ts
+/** 触发账号二次验证的错误码 */
+const ERROR_SECOND_VERIFY = 2046;
+/** 验证码错误 */
+const ERROR_WRONG_CODE = 1202;
+/** 发码过于频繁 */
+const ERROR_RATE_LIMITED = 1206;
+/** 命中风控 / 设备环境异常 */
+const RISK_ERROR_CODES = /* @__PURE__ */ new Set([2156, 4031]);
+/**
+* 轮询过于频繁
+*
+* 描述文案是「访问太频繁」，但设备指纹不完整时服务端也用这个码兜底，
+* 属于可重试的瞬时状态，退避后继续轮询即可，不能当致命错误。
+*/
+const ERROR_POLL_BUSY = 7;
+/** 命中限频后的退避倍率 */
+const BUSY_BACKOFF = 2;
+/** 轮询间隔下限与默认值，服务端偶尔会给 0 */
+const MIN_INTERVAL = 1e3;
+const DEFAULT_INTERVAL = 3e3;
+/** 验证会话票据字段，需原样透传 */
+const STD_KEYS = [
+	"std_verify_flow_id",
+	"std_verify_scene",
+	"std_verify_template",
+	"std_verify_token",
+	"std_verify_type",
+	"std_verify_way"
+];
+const asString = (value) => typeof value === "string" ? value : "";
+const asNumber = (value) => {
+	const parsed = typeof value === "number" ? value : Number(value);
+	return Number.isFinite(parsed) ? parsed : void 0;
+};
+/** 从响应体的多个可能位置取错误码 */
+const readErrorCode = (payload) => asNumber(payload.data?.error_code) ?? asNumber(payload.error_code);
+/** 取一段人类可读的错误描述 */
+const readMessage = (payload) => asString(payload.data?.description) || asString(payload.description) || asString(payload.message) || "";
+/**
+* 解析 `get_qrcode` 响应
+* @param payload 服务端响应体
+* @returns 二维码信息，缺少 token 时返回 null
+*/
+const parseQrcode = (payload) => {
+	const data = payload.data ?? {};
+	const token = asString(data.token);
+	if (!token) return null;
+	return {
+		token,
+		content: asString(data.qrcode_index_url) || token,
+		expireTime: asNumber(data.expire_time) ?? 0
+	};
+};
+/** 解析服务端下发的可选验证方式 */
+const parseVerifyWays = (raw) => {
+	if (!Array.isArray(raw)) return [];
+	return raw.map((item) => {
+		const way = item;
+		return {
+			verifyWay: asString(way?.verify_way),
+			mobile: asString(way?.mobile) || void 0
+		};
+	}).filter((way) => way.verifyWay !== "");
+};
+/**
+* 从轮询响应里提取二次验证上下文
+* @param data 轮询响应的 data 段
+*/
+const parseVerifyContext = (data) => {
+	const stdParams = {};
+	for (const key of STD_KEYS) {
+		const value = asString(data[key]);
+		if (value) stdParams[key] = value;
+	}
+	return {
+		encryptUid: asString(data.encrypt_uid),
+		verifyTicket: asString(data.verify_ticket),
+		stdParams,
+		copywritingKey: asString(data.copywriting_key) || "qr_connect",
+		diversionTag: asString(data.ies_safety_diversion_tag) || "mfa",
+		newVerifyFlow: asString(data.new_verify_flow),
+		verifyWays: parseVerifyWays(data.verify_ways)
+	};
+};
+/**
+* 解析 `check_qrconnect` 响应为状态机可消费的结果
+* @param payload 服务端响应体
+*/
+const parsePollResult = (payload) => {
+	const data = payload.data ?? {};
+	const rawInterval = asNumber(data.interval) ?? 0;
+	const interval = rawInterval >= MIN_INTERVAL ? rawInterval : DEFAULT_INTERVAL;
+	const status = asString(data.status);
+	const errorCode = readErrorCode(payload);
+	if (errorCode === ERROR_SECOND_VERIFY || asString(data.account_flow) === "verify") return {
+		status: "verify",
+		interval,
+		verify: parseVerifyContext(data)
+	};
+	if (errorCode !== void 0 && RISK_ERROR_CODES.has(errorCode)) return {
+		status: "risk",
+		interval,
+		message: readMessage(payload) || `error_code=${errorCode}`
+	};
+	if (errorCode === ERROR_POLL_BUSY) return {
+		status: "busy",
+		interval: interval * BUSY_BACKOFF,
+		message: readMessage(payload) || "轮询过于频繁"
+	};
+	switch (status) {
+		case "new":
+		case "scanned":
+		case "expired": return {
+			status,
+			interval
+		};
+		case "confirmed": return {
+			status: "confirmed",
+			interval,
+			redirectUrl: asString(data.redirect_url) || (Array.isArray(data.redirect_urls) ? asString(data.redirect_urls[0]) : "")
+		};
+		default: return {
+			status: "unknown",
+			interval,
+			message: readMessage(payload) || (status ? `status=${status}` : `error_code=${errorCode ?? "unknown"}`)
+		};
+	}
+};
+/**
+* 解析 `send_code` 响应
+* @param payload 服务端响应体
+*/
+const parseSendCodeResult = (payload) => {
+	const data = payload.data ?? {};
+	const errorCode = readErrorCode(payload);
+	const retryAfter = asNumber(data.retry_time) ?? 60;
+	const mobile = asString(data.mobile);
+	if (errorCode === 0 || errorCode === void 0 && payload.message === "success") return {
+		ok: true,
+		mobile,
+		retryAfter,
+		message: ""
+	};
+	return {
+		ok: false,
+		mobile,
+		retryAfter,
+		errorCode,
+		message: readMessage(payload) || (errorCode === ERROR_RATE_LIMITED ? "短信发送过于频繁" : `发码失败 error_code=${errorCode ?? "unknown"}`)
+	};
+};
+/**
+* 解析 `validate_code` 响应
+* @param payload 服务端响应体
+*/
+const parseValidateCodeResult = (payload) => {
+	const data = payload.data ?? {};
+	const errorCode = readErrorCode(payload);
+	if (errorCode === 0 || asString(data.ticket) || errorCode === void 0 && payload.message === "success") return {
+		ok: true,
+		wrongCode: false,
+		message: ""
+	};
+	return {
+		ok: false,
+		wrongCode: errorCode === ERROR_WRONG_CODE,
+		errorCode,
+		message: readMessage(payload) || (errorCode === ERROR_WRONG_CODE ? "验证码错误" : `验证失败 error_code=${errorCode ?? "unknown"}`)
+	};
+};
+//#endregion
+//#region src/platform/douyin/passport/index.ts
+var passport_exports = /* @__PURE__ */ require_rolldown_runtime.__exportAll({
+	BDMS_SDK_VERSION: () => BDMS_SDK_VERSION,
+	CookieJar: () => CookieJar,
+	DouyinPassportClient: () => DouyinPassportClient,
+	INTERNAL_PREFIX: () => INTERNAL_PREFIX,
+	PASSPORT_USER_AGENT: () => PASSPORT_USER_AGENT,
+	TicketGuard: () => TicketGuard,
+	aBogus: () => aBogus,
+	makeAidSign: () => makeAidSign,
+	makeSignAndQs: () => makeSignAndQs,
+	parsePollResult: () => parsePollResult,
+	parseQrcode: () => parseQrcode,
+	parseSendCodeResult: () => parseSendCodeResult,
+	parseValidateCodeResult: () => parseValidateCodeResult,
+	randomHex: () => randomHex,
+	sm3: () => sm3,
+	sm3Hex: () => sm3Hex,
+	sm3Twice: () => sm3Twice,
+	utcNoonTimestamp: () => utcNoonTimestamp,
+	xor5Hex: () => xor5Hex
+});
+//#endregion
+//#region src/types/NetworksConfigType.ts
+/** 快手平台API错误码 */
+let kuaishouAPIErrorCode = /* @__PURE__ */ function(kuaishouAPIErrorCode) {
+	/** Cookie无效或已过期 */
+	kuaishouAPIErrorCode["COOKIE"] = "INVALID_COOKIE";
+	/** 未知错误 */
+	kuaishouAPIErrorCode["UNKNOWN"] = "UNKNOWN_ERROR";
+	return kuaishouAPIErrorCode;
+}({});
+/** 小红书平台API错误码 */
+let xiaohongshuAPIErrorCode = /* @__PURE__ */ function(xiaohongshuAPIErrorCode) {
+	/** Cookie无效或已过期 */
+	xiaohongshuAPIErrorCode["COOKIE"] = "INVALID_COOKIE";
+	/** 未知错误 */
+	xiaohongshuAPIErrorCode["UNKNOWN"] = "UNKNOWN_ERROR";
+	/** 非法请求 */
+	xiaohongshuAPIErrorCode[xiaohongshuAPIErrorCode["ILLEGAL_REQUEST"] = 500] = "ILLEGAL_REQUEST";
+	/** 检测到帐号异常，请稍后重试 */
+	xiaohongshuAPIErrorCode[xiaohongshuAPIErrorCode["ACCOUNT_ABNORMAL"] = 300011] = "ACCOUNT_ABNORMAL";
+	/** 网络连接异常，请检查网络设置后重试 */
+	xiaohongshuAPIErrorCode[xiaohongshuAPIErrorCode["NETWORK_ERROR"] = 300012] = "NETWORK_ERROR";
+	/** 访问频次异常，请勿频繁操作 */
+	xiaohongshuAPIErrorCode[xiaohongshuAPIErrorCode["FREQUENCY_ERROR"] = 300013] = "FREQUENCY_ERROR";
+	/** 浏览器异常，请尝试更换浏览器后重试 */
+	xiaohongshuAPIErrorCode[xiaohongshuAPIErrorCode["BROWSER_ERROR"] = 300015] = "BROWSER_ERROR";
+	return xiaohongshuAPIErrorCode;
+}({});
+//#endregion
+//#region src/model/fetchers/douyin/auth.ts
+/**
+* 抖音登录认证相关 API（passport 扫码登录）
+*
+* 与其它 fetcher 的差别：这几个接口不走 `DouyinData` 的 URL 拼装 + a_bogus 流水线，
+* 因为 passport 体系有自己的三重 query 签名、独立的 a_bogus 形态与双重编码规则。
+* 对外形态保持一致：同样是 `(options, cookie?, requestConfig?) => Result<T>`，
+* 同样发 `apiSuccess` / `apiError` 事件，同样复用 amagi 的代理、超时与重试。
+*
+* 这几个方法都是无状态的：会话状态全部装在 cookie 串里，调用方拿到返回的 `cookie`
+* 后在下一次调用时传回来即可。轮询循环由调用方维护。
+*
+* @module fetchers/douyin/auth
+*/
+/** 短信验证码的验证方式标识，服务端未给出可用方式时的兜底值 */
+const SMS_VERIFY_WAY = "mobile_sms_verify";
+/**
+* 可以用「收 6 位验证码」这套流程走完的验证方式
+*
+* 除官方常见的 `mobile_sms_verify`，账号被判定需要辅助验证时会给出
+* `assist_mobile_sms_verify`，两者都是下行短信收码，走同一对
+* `send_code` / `validate_code` 接口，区别只在 `std_verify_way` 的取值。
+* 上行短信（`*_up_sms_verify`）要求用户从手机发短信出去，是另一套接口，不在此列。
+*/
+const SMS_CODE_WAY_PATTERN = /^(assist_)?mobile_sms_verify$/;
+/**
+* 判断某个验证方式能否用短信验证码流程完成
+* @param verifyWay 服务端下发的 verify_way
+*/
+const isSmsCodeVerifyWay = (verifyWay) => SMS_CODE_WAY_PATTERN.test(verifyWay);
+/**
+* 选出本次要用的 std_verify_way
+*
+* 优先用调用方指定的；否则从服务端给出的可选方式里挑一个能收码的；都没有才回退到默认值。
+* 之前这里写死 `mobile_sms_verify`，遇到辅助验证的账号会因为 way 对不上而失败。
+* @param verify 轮询下发的验证上下文
+* @param requested 调用方显式指定的验证方式
+*/
+const resolveVerifyWay = (verify, requested) => requested ?? verify.verifyWays.find((way) => isSmsCodeVerifyWay(way.verifyWay))?.verifyWay ?? verify.stdParams.std_verify_way ?? SMS_VERIFY_WAY;
+/** 短信验证码的 act_type */
+const SMS_ACT_TYPE = "3737";
+/** 验证页 SDK 版本，随表单一起提交 */
+const AUTHN_VERSION = "1.0.0.420-web";
+/** 抖音 web 的 aid */
+const AID = "6383";
+/** 扫码成功后的跳转地址 */
+const NEXT_URL = "https://www.douyin.com";
+/**
+* 发码与验码共用的表单字段
+*
+* 字段顺序与「空值也要占位」的行为对齐官方验证页 SDK 的抓包形态：
+* `verify_ticket` / `new_verify_flow` / `std_verify_flow_id` / `std_verify_token`
+* 即使为空也必须出现，缺字段会被判为伪造请求。
+* @param verify 轮询下发的验证上下文
+* @param verifyWay 本次使用的验证方式，原样进 `std_verify_way`
+* @param tail 追加在 std_verify_way 之后的字段（发码是 is6Digits，验码是 code）
+*/
+const buildVerifyBody = (verify, verifyWay, tail) => ({
+	mix_mode: "1",
+	type: SMS_ACT_TYPE,
+	encrypt_uid: verify.encryptUid,
+	verify_ticket: verify.verifyTicket,
+	copywriting_key: verify.copywritingKey,
+	ies_safety_diversion_tag: verify.diversionTag,
+	new_verify_flow: verify.newVerifyFlow,
+	std_verify_flow_id: verify.stdParams.std_verify_flow_id ?? "",
+	std_verify_scene: verify.stdParams.std_verify_scene ?? "account_login",
+	std_verify_template: verify.stdParams.std_verify_template ?? "ato_web",
+	std_verify_token: verify.stdParams.std_verify_token ?? "",
+	std_verify_type: verify.stdParams.std_verify_type ?? "MFA",
+	std_verify_way: verifyWay,
+	...tail,
+	aid: AID,
+	new_authn_sdk_version: AUTHN_VERSION
+});
+/**
+* 构造 passport 侧的业务错误响应
+* @param methodType 方法名，进 amagiError.requestType
+* @param message 错误描述
+*/
+const passportError = (methodType, message) => createErrorResponse({
+	code: "UNKNOWN_ERROR",
+	data: null,
+	amagiError: {
+		errorDescription: message,
+		requestType: methodType,
+		requestUrl: `https://login.douyin.com/passport/`
+	},
+	amagiMessage: message
+}, message);
+/** 统一包一层事件上报与异常兜底 */
+const run = async (methodType, task) => {
+	const startTime = Date.now();
+	try {
+		const result = await task();
+		const duration = Date.now() - startTime;
+		if (result.code === 200) emitApiSuccess({
+			platform: "douyin",
+			methodType,
+			response: result,
+			statusCode: 200,
+			duration
+		});
+		else emitApiError({
+			platform: "douyin",
+			methodType,
+			errorCode: result.code,
+			errorMessage: result.message,
+			duration
+		});
+		return result;
+	} catch (error) {
+		const duration = Date.now() - startTime;
+		const errorMessage = error instanceof Error ? error.message : "未知错误";
+		emitApiError({
+			platform: "douyin",
+			methodType,
+			errorMessage,
+			duration
+		});
+		throw new Error(`抖音登录请求失败: ${errorMessage}`);
+	}
+};
+/**
+* 申请抖音扫码登录二维码
+*
+* 首次调用会自动完成环境指纹初始化（`__ac_nonce` + `ttwid`），无需额外准备。
+* @param options - 请求选项 (可选)
+* @param cookie - 已有的会话 Cookie (可选，续用同一会话时传入)
+* @param requestConfig - 请求配置 (可选)
+* @returns 二维码令牌、内容与会话 cookie
+* @example
+* ```typescript
+* const qrcode = await requestPassportQrcode()
+* console.log(qrcode.data.content) // 拿去生成二维码图片
+* ```
+*/
+async function requestPassportQrcode(options, cookie, requestConfig) {
+	return run("passportQrcode", async () => {
+		const client = new DouyinPassportClient(cookie, requestConfig);
+		await client.bootstrap();
+		const response = await client.request("/passport/web/get_qrcode/", {
+			next: NEXT_URL,
+			need_short_url: "true",
+			need_logo: "false",
+			is_new_login: "1"
+		});
+		const qrcode = parseQrcode(response.body);
+		if (!qrcode) return passportError("passportQrcode", response.body.message || `获取二维码失败: ${response.raw.slice(0, 200)}`);
+		return createSuccessResponse({
+			token: qrcode.token,
+			content: qrcode.content,
+			expire_time: qrcode.expireTime,
+			expires_in: Math.max(0, qrcode.expireTime - Math.floor(Date.now() / 1e3)),
+			cookie: response.cookie
+		}, "获取成功", 200);
+	});
+}
+/**
+* 查询抖音扫码登录二维码的状态
+*
+* 状态为 `confirmed` 时会自动跟随 SSO 跳转领取登录凭证，返回的 `cookie` 即完整登录态。
+* @param options - 二维码状态参数
+* @param options.token - `requestPassportQrcode` 返回的令牌
+* @param cookie - 会话 Cookie，必须是申请二维码时返回的那一份
+* @param requestConfig - 请求配置 (可选)
+* @returns 扫码状态与最新会话 cookie
+* @example
+* ```typescript
+* const status = await checkPassportQrcode({ token }, cookie)
+* // new 未扫码 / scanned 已扫待确认 / verify 需二次验证 / confirmed 登录成功 / expired 已过期
+* console.log(status.data.status)
+* ```
+*/
+async function checkPassportQrcode(options, cookie, requestConfig) {
+	return run("passportQrcodeStatus", async () => {
+		if (!options?.token) return passportError("passportQrcodeStatus", "缺少 token 参数");
+		const client = new DouyinPassportClient(cookie, requestConfig);
+		const response = await client.request("/passport/web/check_qrconnect/", {
+			next: NEXT_URL,
+			need_logo: "false",
+			is_frontier: "true",
+			token: options.token,
+			is_new_login: "1",
+			need_short_url: "true"
+		});
+		const result = parsePollResult(response.body);
+		if (result.status === "verify") emitLogDebug(`[douyin passport] 触发二次验证，服务端原始响应: ${response.raw.slice(0, 1e3)}`);
+		if (result.status === "confirmed" && result.redirectUrl) await client.followSsoRedirect(result.redirectUrl);
+		const sessionCookie = result.status === "confirmed" ? client.cookies.toString() : client.cookies.serialize();
+		return createSuccessResponse({
+			...result,
+			cookie: sessionCookie,
+			logged_in: client.cookies.isLoggedIn()
+		}, "获取成功", 200);
+	});
+}
+/**
+* 向账号绑定手机发送二次验证短信验证码
+*
+* 用于轮询返回 `status: 'verify'`（即 `error_code=2046` / `account_flow=verify`）的场景。
+* @param options - 发码参数
+* @param options.verify - 轮询返回的验证上下文
+* @param options.biz_trace_id - 追踪 ID (可选，不传自动生成)
+* @param cookie - 会话 Cookie
+* @param requestConfig - 请求配置 (可选)
+* @returns 脱敏手机号、重发等待秒数与追踪 ID
+*/
+async function sendPassportVerifyCode(options, cookie, requestConfig) {
+	return run("passportSendCode", async () => {
+		if (!options?.verify?.encryptUid) return passportError("passportSendCode", "缺少 encrypt_uid，请从轮询响应中取得验证上下文");
+		const bizTraceId = options.biz_trace_id ?? randomHex(8);
+		const verifyWay = resolveVerifyWay(options.verify, options.verify_way);
+		emitLogDebug(`[douyin passport] 发码使用的验证方式: ${verifyWay}`);
+		const response = await new DouyinPassportClient(cookie, requestConfig).liteRequest("/passport/web/send_code/", buildVerifyBody(options.verify, verifyWay, { is6Digits: "1" }), bizTraceId);
+		const result = parseSendCodeResult(response.body);
+		if (!result.ok) emitLogDebug(`[douyin passport] 发码失败原文: ${response.raw.slice(0, 500)}`);
+		return createSuccessResponse({
+			...result,
+			cookie: response.cookie,
+			biz_trace_id: bizTraceId,
+			verify_way: verifyWay
+		}, "获取成功", 200);
+	});
+}
+/**
+* 提交二次验证的短信验证码
+* @param options - 验码参数
+* @param options.verify - 轮询返回的验证上下文
+* @param options.code - 用户收到的 6 位验证码明文
+* @param options.biz_trace_id - 必须与发码时用的是同一个
+* @param cookie - 会话 Cookie
+* @param requestConfig - 请求配置 (可选)
+* @returns 验证结果；`wrongCode` 为 true 表示验证码填错，可以让用户重试
+*/
+async function validatePassportVerifyCode(options, cookie, requestConfig) {
+	return run("passportValidateCode", async () => {
+		if (!options?.verify?.encryptUid) return passportError("passportValidateCode", "缺少 encrypt_uid，请从轮询响应中取得验证上下文");
+		if (!options.code) return passportError("passportValidateCode", "缺少 code，请填入收到的短信验证码");
+		const response = await new DouyinPassportClient(cookie, requestConfig).liteRequest("/passport/web/validate_code/", buildVerifyBody(options.verify, resolveVerifyWay(options.verify, options.verify_way), { code: xor5Hex(options.code) }), options.biz_trace_id ?? randomHex(8));
+		const result = parseValidateCodeResult(response.body);
+		if (!result.ok) emitLogDebug(`[douyin passport] 验码失败原文: ${response.raw.slice(0, 500)}`);
+		return createSuccessResponse({
+			...result,
+			cookie: response.cookie
+		}, "获取成功", 200);
+	});
+}
+//#endregion
 //#region src/platform/defaultConfigs.ts
 /**
 * 根据User-Agent生成对应的Sec-Ch-Ua值
@@ -2285,34 +3974,6 @@ const getXiaohongshuDefaultConfig = (cookie) => {
 	} };
 };
 //#endregion
-//#region src/types/NetworksConfigType.ts
-/** 快手平台API错误码 */
-let kuaishouAPIErrorCode = /* @__PURE__ */ function(kuaishouAPIErrorCode) {
-	/** Cookie无效或已过期 */
-	kuaishouAPIErrorCode["COOKIE"] = "INVALID_COOKIE";
-	/** 未知错误 */
-	kuaishouAPIErrorCode["UNKNOWN"] = "UNKNOWN_ERROR";
-	return kuaishouAPIErrorCode;
-}({});
-/** 小红书平台API错误码 */
-let xiaohongshuAPIErrorCode = /* @__PURE__ */ function(xiaohongshuAPIErrorCode) {
-	/** Cookie无效或已过期 */
-	xiaohongshuAPIErrorCode["COOKIE"] = "INVALID_COOKIE";
-	/** 未知错误 */
-	xiaohongshuAPIErrorCode["UNKNOWN"] = "UNKNOWN_ERROR";
-	/** 非法请求 */
-	xiaohongshuAPIErrorCode[xiaohongshuAPIErrorCode["ILLEGAL_REQUEST"] = 500] = "ILLEGAL_REQUEST";
-	/** 检测到帐号异常，请稍后重试 */
-	xiaohongshuAPIErrorCode[xiaohongshuAPIErrorCode["ACCOUNT_ABNORMAL"] = 300011] = "ACCOUNT_ABNORMAL";
-	/** 网络连接异常，请检查网络设置后重试 */
-	xiaohongshuAPIErrorCode[xiaohongshuAPIErrorCode["NETWORK_ERROR"] = 300012] = "NETWORK_ERROR";
-	/** 访问频次异常，请勿频繁操作 */
-	xiaohongshuAPIErrorCode[xiaohongshuAPIErrorCode["FREQUENCY_ERROR"] = 300013] = "FREQUENCY_ERROR";
-	/** 浏览器异常，请尝试更换浏览器后重试 */
-	xiaohongshuAPIErrorCode[xiaohongshuAPIErrorCode["BROWSER_ERROR"] = 300015] = "BROWSER_ERROR";
-	return xiaohongshuAPIErrorCode;
-}({});
-//#endregion
 //#region src/platform/douyin/sign/a_bogus.ts
 var SM3 = class {
 	reg;
@@ -4636,6 +6297,10 @@ function createBoundDouyinFetcher(cookie, requestConfig) {
 * ```
 */
 const douyinFetcher = {
+	requestPassportQrcode,
+	checkPassportQrcode,
+	sendPassportVerifyCode,
+	validatePassportVerifyCode,
 	fetchVideoWork: fetchVideoWork$1,
 	fetchImageAlbumWork,
 	fetchSlidesWork,
@@ -8684,6 +10349,7 @@ const createDouyinRoutes = (cookie, requestConfig = getDouyinDefaultConfig(cooki
 /** 抖音相关功能模块 (工具集) */
 const douyinUtils = {
 	sign: douyinSign,
+	passport: passport_exports,
 	douyinApiUrls
 };
 //#endregion
@@ -9456,7 +11122,7 @@ function getApiRoute(platform, methodType) {
 * 构建后使用 __VERSION__，开发环境从 package.json 读取
 */
 const getVersion = () => {
-	return "6.5.0";
+	return "6.6.0";
 };
 const VERSION = getVersion();
 /**
@@ -9586,6 +11252,7 @@ exports.bilibiliErrorCodeMap = bilibiliErrorCodeMap;
 exports.bilibiliFetcher = bilibiliFetcher;
 exports.bilibiliUtils = bilibiliUtils;
 exports.bv2av = bv2av;
+exports.checkPassportQrcode = checkPassportQrcode;
 exports.createAmagiClient = createAmagiClient;
 exports.createBilibiliRoutes = createBilibiliRoutes;
 exports.createBoundBilibiliFetcher = createBoundBilibiliFetcher;
@@ -9600,6 +11267,12 @@ exports.createXiaohongshuRoutes = createXiaohongshuRoutes;
 exports.default = Client;
 exports.douyinApiUrls = douyinApiUrls;
 exports.douyinFetcher = douyinFetcher;
+Object.defineProperty(exports, "douyinPassport", {
+	enumerable: true,
+	get: function() {
+		return passport_exports;
+	}
+});
 exports.douyinSign = douyinSign;
 exports.douyinUtils = douyinUtils;
 exports.emitApiError = emitApiError;
@@ -9621,6 +11294,7 @@ exports.getEnglishMethodName = getEnglishMethodName;
 exports.getHeadersAndData = getHeadersAndData;
 exports.handleError = handleError;
 exports.isNetworkErrorResult = isNetworkErrorResult;
+exports.isSmsCodeVerifyWay = isSmsCodeVerifyWay;
 exports.kuaishouApiUrls = kuaishouApiUrls;
 exports.kuaishouFetcher = kuaishouFetcher;
 exports.kuaishouSign = kuaishouSign;
@@ -9631,10 +11305,13 @@ exports.registerBilibiliRoutes = createBilibiliRoutes;
 exports.registerDouyinRoutes = createDouyinRoutes;
 exports.registerKuaishouRoutes = createKuaishouRoutes;
 exports.registerXiaohongshuRoutes = createXiaohongshuRoutes;
+exports.requestPassportQrcode = requestPassportQrcode;
+exports.sendPassportVerifyCode = sendPassportVerifyCode;
 exports.toFetcherMethod = toFetcherMethod;
 exports.validateBilibiliParams = validateBilibiliParams;
 exports.validateDouyinParams = validateDouyinParams;
 exports.validateKuaishouParams = validateKuaishouParams;
+exports.validatePassportVerifyCode = validatePassportVerifyCode;
 exports.validateXiaohongshuParams = validateXiaohongshuParams;
 exports.wbi_sign = wbi_sign;
 exports.xiaohongshuApiUrls = xiaohongshuApiUrls;