@ikenxuan/amagi 6.6.0 → 7.0.0-beta.1

package/dist/exports/compat.mjs

@@ -0,0 +1,168 @@
+import { $ as unwrap, A as douyinFetcher, B as xiaohongshuSign, C as ValidationError, Ct as parseDmSegMobileReply, D as createBoundKuaishouFetcher, E as xiaohongshuFetcher, F as bilibiliFetcher, G as createDouyinRoutes, H as createKuaishouRoutes, I as createBoundBilibiliFetcher, J as bilibiliUtils, K as passport_exports, L as createClient, M as requestPassportQrcode, N as sendPassportVerifyCode, O as kuaishouFetcher, P as validatePassportVerifyCode, Q as isSuccess, R as xiaohongshuUtils, S as ApiError, St as emitNetworkRetry, T as createBoundXiaohongshuFetcher, Tt as bv2av, U as kuaishouSign, V as kuaishouUtils, W as douyinUtils, X as AmagiThrownError, Y as createBilibiliRoutes, Z as isFailure, _ as validateBilibiliParams, _t as emitLogError, a as AdditionalType, at as wbi_sign, b as validateXiaohongshuParams, bt as emitLogWarn, c as createAmagiClient, ct as fetchResponse, d as assertValidBilibiliParams, dt as emitApiError, et as AMAGI_BUS_EVENT_NAMES, f as assertValidDouyinParams, ft as emitApiSuccess, g as createSuccessResponse, gt as emitLogDebug, h as createErrorResponse, ht as emitLog, i as DynamicType, it as qtparam, j as checkPassportQrcode, k as createBoundDouyinFetcher, l as kuaishouApiUrls, lt as isNetworkErrorResult, m as assertValidXiaohongshuParams, mt as emitHttpResponse, n as CreateApp, nt as KUAISHOU_PC_CAPTCHA_RESULT, o as MajorType, ot as bilibiliApiUrls, p as assertValidKuaishouParams, pt as emitHttpRequest, q as douyinSign, r as amagi, rt as parseKuaishouCaptcha, s as CommentType, st as fetchData, tt as KUAISHOU_H5_CAPTCHA_RESULT, u as douyinApiUrls, ut as amagiEvents, v as validateDouyinParams, vt as emitLogInfo, w as handleError, wt as av2bv, x as xiaohongshuApiUrls, xt as emitNetworkError, y as validateKuaishouParams, yt as emitLogMark, z as createXiaohongshuRoutes } from "../src-AA7Elfxn.mjs";
+//#region src/exports/compat.ts
+/** 模块级只执行一次的迁移提示（不刷屏） */
+emitLogWarn("[@ikenxuan/amagi/compat] 你正在使用 v6 兼容入口；v7 迁移说明见 https://github.com/ikenxuan/amagi （v8 将移除 compat）");
+/**
+* `ErrorKind` → v6 信封顶层 `code`。
+*
+* v6 信封顶层 `code` 的语义并不统一（ApiError code 直接当 HTTP 状态、
+* 平台码与 amagi 错误码混用），因此这里是近似而非逐字还原：取
+* kind → HTTP 语义码的稳定映射，平台原文码保留在 `error.code`。
+*/
+const KIND_LEGACY_CODE = {
+	validation: 400,
+	auth: 401,
+	forbidden: 403,
+	not_found: 404,
+	rate_limit: 429,
+	risk: 403,
+	unavailable: 503,
+	network: 500,
+	timeout: 504,
+	parse: 502,
+	internal: 500,
+	unknown: 500
+};
+/**
+* 把 v7 信封回填成 v6 信封（纯函数，不抛错）。
+*
+* - 成功：`code: 200`，`error` 键运行时补 `undefined`
+* - 失败：顶层 `code` 取 {@link KIND_LEGACY_CODE}；平台码进 `error.code`；
+*   原始响应体进 `error.data`（没有则 null）
+*/
+const toLegacy = (r) => {
+	if (r.success) return {
+		success: true,
+		code: 200,
+		message: r.message,
+		data: r.data,
+		error: void 0
+	};
+	const e = r.error;
+	const requestType = r.meta.endpoint.includes(".") ? r.meta.endpoint.split(".").slice(1).join(".") : r.meta.endpoint;
+	return {
+		success: false,
+		code: KIND_LEGACY_CODE[e.kind],
+		message: r.message,
+		data: void 0,
+		error: {
+			code: e.platform?.code ?? e.code,
+			data: e.raw ?? null,
+			amagiError: {
+				errorDescription: e.message,
+				requestType,
+				requestUrl: void 0
+			},
+			amagiMessage: e.message
+		}
+	};
+};
+/** 是不是 v6 信封（顶层带 `code`）。passport 等保留方法返回 v6 信封，直接透传 */
+const isLegacyEnvelope = (r) => typeof r === "object" && r !== null && "success" in r && "code" in r;
+/** `kind: 'validation'` 的失败信封 → v6 的抛出行为（抛 ValidationError） */
+const validationErrorOf = (e) => {
+	const errors = e.issues && e.issues.length > 0 ? e.issues.map((i) => ({
+		field: i.path,
+		message: i.message
+	})) : [{
+		field: "(endpoint)",
+		message: e.message
+	}];
+	return new ValidationError("参数验证失败", errors);
+};
+/** 一次调用的结果收口：v6 信封透传；v7 信封转 toLegacy；校验失败恢复抛出 */
+const settle = async (promise) => {
+	const out = await promise;
+	if (isLegacyEnvelope(out)) return out;
+	const result = out;
+	if (!result.success && result.error.kind === "validation") throw validationErrorOf(result.error);
+	return toLegacy(result);
+};
+const WRAP_CACHE = /* @__PURE__ */ new WeakMap();
+/**
+* 把一个 fetcher 对象包装成「结果转 v6 信封」的版本。
+*
+* 包装发生在 get 时，方法集合自动跟随原对象；每个方法只包一次并缓存
+* （WeakMap 按目标对象 + 键）。非函数属性（若存在）原样透传。
+*/
+const wrapFetcher = (fetcher) => {
+	return new Proxy(fetcher, { get(target, prop, receiver) {
+		const value = Reflect.get(target, prop, receiver);
+		if (typeof value !== "function" || prop === "then") return value;
+		let cache = WRAP_CACHE.get(target);
+		if (!cache) {
+			cache = /* @__PURE__ */ new Map();
+			WRAP_CACHE.set(target, cache);
+		}
+		let wrapped = cache.get(prop);
+		if (!wrapped) {
+			const fn = value;
+			wrapped = (...args) => settle(Promise.resolve(fn.apply(target, args)));
+			cache.set(prop, wrapped);
+		}
+		return wrapped;
+	} });
+};
+/** 兼容版 client 工厂：`createAmagiClient` 的每个平台 fetcher 包一层 */
+const compatCreateAmagiClient = (options) => {
+	const client = createAmagiClient(options);
+	return {
+		...client,
+		douyin: {
+			...client.douyin,
+			douyinApiUrls,
+			fetcher: wrapFetcher(client.douyin.fetcher)
+		},
+		bilibili: {
+			...client.bilibili,
+			bilibiliApiUrls,
+			fetcher: wrapFetcher(client.bilibili.fetcher)
+		},
+		kuaishou: {
+			...client.kuaishou,
+			kuaishouApiUrls,
+			fetcher: wrapFetcher(client.kuaishou.fetcher)
+		},
+		xiaohongshu: {
+			...client.xiaohongshu,
+			xiaohongshuApiUrls,
+			fetcher: wrapFetcher(client.xiaohongshu.fetcher)
+		}
+	};
+};
+/** 兼容版静态 fetcher */
+const compatDouyinFetcher = wrapFetcher(douyinFetcher);
+const compatBilibiliFetcher = wrapFetcher(bilibiliFetcher);
+const compatKuaishouFetcher = wrapFetcher(kuaishouFetcher);
+const compatXiaohongshuFetcher = wrapFetcher(xiaohongshuFetcher);
+/** 兼容版 bound 工厂（返回的 fetcher 已包层） */
+const compatCreateBoundDouyinFetcher = (cookie, requestConfig) => wrapFetcher(createBoundDouyinFetcher(cookie, requestConfig));
+const compatCreateBoundBilibiliFetcher = (cookie, requestConfig) => wrapFetcher(createBoundBilibiliFetcher(cookie, requestConfig));
+const compatCreateBoundKuaishouFetcher = (cookie, requestConfig) => wrapFetcher(createBoundKuaishouFetcher(cookie, requestConfig));
+const compatCreateBoundXiaohongshuFetcher = (cookie, requestConfig) => wrapFetcher(createBoundXiaohongshuFetcher(cookie, requestConfig));
+function CreateAmagiCompatApp(options = {}) {
+	return compatCreateAmagiClient(options);
+}
+Object.defineProperty(CreateAmagiCompatApp, "version", {
+	value: amagi.version,
+	writable: false,
+	enumerable: true,
+	configurable: false
+});
+CreateAmagiCompatApp.douyin = amagi.douyin;
+CreateAmagiCompatApp.bilibili = amagi.bilibili;
+CreateAmagiCompatApp.kuaishou = amagi.kuaishou;
+CreateAmagiCompatApp.xiaohongshu = amagi.xiaohongshu;
+CreateAmagiCompatApp.events = amagi.events;
+CreateAmagiCompatApp.on = amagi.on;
+CreateAmagiCompatApp.once = amagi.once;
+CreateAmagiCompatApp.douyinFetcher = compatDouyinFetcher;
+CreateAmagiCompatApp.bilibiliFetcher = compatBilibiliFetcher;
+CreateAmagiCompatApp.kuaishouFetcher = compatKuaishouFetcher;
+CreateAmagiCompatApp.xiaohongshuFetcher = compatXiaohongshuFetcher;
+CreateAmagiCompatApp.createBoundDouyinFetcher = compatCreateBoundDouyinFetcher;
+CreateAmagiCompatApp.createBoundBilibiliFetcher = compatCreateBoundBilibiliFetcher;
+CreateAmagiCompatApp.createBoundKuaishouFetcher = compatCreateBoundKuaishouFetcher;
+CreateAmagiCompatApp.createBoundXiaohongshuFetcher = compatCreateBoundXiaohongshuFetcher;
+//#endregion
+export { AMAGI_BUS_EVENT_NAMES, AdditionalType, AmagiThrownError, ApiError, CommentType, CreateAmagiCompatApp, CreateAmagiCompatApp as default, CreateApp, DynamicType, KIND_LEGACY_CODE, KUAISHOU_H5_CAPTCHA_RESULT, KUAISHOU_PC_CAPTCHA_RESULT, MajorType, ValidationError, amagi, amagiEvents, assertValidBilibiliParams, assertValidDouyinParams, assertValidKuaishouParams, assertValidXiaohongshuParams, av2bv, bilibiliApiUrls, compatBilibiliFetcher as bilibiliFetcher, compatBilibiliFetcher, bilibiliUtils, bv2av, checkPassportQrcode, compatCreateBoundBilibiliFetcher, compatCreateBoundBilibiliFetcher as createBoundBilibiliFetcher, compatCreateBoundDouyinFetcher, compatCreateBoundDouyinFetcher as createBoundDouyinFetcher, compatCreateBoundKuaishouFetcher, compatCreateBoundKuaishouFetcher as createBoundKuaishouFetcher, compatCreateBoundXiaohongshuFetcher, compatCreateBoundXiaohongshuFetcher as createBoundXiaohongshuFetcher, compatDouyinFetcher, compatDouyinFetcher as douyinFetcher, compatKuaishouFetcher, compatKuaishouFetcher as kuaishouFetcher, compatXiaohongshuFetcher, compatXiaohongshuFetcher as xiaohongshuFetcher, compatCreateAmagiClient as createAmagiClient, createBilibiliRoutes, createClient, createDouyinRoutes, createErrorResponse, createKuaishouRoutes, createSuccessResponse, createXiaohongshuRoutes, douyinApiUrls, passport_exports as douyinPassport, douyinSign, douyinUtils, emitApiError, emitApiSuccess, emitHttpRequest, emitHttpResponse, emitLog, emitLogDebug, emitLogError, emitLogInfo, emitLogMark, emitLogWarn, emitNetworkError, emitNetworkRetry, fetchData, fetchResponse, handleError, isFailure, isNetworkErrorResult, isSuccess, kuaishouApiUrls, kuaishouSign, kuaishouUtils, parseDmSegMobileReply, parseKuaishouCaptcha, qtparam, requestPassportQrcode, sendPassportVerifyCode, toLegacy, unwrap, validateBilibiliParams, validateDouyinParams, validateKuaishouParams, validatePassportVerifyCode, validateXiaohongshuParams, wbi_sign, wrapFetcher, xiaohongshuApiUrls, xiaohongshuSign, xiaohongshuUtils };

package/dist/exports/signing.cjs

@@ -0,0 +1,437 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_tokens = require("../tokens-DHKAuPVW.cjs");
+//#region src/platforms/douyin/sign/decode.ts
+/**
+* 把签名参数读回明文 —— 验证工具的解码层。
+*
+* 移植自 Douyin_TikTok_Download_API 的 `signing/native/decoding.py`（Apache-2.0）。
+* 存在的理由只有一个：**证明签名实现还是对的**。
+*
+* ## 为什么需要它
+*
+* 抖音对签名是抽样校验的，所以「请求成功」证明不了任何事。唯一能证伪一个常量的办法，
+* 是把真实签名拆开看。旧实现用错盐值（`cus`）活了两年没被发现，就是因为整套测试都是
+* 自证的——自生成快照、和被测量对象比自身、以及没有任何一条断言能证伪一个常量。
+*
+* 这个模块提供外部锚点：给它一份浏览器产出的签名，它会告诉你签名里封住的到底是什么，
+* 以及你手上的候选输入是不是它封的那一个。
+*
+* ## 「解码」在这里诚实地指三件不同的事
+*
+* 把它们混为一谈，就是这类工具开始撒谎的方式：
+*
+* - **可还原**：值就在载荷里，能原样取回。时钟、`aid`、`page_id`、屏幕几何串、
+*   版本串、调用计数。没有任何推断。
+* - **被绑定但不可还原**：载荷里带着某个东西的摘要——a_bogus 里是 query / body / UA
+*   各三个 SM3 字节。输入无法从摘要倒推出来，所以这个模块**从不假装能**。它做的是
+*   **校验**：给它一个候选值，它回答这个候选是不是签名封住的那一个，以及有多少位证据
+*   支持这个结论。这才是哈希真正的逆运算，而且比猜一个值有用得多——它把
+*   「我的请求被拒了」变成「我发的这个签名是对着另一条 URL 算的」。
+* - **根本没被计算**：`msToken` 与访客令牌由平台签发或随机抽出来，底下没有明文可找。
+*   说出这一点就是答案，而不是「没能给出答案」。
+*
+* 每个字段都携带自己属于哪一类，读者不会被留在「标签旁边那个数字是读出来的还是推出来的」
+* 这种猜测里。
+*
+* 这里没有任何东西用于签名。它只跑在调用方已经持有的值上，不碰网络、不消耗身份。
+*/
+/** 字段是什么。控制台按它上色，调用方也可以对它分支 */
+const KIND = {
+	/** 从载荷里直接读出，就是签名者放进去的东西 */
+	PLAIN: "plain",
+	/** 一个时钟，同时给出原始数字与 ISO-8601 时刻 */
+	TIME: "time",
+	/** 哈希或哈希的一个字节。输入不可还原——见 checks */
+	DIGEST: "digest",
+	/** 内部冗余。在这里重算，这正是解码得以自证的依据 */
+	CHECKSUM: "checksum",
+	/** SDK 对它自认为身处其中的页面所做的回报 */
+	ENVIRONMENT: "environment",
+	/** 每次捕获里都有、但含义未被确认的东西。命名它，而不是编造它 */
+	OPAQUE: "opaque"
+};
+/** 一个参数底下为什么没有明文 */
+const REASON = {
+	MALFORMED: "malformed",
+	NOT_COMPUTED: "not_computed",
+	ONE_WAY: "one_way",
+	UNKNOWN_PARAMETER: "unknown_parameter"
+};
+/** 候选输入是不是签名封住的那一个 */
+const CHECK = {
+	MATCH: "match",
+	DIFFERS: "differs",
+	NOT_SUPPLIED: "not_supplied"
+};
+/** 每条摘要链钉住输入的位数 */
+const CHAIN_BITS = 24;
+const FORTNIGHT_MS = 12096e5;
+/** 毫秒时钟转 ISO-8601 UTC；数字荒诞到解析不了时退回原样，因为那通常正是它最有意思的地方 */
+const instant = (milliseconds) => {
+	const date = new Date(milliseconds);
+	return Number.isNaN(date.getTime()) ? String(milliseconds) : date.toISOString().replace(".000Z", "Z");
+};
+const clockField = (name, milliseconds, detail) => ({
+	name,
+	value: `${milliseconds} (${instant(milliseconds)})`,
+	kind: KIND.TIME,
+	detail
+});
+const check = (name, expected, actual, covered) => expected.join(",") === actual.join(",") ? {
+	name,
+	status: CHECK.MATCH,
+	bits: CHAIN_BITS,
+	covered
+} : {
+	name,
+	status: CHECK.DIFFERS,
+	bits: CHAIN_BITS
+};
+/**
+* 拆开一份 `a_bogus`，并就调用方给出的候选值做校验。
+* @param value - `a_bogus` 的值
+* @param candidates - 候选的 query / body / User-Agent，给哪个校验哪个
+* @returns 拆解结果；格式不合法时 `recovered` 为 `false` 并给出 `reason`
+*/
+const decodeABogus = (value, candidates = {}) => {
+	const problem = require_tokens.structureError(value);
+	if (problem !== null) return {
+		parameter: "a_bogus",
+		platform: "douyin",
+		algorithm: "a_bogus",
+		recovered: false,
+		reason: `${REASON.MALFORMED}:${problem}`,
+		fields: [],
+		checks: [],
+		notes: []
+	};
+	const raw = require_tokens.decode(value);
+	const scalars = raw.fields;
+	const fortnights = scalars.L26;
+	const fields = [
+		{
+			name: "header_magic",
+			value: `[${raw.headerMagic.join(", ")}]`,
+			kind: KIND.PLAIN
+		},
+		{
+			name: "sdk_version",
+			value: raw.sdkVersion.join("."),
+			kind: KIND.PLAIN
+		},
+		clockField("now_ms", raw.nowMs),
+		clockField("ink_ms", raw.inkMs, "now_ms - 1，SDK 对自己的存活检查"),
+		{
+			name: "aid",
+			value: String(raw.aid),
+			kind: KIND.PLAIN
+		},
+		{
+			name: "page_id",
+			value: String(raw.pageId),
+			kind: KIND.PLAIN
+		},
+		{
+			name: "fortnights",
+			value: `${fortnights} (${instant(require_tokens.FORTNIGHT_EPOCH_MS + fortnights * FORTNIGHT_MS)})`,
+			kind: KIND.PLAIN,
+			detail: "自 a_bogus 纪元起的「两周」数"
+		},
+		{
+			name: "browser_info",
+			value: raw.browserInfo,
+			kind: KIND.ENVIRONMENT,
+			detail: "屏幕|可视区|…"
+		},
+		{
+			name: "tail",
+			value: raw.tail,
+			kind: KIND.PLAIN,
+			detail: "(now_ms + 3) & 0xFF"
+		},
+		{
+			name: "env_flags",
+			value: String(raw.envFlags),
+			kind: KIND.ENVIRONMENT
+		},
+		{
+			name: "detect_flags",
+			value: String(raw.detectFlags),
+			kind: KIND.ENVIRONMENT
+		},
+		{
+			name: "call_bucket",
+			value: String(raw.callBucket),
+			kind: KIND.ENVIRONMENT
+		},
+		{
+			name: "tripwire",
+			value: String(raw.tripwire),
+			kind: KIND.ENVIRONMENT
+		}
+	];
+	const inputByChain = {
+		query: candidates.query,
+		body: candidates.body,
+		user_agent: candidates.userAgent
+	};
+	const emptyBody = require_tokens.chainBytes(require_tokens.DIGEST_CHAINS.body, require_tokens.digestWith("", require_tokens.SALT));
+	const checks = [];
+	for (const [name, chain] of Object.entries(require_tokens.DIGEST_CHAINS)) {
+		const carried = chain.slots.map((slot) => scalars[slot]);
+		let detail = `${name} 链的 3 个字节，落在 ${chain.slots.join(", ")}`;
+		if (name === "body" && carried.join(",") === emptyBody.join(",")) detail = `${detail}；与空 body 一致，GET 就是这种情况`;
+		fields.push({
+			name: `${name}_digest`,
+			value: carried.join(" "),
+			kind: KIND.DIGEST,
+			detail
+		});
+		const candidate = inputByChain[name];
+		if (candidate === void 0) {
+			checks.push({
+				name,
+				status: CHECK.NOT_SUPPLIED,
+				bits: CHAIN_BITS
+			});
+			continue;
+		}
+		const digest = name === "user_agent" ? require_tokens.userAgentDigest(candidate, {
+			envFlags: raw.envFlags,
+			detectFlags: raw.detectFlags
+		}) : require_tokens.digestWith(candidate, require_tokens.SALT);
+		checks.push(check(name, require_tokens.chainBytes(chain, digest), carried, candidate));
+	}
+	return {
+		parameter: "a_bogus",
+		platform: "douyin",
+		algorithm: "a_bogus",
+		recovered: true,
+		fields,
+		checks,
+		notes: ["checksum_verified", "noise_not_recoverable"]
+	};
+};
+/**
+* 反推一份签名用的是哪个盐值 —— **这个工具存在的核心理由**。
+*
+* 做法与当初发现 `cus` 过期时完全一样：签名里封着 query 链的三个字节，把候选盐值逐个
+* 代进去重算摘要，能重现那三个字节的就是当前盐值。整件事不需要网络、不需要身份、
+* 也不依赖抖音是否接受了你的请求——这正是它能发现「请求照样成功但常量已经过期」的原因。
+*
+* ## 只有 query 链参与判定
+*
+* body 链在 GET 上与空串一致，而 UA 链**根本不吃盐值**（它走 RC4 加单次 SM3），
+* 两条对判定都没有贡献，所以这里的候选盐值只对 query 生效。证据量是 24 位，
+* 实战足够——但要说明，而不是藏起来。
+* @param value - 一份真实的 `a_bogus`
+* @param query - 该签名所覆盖的那条 query（不含 `a_bogus` 自身）
+* @param salts - 待测的盐值候选
+* @returns 判定结果
+*/
+const diagnoseSalt = (value, query, salts = [require_tokens.SALT, "cus"]) => {
+	if (require_tokens.structureError(value) !== null) return {
+		salt: null,
+		observed: [],
+		results: []
+	};
+	const chain = require_tokens.DIGEST_CHAINS.query;
+	const scalars = require_tokens.decode(value).fields;
+	const observed = chain.slots.map((slot) => scalars[slot]);
+	const results = salts.map((salt) => {
+		const predicted = require_tokens.chainBytes(chain, require_tokens.digestWith(query, salt));
+		return {
+			salt,
+			predicted,
+			matched: predicted.join(",") === observed.join(",")
+		};
+	});
+	return {
+		salt: results.find((row) => row.matched)?.salt ?? null,
+		observed,
+		results
+	};
+};
+/**
+* 只按形状猜一个值是什么参数。用于调用方不知道自己在看什么的时候。
+*
+* 只做形状判断，不做任何密码学断言——猜错时返回 `null` 比返回一个错答案好。
+* @param value - 待识别的值
+* @returns 参数名或 `null`
+*/
+const identify = (value) => {
+	if (!value) return null;
+	if (require_tokens.structureError(value) === null) return "a_bogus";
+	if (/^verify_[0-9a-z]+_/.test(value)) return "verifyFp";
+	if (value.length === 28 && /^[A-Za-z0-9_=+/-]+$/.test(value)) return "X-Bogus";
+	if (value.length >= 100 && /^[A-Za-z0-9+-]+=*$/.test(value)) return "msToken";
+	if (/^[0-9a-f]{32}$/i.test(value)) return "x-secsdk-web-signature";
+	return null;
+};
+/**
+* 签名**一定**不覆盖的参数。
+*
+* `a_bogus` 是签名自身；`timestamp` 与 `x-secsdk-web-signature` 由 secsdk 在签名
+* **之后**追加 —— 这一点在真实捕获与 amagi 自己的管线里一致。
+*/
+const NEVER_SIGNED = [
+	"a_bogus",
+	"timestamp",
+	"x-secsdk-web-signature"
+];
+/**
+* 是否被签名覆盖**随管线而异**的参数。
+*
+* 不要猜。真实浏览器捕获里 `uifid` 在 `a_bogus` **之前**（因而被签名覆盖），
+* 而 amagi 的管线是 `webid → a_bogus → secsdk`，`uifid` 由 secsdk 在之后补上
+* （因而没被覆盖）。同一个参数名，两边结论相反 —— 所以这里把四种参数做成
+* 2⁴ 种组合逐个试，命中的那一种就是答案。
+*/
+const SIGNING_AMBIGUOUS = [
+	"uifid",
+	"msToken",
+	"verifyFp",
+	"fp"
+];
+/**
+* 反推一份签名**当时覆盖的那条 query**，以及用的是哪个盐值。
+*
+* 这是 {@link diagnoseSalt} 的加强版：那份要求调用方已经知道签名覆盖了哪些参数，
+* 而线上抓来的 URL 里，`uifid` / `msToken` / `verifyFp` / `fp` 到底在签名前还是
+* 签名后，取决于页面当时挂的是哪条管线 —— 同一份代码在浏览器里和在 amagi 里顺序
+* 就是不一样的。与其让调用方去猜，这里把 2⁴ 种组合全试一遍，报出命中的那一种。
+*
+* 命中意味着**两件事同时成立**：这是一份结构良好的 a_bogus，且它的 query 链在给定
+* 盐值下重现了这条 query。所以它是「验证」而不只是「解码」。
+* @param signature - `a_bogus` 的值（未做 URL 编码）
+* @param url - 已签名的完整 URL
+* @param salts - 待搜的盐值候选
+* @returns 命中结果；没有任何组合命中时返回 `null`
+*/
+const recoverSignedQuery = (signature, url, salts = [require_tokens.SALT]) => {
+	if (require_tokens.structureError(signature) !== null) return null;
+	const chain = require_tokens.DIGEST_CHAINS.query;
+	const scalars = require_tokens.decode(signature).fields;
+	const observed = chain.slots.map((slot) => scalars[slot]).join(",");
+	let tried = 0;
+	for (let mask = 0; mask < 1 << SIGNING_AMBIGUOUS.length; mask++) {
+		const kept = SIGNING_AMBIGUOUS.filter((_, index) => (mask & 1 << index) !== 0);
+		const parsed = new URL(url);
+		for (const name of NEVER_SIGNED) parsed.searchParams.delete(name);
+		for (const name of SIGNING_AMBIGUOUS) if (!kept.includes(name)) parsed.searchParams.delete(name);
+		const query = parsed.searchParams.toString();
+		for (const salt of salts) {
+			tried++;
+			if (require_tokens.chainBytes(chain, require_tokens.digestWith(query, salt)).join(",") === observed) return {
+				query,
+				kept,
+				salt,
+				tried
+			};
+		}
+	}
+	return null;
+};
+/**
+* 从一条已签名的 URL 里重建出签名覆盖的那条 query（不再搜索，按固定规则摘参数）。
+*
+* **只在已知管线顺序时使用。** 面对来源不明的 URL 请用 {@link recoverSignedQuery}，
+* 它会搜索并告诉你哪条重建成立。保留这个函数是为了让「摘掉签名参数」这件事在
+* 需要确定行为的地方仍然可用。
+* @param url - 已签名的完整 URL
+* @returns 摘掉 `a_bogus` / `timestamp` / `x-secsdk-web-signature` 之后的 query
+*/
+const signedQueryOf = (url) => {
+	const parsed = new URL(url);
+	for (const name of NEVER_SIGNED) parsed.searchParams.delete(name);
+	return parsed.searchParams.toString();
+};
+/**
+* 拆开一条 URL 上所有认得出的签名参数。
+*
+* 会先尝试 {@link recoverSignedQuery} 找出签名真正覆盖的那条 query；找不到时退回
+* {@link signedQueryOf} 的结果，并把这个不确定性体现在 `notes` 里。
+* @param url - 已签名的完整 URL
+* @param options - 可选的 User-Agent、显式 query 与盐值候选
+* @returns 每个参数一条拆解结果
+*/
+const decodeUrl = (url, options = {}) => {
+	const aBogus = new URL(url).searchParams.get("a_bogus");
+	if (aBogus === null) return [];
+	const signature = decodeURIComponent(aBogus);
+	const recovery = options.query ? null : recoverSignedQuery(signature, url, options.salts ?? ["dhzx"]);
+	const query = options.query ?? recovery?.query ?? signedQueryOf(url);
+	const decoded = decodeABogus(signature, {
+		query,
+		body: options.body,
+		userAgent: options.userAgent
+	});
+	if (recovery) {
+		decoded.notes.push(`query_recovered:kept=${recovery.kept.join("+") || "(none)"}`);
+		decoded.fields.push({
+			name: "signed_query",
+			value: recovery.query,
+			kind: KIND.PLAIN,
+			detail: `从 ${recovery.tried} 种组合中命中：保留了 ${recovery.kept.join("、") || "（不保留任何可选参数）"}`
+		});
+	} else if (!options.query) decoded.notes.push("query_reconstructed_by_rule:no_combination_matched");
+	return [decoded];
+};
+//#endregion
+exports.ABogus = require_tokens.ABogus;
+exports.AID = require_tokens.AID;
+exports.ALPHABETS = require_tokens.ALPHABETS;
+exports.CALL_BUCKET = require_tokens.CALL_BUCKET;
+exports.CHECK = CHECK;
+exports.DEFAULT_BROWSER_INFO = require_tokens.DEFAULT_BROWSER_INFO;
+exports.DETECT_FLAGS = require_tokens.DETECT_FLAGS;
+exports.DIGEST_CHAINS = require_tokens.DIGEST_CHAINS;
+exports.DOUYIN_MS_TOKEN_LENGTH = require_tokens.DOUYIN_MS_TOKEN_LENGTH;
+exports.DOUYIN_MS_TOKEN_SIZES = require_tokens.DOUYIN_MS_TOKEN_SIZES;
+exports.DOUYIN_TTWID = require_tokens.DOUYIN_TTWID;
+exports.DOUYIN_TTWID_PAYLOAD = require_tokens.DOUYIN_TTWID_PAYLOAD;
+exports.ENV_FLAGS = require_tokens.ENV_FLAGS;
+exports.FIELD_ORDER = require_tokens.FIELD_ORDER;
+exports.FORTNIGHT_EPOCH_MS = require_tokens.FORTNIGHT_EPOCH_MS;
+exports.HEADER_MAGIC = require_tokens.HEADER_MAGIC;
+exports.KIND = KIND;
+exports.MS_TOKEN_ALPHABET = require_tokens.MS_TOKEN_ALPHABET;
+exports.PAGE_ID = require_tokens.PAGE_ID;
+exports.PAYLOAD_KEY = require_tokens.PAYLOAD_KEY;
+exports.REASON = REASON;
+exports.SALT = require_tokens.SALT;
+exports.SDK_VERSION = require_tokens.SDK_VERSION;
+exports.SM3_IV = require_tokens.SM3_IV;
+exports.TRIPWIRE_LOCKED = require_tokens.TRIPWIRE_LOCKED;
+exports.TTWID_REGISTER_URL = require_tokens.TTWID_REGISTER_URL;
+exports.VERIFY_FP_ALPHABET = require_tokens.VERIFY_FP_ALPHABET;
+exports.VERIFY_FP_LENGTH = require_tokens.VERIFY_FP_LENGTH;
+exports.browserInfoFromScreen = require_tokens.browserInfoFromScreen;
+exports.buildBrowserInfo = require_tokens.buildBrowserInfo;
+exports.canary = require_tokens.canary;
+exports.chainBytes = require_tokens.chainBytes;
+exports.decode = require_tokens.decode;
+exports.decodeABogus = decodeABogus;
+exports.decodeBase64 = require_tokens.decodeBase64;
+exports.decodeUrl = decodeUrl;
+exports.diagnoseSalt = diagnoseSalt;
+exports.digestOf = require_tokens.digestOf;
+exports.digestWith = require_tokens.digestWith;
+exports.encodeBase64 = require_tokens.encodeBase64;
+exports.genFalseMsToken = require_tokens.genFalseMsToken;
+exports.genSVWebId = require_tokens.genSVWebId;
+exports.genVerifyFp = require_tokens.genVerifyFp;
+exports.identify = identify;
+exports.isDecodeProblem = require_tokens.isDecodeProblem;
+exports.jsBytes = require_tokens.jsBytes;
+exports.msTokenPayload = require_tokens.msTokenPayload;
+exports.rc4 = require_tokens.rc4;
+exports.recoverSignedQuery = recoverSignedQuery;
+exports.signedQueryOf = signedQueryOf;
+exports.sm3Hash = require_tokens.sm3Hash;
+exports.sm3Hexdigest = require_tokens.sm3Hexdigest;
+exports.sm3ToArray = require_tokens.sm3ToArray;
+exports.structureError = require_tokens.structureError;
+exports.toBase36 = require_tokens.toBase36;
+exports.unmaskPair = require_tokens.unmaskPair;
+exports.userAgentDigest = require_tokens.userAgentDigest;