@ikenxuan/amagi 7.0.0-beta.4 → 7.0.0-beta.6

package/dist/{src-ocSC1FCs.mjs → src-BHqC-g47.mjs}

@@ -1,13 +1,13 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { C as wbi, S as qtparam$1, _ as douyinSign$1, a as createXiaohongshuGuestCookie$1, b as getCookieValue, c as sharedKuaishouSigner, d as douyinBogus, f as douyinXBogus, g as applySecsdkWebSign, h as xBogus, i as getSearchId, l as deriveKuaishouPureSignature, m as secsdk, n as traceId, o as createXiaohongshuCryptoConfig, p as msToken, r as xs, s as hxfalcon, t as rap, u as aBogus$1, v as XBogus, x as AmagiHeaders, y as observeDouyinWebid } from "./steps-DQlwODdh.mjs";
 import { A as a_bogus_default, M as buildBrowserInfo, d as genVerifyFp, m as ABogus, o as TTWID_REGISTER_URL, r as DOUYIN_TTWID } from "./tokens-BFqSOfhx.mjs";
-import URL$1 from "node:url";
 import express, { Router } from "express";
 import zod from "zod";
+import crypto, { createCipheriv, createHash, randomBytes, randomUUID } from "node:crypto";
 import protobuf from "protobufjs";
 import axios, { AxiosError, AxiosHeaders, mergeConfig } from "axios";
 import { EventEmitter } from "node:events";
-import crypto, { createCipheriv, createHash, randomBytes, randomUUID } from "node:crypto";
-import { CryptoConfig, FingerprintGenerator, Xhshow, xRapParam } from "@ikenxuan/xhshow-ts";
+import { FingerprintGenerator, Xhshow } from "@ikenxuan/xhshow-ts";
 //#region src/platforms/bilibili/api.ts
 /** B站 API URL 构建类（所有方法只拼 URL，不发起请求） */
 var BilibiliAPI$1 = class {
@@ -169,16 +169,54 @@ const bilibiliApiUrls$1 = new BilibiliAPI$1();
 * @returns 携带 `T` 的令牌，运行时是个空对象
 */
 const type = () => ({});
+/** 反爬参数的执行阶段次序：端点作者不用手排，{@link stepsToSigner} 按这个固定次序排好再跑 */
+const PHASE_ORDER = {
+	prepare: 0,
+	token: 1,
+	sign: 2,
+	finalize: 3
+};
+/**
+* 把一串 {@link SignStep} 压成一个签名器：按 {@link SignPhase} 稳定排序后依次 `apply`。
+* 同 phase 内保留数组出现顺序（`index` 兜底），所以 `[aBogus(), msToken()]` 与
+* `[msToken(), aBogus()]` 结果一致 —— token 阶段恒先于 sign，端点作者写错顺序也不翻车。
+*
+* 两条路径共用它、因此共用同一套排序语义：runtime 解析 {@link SignDecl} 里的 step 清单时用它，
+* 平台签名器表（`sign/signers.ts` 那层薄壳）也用它把注册名对应的 step 清单压成一个 {@link SignFn}。
+* @param steps - 反爬参数清单
+* @returns 依次应用全部步骤的签名函数
+*/
+const stepsToSigner = (steps) => {
+	const ordered = steps.map((step, index) => ({
+		step,
+		index
+	})).sort((a, b) => PHASE_ORDER[a.step.phase] - PHASE_ORDER[b.step.phase] || a.index - b.index).map((entry) => entry.step);
+	return async (spec, ctx) => {
+		let current = spec;
+		for (const step of ordered) current = await step.apply(current, ctx);
+		return current;
+	};
+};
 /**
-* 声明一个端点。
-*
-* 运行时就是恒等函数，全部价值在类型推导：`TParams` 从 `params` 推出，
-* `TData` 从 `response` / `normalize` / `compute` 推出。
+* 声明一个端点。运行时是恒等函数（原样返回 `def`），全部价值在类型推导：
+* `TParams` 从 `params` 推、`TData` 从 `response` / `compute` 推。
+* 平台一般用各自的 `defineXxxEndpoint`（把签名器名收窄），不直接用这个。
 * @param def - 端点声明
-* @returns 原样返回 `def`，但带上推导好的具体类型
 */
 const defineEndpoint = (def) => def;
 //#endregion
+//#region src/platforms/bilibili/endpoints/define.ts
+/**
+* B站端点声明。
+*
+* 就是 {@link defineEndpoint} 绑定了 B站签名器名联合 {@link BilibiliSignerName}：
+* `sign` 的字符串分支被收窄成 `'wbi' | 'qtparam'`，写错名字编译期即报错，不必等
+* 运行时查表失败。运行时仍是恒等函数，其余行为与通用 `defineEndpoint` 完全一致。
+* @param def - 端点声明（`sign` 的名字受 B站签名器表约束）
+* @returns 原样返回 `def`，带上推导好的具体类型
+*/
+const defineBilibiliEndpoint = (def) => defineEndpoint(def);
+//#endregion
 //#region src/platforms/bilibili/endpoints/articleCards.ts
 /**
 * 专栏显示卡片信息（单请求）。
@@ -186,7 +224,7 @@ const defineEndpoint = (def) => def;
 * 与旧版一致：`getArticleCards` GET，无签名。
 * `ids` 可传字符串或字符串数组。
 */
-const articleCards = defineEndpoint({
+const articleCards = defineBilibiliEndpoint({
 	name: "bilibili.articleCards",
 	route: "/fetch_article_card",
 	doc: {
@@ -208,7 +246,7 @@ const articleCards = defineEndpoint({
 *
 * 与旧版一致：`getArticleContent` GET，无签名。
 */
-const articleContent = defineEndpoint({
+const articleContent = defineBilibiliEndpoint({
 	name: "bilibili.articleContent",
 	route: "/fetch_article_content",
 	doc: {
@@ -230,7 +268,7 @@ const articleContent = defineEndpoint({
 *
 * 与旧版一致：`getArticleInfo` GET，无签名。
 */
-const articleInfo = defineEndpoint({
+const articleInfo = defineBilibiliEndpoint({
 	name: "bilibili.articleInfo",
 	route: "/fetch_article_info",
 	doc: {
@@ -252,7 +290,7 @@ const articleInfo = defineEndpoint({
 *
 * 与旧版一致：`getArticleListInfo` GET，无签名。
 */
-const articleListInfo = defineEndpoint({
+const articleListInfo = defineBilibiliEndpoint({
 	name: "bilibili.articleListInfo",
 	route: "/fetch_column_info",
 	doc: {
@@ -328,7 +366,7 @@ const bv2av = (bvid) => {
 *
 * 返回形状：`{ bvid }`。
 */
-const avToBv = defineEndpoint({
+const avToBv = defineBilibiliEndpoint({
 	name: "bilibili.avToBv",
 	route: "/av_to_bv",
 	doc: {
@@ -347,7 +385,7 @@ const avToBv = defineEndpoint({
 * 与旧版一致：`getBangumiInfo` GET，无签名。
 * `ep_id` 与 `season_id` 至少传其一，两者都要求非空串（`ep_id` 优先）。
 */
-const bangumiInfo = defineEndpoint({
+const bangumiInfo = defineBilibiliEndpoint({
 	name: "bilibili.bangumiInfo",
 	route: "/fetch_bangumi_video_info",
 	doc: {
@@ -381,7 +419,7 @@ const bangumiInfo = defineEndpoint({
 * 与旧版一致：`getBangumiStream` GET + qtparam 签名，
 * `ep_id` 去掉 `ep` 前缀。
 */
-const bangumiStream = defineEndpoint({
+const bangumiStream = defineBilibiliEndpoint({
 	name: "bilibili.bangumiStream",
 	route: "/fetch_bangumi_video_playurl",
 	doc: {
@@ -399,7 +437,7 @@ const bangumiStream = defineEndpoint({
 			ep_id: p.ep_id.replace("ep", "")
 		})
 	}),
-	sign: "qtparam",
+	sign: [qtparam$1()],
 	retryOn: ["RISK_CONTROL"],
 	response: type()
 });
@@ -412,7 +450,7 @@ const bangumiStream = defineEndpoint({
 *
 * 返回 `{ aid: number }`，不带 `av` 前缀。
 */
-const bvToAv = defineEndpoint({
+const bvToAv = defineBilibiliEndpoint({
 	name: "bilibili.bvToAv",
 	route: "/bv_to_av",
 	doc: {
@@ -431,7 +469,7 @@ const bvToAv = defineEndpoint({
 * 与旧版一致：`getCaptchaFromVoucher` POST，
 * body 为 `{ csrf?, v_voucher }`，无签名。
 */
-const captchaFromVoucher = defineEndpoint({
+const captchaFromVoucher = defineBilibiliEndpoint({
 	name: "bilibili.captchaFromVoucher",
 	route: "/apply_captcha",
 	doc: {
@@ -461,7 +499,7 @@ const captchaFromVoucher = defineEndpoint({
 *
 * 与旧版一致：`getCommentReplies` GET，无签名。
 */
-const commentReplies$1 = defineEndpoint({
+const commentReplies$1 = defineBilibiliEndpoint({
 	name: "bilibili.commentReplies",
 	route: "/fetch_comment_reply",
 	doc: {
@@ -524,7 +562,7 @@ const COMMENT_TYPES$1 = [
 *   按 `rpid` 去重 + 截断到 `number`。
 * - 未开放评论区由主接口返回非 0 的 `code`，由 judge 判失败。
 */
-const comments$2 = defineEndpoint({
+const comments$2 = defineBilibiliEndpoint({
 	name: "bilibili.comments",
 	route: "/fetch_work_comments",
 	doc: {
@@ -549,7 +587,7 @@ const comments$2 = defineEndpoint({
 			mode: p.mode
 		})
 	}),
-	sign: "wbi",
+	sign: [wbi()],
 	paginate: {
 		maxPageSize: 100,
 		items: (page) => page.data?.replies ?? [],
@@ -563,20 +601,18 @@ const comments$2 = defineEndpoint({
 				...params,
 				pagination_str: next ?? params.pagination_str
 			};
+		},
+		merge: ({ lastPage, items }, params) => {
+			const sliced = Array.from(new Map(items.map((item) => [item.rpid, item])).values()).slice(0, params.number ?? 20);
+			return {
+				...lastPage,
+				data: {
+					...lastPage.data,
+					replies: sliced
+				}
+			};
 		}
 	},
-	normalize: (decoded, params) => {
-		const { lastPage, items } = decoded;
-		const page = lastPage;
-		const sliced = Array.from(new Map(items.map((item) => [item.rpid, item])).values()).slice(0, params.number ?? 20);
-		return {
-			...page ?? {},
-			data: {
-				...page?.data ?? {},
-				replies: sliced
-			}
-		};
-	},
 	retryOn: ["RISK_CONTROL"],
 	response: type()
 });
@@ -612,7 +648,7 @@ const COMMENT_TYPES = [
 *
 * 与旧版一致：`getDynamicDetail` GET，无签名。
 */
-const dynamicDetail = defineEndpoint({
+const dynamicDetail = defineBilibiliEndpoint({
 	name: "bilibili.dynamicDetail",
 	route: "/fetch_dynamic_info",
 	doc: {
@@ -635,7 +671,7 @@ const dynamicDetail = defineEndpoint({
 * 与旧版一致：`getEmojiList` GET，无签名。
 * 它是网络请求（表情面板接口），不是本地计算。
 */
-const emojiList$4 = defineEndpoint({
+const emojiList$4 = defineBilibiliEndpoint({
 	name: "bilibili.emojiList",
 	route: "/fetch_emoji_list",
 	doc: {
@@ -657,7 +693,7 @@ const emojiList$4 = defineEndpoint({
 *
 * 与旧版一致：`getLiveRoomInfo` GET，无签名。
 */
-const liveRoomInfo$2 = defineEndpoint({
+const liveRoomInfo$2 = defineBilibiliEndpoint({
 	name: "bilibili.liveRoomInfo",
 	route: "/fetch_live_room_detail",
 	doc: {
@@ -679,7 +715,7 @@ const liveRoomInfo$2 = defineEndpoint({
 *
 * 与旧版一致：`getLiveRoomInit` GET，无签名。
 */
-const liveRoomInit = defineEndpoint({
+const liveRoomInit = defineBilibiliEndpoint({
 	name: "bilibili.liveRoomInit",
 	route: "/fetch_liveroom_def",
 	doc: {
@@ -701,7 +737,7 @@ const liveRoomInit = defineEndpoint({
 *
 * 与旧版一致：`getLoginQrcode` GET，无签名。
 */
-const loginQrcode$1 = defineEndpoint({
+const loginQrcode$1 = defineBilibiliEndpoint({
 	name: "bilibili.loginQrcode",
 	route: "/new_login_qrcode",
 	doc: {
@@ -723,7 +759,7 @@ const loginQrcode$1 = defineEndpoint({
 *
 * 与旧版一致：`getLoginStatus` GET，无签名。
 */
-const loginStatus = defineEndpoint({
+const loginStatus = defineBilibiliEndpoint({
 	name: "bilibili.loginStatus",
 	route: "/login_basic_info",
 	doc: {
@@ -746,7 +782,7 @@ const loginStatus = defineEndpoint({
 * 与旧版一致：`getQrcodeStatus` GET，无签名。
 * **返回形状**：只返回平台响应体（`code` / `data` / `message`），不透出响应 headers。
 */
-const qrcodeStatus = defineEndpoint({
+const qrcodeStatus = defineBilibiliEndpoint({
 	name: "bilibili.qrcodeStatus",
 	route: "/check_qrcode",
 	doc: {
@@ -768,7 +804,7 @@ const qrcodeStatus = defineEndpoint({
 *
 * 与旧版一致：`getUploaderTotalViews` GET，无签名。
 */
-const uploaderTotalViews = defineEndpoint({
+const uploaderTotalViews = defineBilibiliEndpoint({
 	name: "bilibili.uploaderTotalViews",
 	route: "/fetch_user_full_view",
 	doc: {
@@ -790,7 +826,7 @@ const uploaderTotalViews = defineEndpoint({
 *
 * 与旧版一致：`getUserCard` GET，无签名。
 */
-const userCard = defineEndpoint({
+const userCard = defineBilibiliEndpoint({
 	name: "bilibili.userCard",
 	route: "/fetch_user_profile",
 	doc: {
@@ -806,112 +842,6 @@ const userCard = defineEndpoint({
 	response: type()
 });
 //#endregion
-//#region src/contracts/request.ts
-/**
-* 大小写不敏感的 header 容器。
-*
-* HTTP header 名本身大小写不敏感，用普通对象装就会出现「写了 `Cookie` 却读
-* `cookie` 读不到」这类静默失配。本类把「大小写」这个变量彻底消掉。
-*
-* 语义：
-* - 查找、判断、删除全部大小写不敏感。
-* - 写入是「后写覆盖」：值覆盖，**显示用的大小写也跟着最后一次写入**，
-*   所以 `set('User-Agent', a)` 之后 `set('user-agent', b)` 只会留下一个
-*   `user-agent: b`，不可能出现两条同名 header。
-* - `undefined` / `null` 的值视为「不写这个 header」，方便直接摊入可选字段。
-*/
-var AmagiHeaders = class AmagiHeaders {
-	/** key 是小写化的 header 名，value 保留最后一次写入的原始大小写与值 */
-	entries = /* @__PURE__ */ new Map();
-	/**
-	* @param init - 初始 header，可以是另一个 `AmagiHeaders` 或普通对象
-	*/
-	constructor(init) {
-		this.merge(init);
-	}
-	/**
-	* 读取 header 值，大小写不敏感
-	* @param name - header 名，任意大小写
-	* @returns 值，不存在时返回 `undefined`
-	*/
-	get(name) {
-		return this.entries.get(name.toLowerCase())?.value;
-	}
-	/**
-	* 判断 header 是否存在，大小写不敏感
-	* @param name - header 名，任意大小写
-	* @returns 存在则返回 `true`
-	*/
-	has(name) {
-		return this.entries.has(name.toLowerCase());
-	}
-	/**
-	* 写入 header。同名（忽略大小写）时覆盖值与显示大小写
-	* @param name - header 名
-	* @param value - 值。`undefined` / `null` 表示不写入
-	* @returns 自身，便于链式调用
-	*/
-	set(name, value) {
-		if (value === void 0 || value === null) return this;
-		this.entries.set(name.toLowerCase(), {
-			name,
-			value: String(value)
-		});
-		return this;
-	}
-	/**
-	* 删除 header，大小写不敏感
-	* @param name - header 名
-	* @returns 原本存在则返回 `true`
-	*/
-	delete(name) {
-		return this.entries.delete(name.toLowerCase());
-	}
-	/**
-	* 合并另一组 header，后来者覆盖
-	* @param input - 待合并的 header
-	* @returns 自身，便于链式调用
-	*/
-	merge(input) {
-		if (!input) return this;
-		const pairs = input instanceof AmagiHeaders ? input.toEntries() : Object.entries(input);
-		for (const [name, value] of pairs) this.set(name, value);
-		return this;
-	}
-	/** header 条数 */
-	get size() {
-		return this.entries.size;
-	}
-	/**
-	* 全部 header 名，保留最后一次写入的大小写
-	* @returns header 名数组
-	*/
-	keys() {
-		return [...this.entries.values()].map((e) => e.name);
-	}
-	/**
-	* 全部 `[名, 值]` 对，名保留最后一次写入的大小写
-	* @returns 键值对数组
-	*/
-	toEntries() {
-		return [...this.entries.values()].map((e) => [e.name, e.value]);
-	}
-	/**
-	* 转成普通对象，用于交给 axios
-	* @returns 普通 header 对象，键保留最后一次写入的大小写
-	*/
-	toJSON() {
-		return Object.fromEntries(this.toEntries());
-	}
-	/**
-	* 深拷贝一份，避免下游改写上游的 header
-	* @returns 新的 `AmagiHeaders` 实例
-	*/
-	clone() {
-		return new AmagiHeaders(this);
-	}
-};
-//#endregion
 //#region src/platforms/bilibili/endpoints/userDynamicList.ts
 /**
 * 用户空间动态（wbi 签名 + Origin/Referer 注入）。
@@ -921,7 +851,7 @@ var AmagiHeaders = class AmagiHeaders {
 * `Referer: https://space.bilibili.com/{host_mid}/dynamic`
 * （调用方显式传了 Referer 则不覆盖）。
 */
-const userDynamicList = defineEndpoint({
+const userDynamicList = defineBilibiliEndpoint({
 	name: "bilibili.userDynamicList",
 	route: "/fetch_user_dynamic",
 	doc: {
@@ -939,7 +869,7 @@ const userDynamicList = defineEndpoint({
 			headers
 		};
 	},
-	sign: "wbi",
+	sign: [wbi()],
 	retryOn: ["RISK_CONTROL"],
 	response: type()
 });
@@ -950,7 +880,7 @@ const userDynamicList = defineEndpoint({
 *
 * 与旧版一致：`getUserLiveStatus` GET，无签名。
 */
-const userLiveStatus = defineEndpoint({
+const userLiveStatus = defineBilibiliEndpoint({
 	name: "bilibili.userLiveStatus",
 	route: "/fetch_user_live_status",
 	doc: {
@@ -972,7 +902,7 @@ const userLiveStatus = defineEndpoint({
 *
 * 与旧版一致：`getUserSpaceInfo` GET + wbi 签名。
 */
-const userSpaceInfo = defineEndpoint({
+const userSpaceInfo = defineBilibiliEndpoint({
 	name: "bilibili.userSpaceInfo",
 	route: "/fetch_user_space_info",
 	doc: {
@@ -984,7 +914,7 @@ const userSpaceInfo = defineEndpoint({
 		method: "GET",
 		url: bilibiliApiUrls$1.getUserSpaceInfo(p)
 	}),
-	sign: "wbi",
+	sign: [wbi()],
 	retryOn: ["RISK_CONTROL"],
 	response: type()
 });
@@ -996,7 +926,7 @@ const userSpaceInfo = defineEndpoint({
 * 与旧版一致：`validateCaptcha` POST，
 * body 为 `{ challenge, token, validate, seccode, csrf? }`，无签名。
 */
-const validateCaptcha = defineEndpoint({
+const validateCaptcha = defineBilibiliEndpoint({
 	name: "bilibili.validateCaptcha",
 	route: "/validate_captcha",
 	doc: {
@@ -1133,7 +1063,7 @@ function parseDmSegMobileReply(data) {
 * judge 恒成功：二进制响应没有 `code` 字段，交给 decode 解析；
 * 解析失败由 execute 归因为 `parse` / `DECODE_FAILED`。
 */
-const videoDanmaku = defineEndpoint({
+const videoDanmaku = defineBilibiliEndpoint({
 	name: "bilibili.videoDanmaku",
 	route: "/fetch_danmaku",
 	doc: {
@@ -1163,7 +1093,7 @@ const videoDanmaku = defineEndpoint({
 * 共 27 条路由。
 */
 const bilibiliRegistry = {
-	videoInfo: defineEndpoint({
+	videoInfo: defineBilibiliEndpoint({
 		name: "bilibili.videoInfo",
 		route: "/fetch_one_video",
 		doc: {
@@ -1178,7 +1108,7 @@ const bilibiliRegistry = {
 		retryOn: ["RISK_CONTROL"],
 		response: type()
 	}),
-	videoStream: defineEndpoint({
+	videoStream: defineBilibiliEndpoint({
 		name: "bilibili.videoStream",
 		route: "/fetch_video_playurl",
 		doc: {
@@ -1193,7 +1123,7 @@ const bilibiliRegistry = {
 			method: "GET",
 			url: bilibiliApiUrls$1.getVideoStream(p)
 		}),
-		sign: "qtparam",
+		sign: [qtparam$1()],
 		retryOn: ["RISK_CONTROL"],
 		response: type()
 	}),
@@ -1974,7 +1904,7 @@ const bilibiliApiUrls = new BilibiliAPI();
 /**
 * 混合密钥编码表，用于对 imgKey 和 subKey 进行字符顺序打乱编码
 */
-const mixinKeyEncTab$1 = [
+const mixinKeyEncTab = [
 	46,
 	47,
 	18,
@@ -2045,7 +1975,7 @@ const mixinKeyEncTab$1 = [
 * @param orig - 原始字符串数组，通常是 img_key + sub_key 的字符数组
 * @returns 返回经过编码表打乱后的32位字符串
 */
-const getMixinKey$1 = (orig) => mixinKeyEncTab$1.map((n) => orig[n]).join("").slice(0, 32);
+const getMixinKey = (orig) => mixinKeyEncTab.map((n) => orig[n]).join("").slice(0, 32);
 /**
 * 为请求参数进行 WBI 签名
 * @param params - 请求参数对象，键值对形式
@@ -2053,8 +1983,8 @@ const getMixinKey$1 = (orig) => mixinKeyEncTab$1.map((n) => orig[n]).join("").sl
 * @param sub_key - 子密钥
 * @returns 返回包含时间戳和签名的查询字符串
 */
-const encWbi$1 = (params, img_key, sub_key) => {
-	const mixin_key = getMixinKey$1(img_key + sub_key);
+const encWbi = (params, img_key, sub_key) => {
+	const mixin_key = getMixinKey(img_key + sub_key);
 	const curr_time = Math.round(Date.now() / 1e3);
 	const chr_filter = /[!'()*]/g;
 	Object.assign(params, { wts: curr_time });
@@ -2089,7 +2019,7 @@ const wbi_sign = async (BASEURL, cookie) => {
 	const url = new URL(BASEURL);
 	const params = {};
 	for (const [key, value] of url.searchParams.entries()) params[key] = value;
-	return encWbi$1(params, web_keys.img_key, web_keys.sub_key);
+	return encWbi(params, web_keys.img_key, web_keys.sub_key);
 };
 //#endregion
 //#region src/platforms/legacy/bilibili/qtparam.ts
@@ -2393,254 +2323,20 @@ const bilibiliJudge = (raw, http) => {
 	};
 };
 //#endregion
-//#region src/platforms/bilibili/sign/qtparam.ts
-/**
-* B站视频流签名器（qtparam 前置）。
-*
-* cookie 取自 `ctx.cookie`（由 `resolveBoundRequest` 用 `AmagiHeaders`
-* 大小写不敏感地解析），这里不自己翻 headers。
-*
-* 行为：
-* - cookie 为空 → 只带 `&platform=html5`（未登录降级）。
-* - 已登录 → 打 `/nav` 取 `vipStatus`（复用 wbi 签名器的 TTL 缓存）：
-*   VIP 带 `&fnval=4048&fourk=1`，非 VIP 带 `&qn=64&fnval=16`，
-*   再追加 wbi 签名（签名基于**未加 fnval 的原始 URL**）。
-*/
-/** 高清档位：qn[3] = 64 = 720P */
-const QN = [
-	6,
-	16,
-	32,
-	64,
-	74,
-	80,
-	112,
-	116,
-	120,
-	125,
-	126,
-	127
-];
-/** VIP 的 fnval：16(DASH) | 64(HDR) | 128(4K) | 256(杜比) | 512(杜比视界) | 1024(8K) | 2048(AV1) = 4048 */
-const VIP_FNVAL = 4048;
-/**
-* 创建 qtparam 签名器。
-*
-* 依赖同一个 {@link WbiSigner} 实例：登录态与 wbi keys 共用一次 `/nav` 的 TTL 缓存。
-* @param wbi - wbi 签名器实例（与 `sign: 'wbi'` 的端点共用）
-* @returns 签名器函数，挂到 `sign: 'qtparam'`
-*/
-const createQtparamSigner = (wbi) => {
-	return async (spec, ctx) => {
-		if (ctx.cookie === "") return {
-			...spec,
-			url: spec.url + "&platform=html5"
-		};
-		const isvip = (await wbi.getNav(ctx)).data?.vipStatus === 1;
-		const qtParams = isvip ? `&fnval=${VIP_FNVAL}&fourk=1` : `&qn=${QN[3]}&fnval=16`;
-		const signed = await wbi.sign(spec, ctx);
-		return {
-			...spec,
-			url: signed.url + qtParams,
-			extra: {
-				...spec.extra,
-				isvip
-			}
-		};
-	};
-};
-//#endregion
-//#region src/platforms/bilibili/sign/wbi.ts
-/**
-* B站 wbi 签名器（实例级）。
-*
-* 两处实现要点：
-* - **走 transport**：`getNav` 用 `ctx.send` 发 `/nav`（`reason: 'prepare'`
-*   进 trace），与主请求走同一条路。
-* - **TTL 缓存随 client 实例**：keys 缓存在实例里，TTL 内连续签名只打一次
-*   `/nav`。
-*
-* 签名算法本身（`mixinKeyEncTab` / `encWbi`）与旧版逐字一致。
-*/
-/** wbi 密钥的 TTL（毫秒）。30 分钟内复用缓存 */
-const WBI_TTL_MS = 18e5;
-/** 混合密钥编码表 */
-const mixinKeyEncTab = [
-	46,
-	47,
-	18,
-	2,
-	53,
-	8,
-	23,
-	32,
-	15,
-	50,
-	10,
-	31,
-	58,
-	3,
-	45,
-	35,
-	27,
-	43,
-	5,
-	49,
-	33,
-	9,
-	42,
-	19,
-	29,
-	28,
-	14,
-	39,
-	12,
-	38,
-	41,
-	13,
-	37,
-	48,
-	7,
-	16,
-	24,
-	55,
-	40,
-	61,
-	26,
-	17,
-	0,
-	1,
-	60,
-	51,
-	30,
-	4,
-	22,
-	25,
-	54,
-	21,
-	56,
-	59,
-	6,
-	63,
-	57,
-	62,
-	11,
-	36,
-	20,
-	34,
-	44,
-	52
-];
-/** 从 URL 末尾取文件名部分（去扩展名），得到 img_key / sub_key */
-const extractKey = (url) => url.slice(url.lastIndexOf("/") + 1, url.lastIndexOf("."));
-/**
-* 对 imgKey 和 subKey 进行字符顺序打乱编码。
-* @param orig - img_key + sub_key 拼接
-* @returns 32 位 mixin key
-*/
-const getMixinKey = (orig) => mixinKeyEncTab.map((n) => orig[n]).join("").slice(0, 32);
-/**
-* 为请求参数计算 wbi 签名。
-* @param params - 请求参数（不含 wts / w_rid）
-* @param img_key - 图片密钥
-* @param sub_key - 子密钥
-* @returns `&wts=..&w_rid=..` 查询串
-*/
-const encWbi = (params, img_key, sub_key) => {
-	const mixin_key = getMixinKey(img_key + sub_key);
-	const curr_time = Math.round(Date.now() / 1e3);
-	const chr_filter = /[!'()*]/g;
-	Object.assign(params, { wts: curr_time });
-	const query = Object.keys(params).sort().map((key) => {
-		const value = params[key].toString().replace(chr_filter, "");
-		return `${encodeURIComponent(key)}=${encodeURIComponent(value)}`;
-	}).join("&");
-	return `&wts=${curr_time}&w_rid=${crypto.createHash("md5").update(query + mixin_key).digest("hex")}`;
-};
+//#region src/platforms/bilibili/sign/signers.ts
 /**
-* B站 wbi 签名器实例。
+* 创建 B站签名器表（薄壳，进程级共享）。
 *
-* 每 client 实例持有一个（`PLATFORM_RUNTIME.bilibili.signers` 里创建），
-* keys 缓存随实例 —— TTL 内 `sign` 不会重复打 `/nav`。
+* 不自建 `WbiSigner` —— `wbi()` / `qtparam()` 内部引用 `steps.ts` 的模块级
+* `sharedWbi`，所以 `createBilibiliSigners()` 调多次也共用同一个实例、同一份
+* `/nav` 缓存（与旧注释「每 client 一份」相反 —— 但实现上本来就只有一份，这里是
+* 让注释对上实现）。
+* @returns 注册名 → 签名器
 */
-var WbiSigner = class {
-	ttlMs;
-	now;
-	nav;
-	/**
-	* @param ttlMs - keys 缓存有效期，默认 {@link WBI_TTL_MS}
-	* @param now - 时钟（可注入）
-	*/
-	constructor(ttlMs = WBI_TTL_MS, now = Date.now) {
-		this.ttlMs = ttlMs;
-		this.now = now;
-	}
-	/**
-	* 取 `/nav` 响应体（带 TTL 缓存）。
-	*
-	* 走 `ctx.send`（reason `'prepare'`）。
-	* @param ctx - 执行上下文（提供 send 与 cookie）
-	* @returns `/nav` 响应体
-	*/
-	async getNav(ctx) {
-		const cached = this.nav;
-		if (cached && this.now() - cached.fetchedAt < this.ttlMs) return cached.body;
-		const body = (await ctx.send({
-			method: "GET",
-			url: "https://api.bilibili.com/x/web-interface/nav",
-			headers: { cookie: ctx.cookie }
-		}, "prepare")).body;
-		this.nav = {
-			body,
-			fetchedAt: this.now()
-		};
-		return body;
-	}
-	/** 从 `/nav` 响应体提取 wbi keys */
-	keysOf(body) {
-		const img = body.data?.wbi_img?.img_url;
-		const sub = body.data?.wbi_img?.sub_url;
-		if (!img || !sub) throw new Error("wbi 密钥获取失败：/nav 响应缺少 wbi_img");
-		return {
-			img_key: extractKey(img),
-			sub_key: extractKey(sub)
-		};
-	}
-	/**
-	* 签名器：给请求 URL 追加 `&wts=..&w_rid=..`。
-	*
-	* `sign: 'wbi'` 的端点（comments / userDynamicList / userSpaceInfo 等）用它。
-	* 首次调用会触发 `/nav` 前置请求（reason `'prepare'`），TTL 内复用。
-	* @param spec - 请求描述
-	* @param ctx - 执行上下文
-	* @returns 带 wbi 签名的请求描述
-	*/
-	sign = async (spec, ctx) => {
-		const nav = await this.getNav(ctx);
-		const { img_key, sub_key } = this.keysOf(nav);
-		const url = new URL(spec.url);
-		const params = {};
-		for (const [key, value] of url.searchParams.entries()) params[key] = value;
-		const query = encWbi(params, img_key, sub_key);
-		return {
-			...spec,
-			url: spec.url + query
-		};
-	};
-};
-/** 创建一个 wbi 签名器实例（每 client 一个） */
-const createWbiSigner = (ttlMs, now) => new WbiSigner(ttlMs, now);
-//#endregion
-//#region src/platforms/bilibili/sign/signers.ts
-/** 创建 B站签名器表（每 client 一份） */
-const createBilibiliSigners = () => {
-	const instance = createWbiSigner();
-	return {
-		wbi: instance.sign,
-		qtparam: createQtparamSigner(instance),
-		instance
-	};
-};
+const createBilibiliSigners = () => ({
+	wbi: stepsToSigner([wbi()]),
+	qtparam: stepsToSigner([qtparam$1()])
+});
 //#endregion
 //#region src/platforms/douyin/config.ts
 /**
@@ -2754,772 +2450,51 @@ const douyinJudge = (raw, http) => {
 	return verdictFromHttpStatus(http.status) ?? { ok: true };
 };
 //#endregion
-//#region src/contracts/cookie.ts
-/**
-* Cookie 契约。
-*
-* **全仓唯一的 cookie 解析与序列化实现。** 解析按 RFC 6265 的键值语义：
-* 名字大小写敏感、值取第一个 `=` 之后的全部内容、不做 URL 解码。
-*
-* `contracts/` 是零依赖叶子层，本文件不 import 任何模块。
-*/
-/**
-* 解析 `name=value; name=value` 形式的 cookie 串。
-*
-* 规则：
-* - 以第一个 `=` 分割，所以值里可以含 `=`（如 base64）。
-* - 名与值两端去空白。
-* - 名为空、或整段没有 `=` 的片段直接跳过。
-* - 同名多次出现时**后者覆盖前者**。
-* - 值不做 URL 解码 —— 签名依赖原始字节，解码会改变签名输入。
-*
-* cookie 名按 RFC 6265 是**大小写敏感**的，因此本函数不做任何大小写归一化。
-* 这与 header 名大小写不敏感（见 `AmagiHeaders`）是两件不同的事。
-* @param cookieString - cookie 串，`undefined` / `null` / 空串都安全
-* @returns 名 → 值的普通对象，无有效项时是空对象
-*/
-const parseCookie = (cookieString) => {
-	const result = {};
-	if (!cookieString) return result;
-	for (const pair of cookieString.split(";")) {
-		const index = pair.indexOf("=");
-		if (index <= 0) continue;
-		const name = pair.slice(0, index).trim();
-		if (!name) continue;
-		result[name] = pair.slice(index + 1).trim();
-	}
-	return result;
-};
-/**
-* 取单条 cookie 的值。
-*
-* **按名精确匹配**，不是子串匹配 ——
-* `getCookieValue('xa1=WRONG; a1=RIGHT', 'a1')` 返回 `'RIGHT'` 而不是 `'WRONG'`。
-* @param cookieString - 完整 cookie 串
-* @param name - cookie 名，大小写敏感
-* @returns 值；不存在时返回 `undefined`
-*/
-const getCookieValue = (cookieString, name) => {
-	if (!cookieString || !name) return void 0;
-	return parseCookie(cookieString)[name];
-};
-//#endregion
-//#region src/platforms/douyin/webid.ts
-/**
-* 抖音 `webid` 的取得与缓存。
-*
-* `webid` 是服务端下发的访客 id，**客户端算不出来** —— 服务端按 `ttwid` 算好之后，
-* 通过每个响应的 `cookie_ttwidinfo_webid` 头告知。一个 ttwid 对应一个稳定的 webid。
-*
-* 抖音会拿 query 里的 `webid` 与 cookie 的会话交叉校验，对不上就返回 HTTP 200 +
-* 空 body（不是 403、也不是业务码），最典型的受害者是 `aweme/favorite`。实测：
-*
-* ```text
-* 浏览器真实的 webid  →  200，1,116,615 字节，19 条
-* 代码里写死的那个    →  200,         0 字节，空
-* 干脆不传            →  200，1,116,776 字节，19 条
-* ```
-*
-* **不传安全，传错致命。** 所以不写死默认值，只在缓存命中时才补。
-* 缓存按 ttwid 分键：换了 cookie，webid 就得跟着换。
-*
-* 顺带澄清一个容易误解的点：填别人的 `webid` **不会**拿到别人的数据 ——
-* 「看谁」由 `sec_user_id` 决定，`webid` 只是设备一致性校验，身份来自 cookie 的
-* `sessionid`。填错只会被拒绝。
-*
-* ## 实现要点
-*
-* 接入的是端点管线：
-*
-* - 键取自 `ctx.cookie`，解析走 `contracts/cookie.ts` 的 `getCookieValue`；
-* - 回收由平台级 `observe` 钩子在每次 send 之后调用，读 `RawResponse.headers`；
-* - 注入由 `sign/signers.ts` 里的第一步完成（`webid → a_bogus/x_bogus → secsdk`），
-*   而不是让同步的 URL 构造去依赖运行期状态。
-*
-* ## 作用域：进程级
-*
-* **这是进程级的，不是每 client 一份** —— 端点定义本身就是模块级单例。
-* 要按 client 隔离得把状态搬到 `ClientCtx` 上。
-* 多 cookie 场景靠 ttwid 分键区分，所以「串用别人的 webid」不会发生。
-*
-* @module platforms/douyin/webid
-*/
-/** ttwid → webid。webid 对同一 ttwid 是稳定的，进程内缓存即可 */
-const cache = /* @__PURE__ */ new Map();
-/** 抖音回传 webid 的响应头 */
-const WEBID_HEADER = "cookie_ttwidinfo_webid";
-/** webid 的形状：纯数字、至少 6 位。不合形状的值一律不收 —— 传错比不传更糟 */
-const WEBID_SHAPE = /^\d{6,}$/;
-/**
-* 从 cookie 串里取 `ttwid`，用作缓存键
-* @param cookie - 本次调用使用的 cookie
-* @returns `ttwid` 的值，取不到时返回空串
-*/
-const ttwidOf = (cookie) => cookie ? getCookieValue(cookie, "ttwid") ?? "" : "";
-/**
-* 看到响应头里的 webid 就记下来。没有这个头、值不合形状、或 cookie 里没有 ttwid
-* （无从分键）时都是无操作。
-* @param res - 本次请求的原始响应
-* @param cookie - 本次请求使用的 cookie，用于取 ttwid 作为缓存键
-*/
-const rememberDouyinWebid = (res, cookie) => {
-	const webid = res.headers.get(WEBID_HEADER);
-	if (!webid || !WEBID_SHAPE.test(webid)) return;
-	const key = ttwidOf(cookie);
-	if (key) cache.set(key, webid);
-};
-/**
-* 取这份 cookie 对应的 webid
-* @param cookie - 本次调用使用的 cookie
-* @returns 缓存里的 webid，没有时返回空串
-*/
-const douyinWebidFor = (cookie) => cache.get(ttwidOf(cookie)) ?? "";
-/**
-* 给 URL 补上 `webid`。
-*
-* 必须在算 a_bogus 之前调用：真实浏览器的顺序是「拼好 query（含 webid）→ a_bogus →
-* secsdk 签名」，后两者都覆盖 query，顺序错了签名就不成立。
-* URL 里已有 `webid`、或缓存里没有值时原样返回。
-* @param url - 还没加签的 URL
-* @param cookie - 本次请求使用的 cookie
-* @returns 补好 `webid` 的 URL
-*/
-const withDouyinWebid = (url, cookie) => {
-	const webid = douyinWebidFor(cookie);
-	if (!webid) return url;
-	let parsed;
-	try {
-		parsed = new URL(url);
-	} catch {
-		return url;
-	}
-	if (parsed.searchParams.has("webid")) return url;
-	parsed.searchParams.set("webid", webid);
-	return parsed.toString();
-};
-/**
-* 平台级 `observe` 钩子：挂在 `PLATFORM_RUNTIME.douyin` 上，每次 send 之后被调一次。
-*
-* **自己吞异常** —— 契约是「只读、不抛、不改判定」。回收 webid 失败只该让下一次
-* 请求少一个参数（不带是安全的），不该把一个本来成功的调用变成 `kind: 'internal'`。
-* @param res - 本次请求的原始响应
-* @param ctx - 当刻的执行上下文（只读 `cookie`）
-*/
-const observeDouyinWebid = (res, ctx) => {
-	try {
-		rememberDouyinWebid(res, ctx.cookie);
-	} catch {}
-};
-//#endregion
-//#region src/platforms/douyin/sign/x_bogus.ts
-/**
-* X-Bogus 生成工具（抖音 / TikTok Web 的老签名）—— TypeScript 移植
-*
-* 移植自 Douyin_TikTok_Download_API `src/dtk/signing/native/xbogus.py`，常量、槽位与
-* **字节顺序**逐条对齐；那份 Python 又是 V4 `crawlers/douyin/web/xbogus.py` 的逐行移植，
-* 而 V4 是站点自己那份混淆 JS 的直译。所以这里对齐的不是「某份实现的做法」，
-* 而是站点校验时的做法。
-*
-* ## 载荷（19 字节）与槽位
-*
-* ```text
-* [64, 1/256, 1, 12, query 摘要[14..15], empty 摘要[14..15], ua 摘要[14..15],
-*  时间戳 4 字节, 536919696 4 字节, 校验位]
-* ```
-*
-* 三条摘要链各自算出 16 字节 MD5，只取第 14、15 字节（`DIGEST_INDICES`）；`1/256`
-* 是站点留在载荷里的浮点常量，最终被截断成 `0`；最后一格是前 18 格的异或。
-*
-* ## 两个曾经的坑，都会产出「看着像模像样」的错签名
-*
-* 1. **字节顺序**：站点把载荷按奇偶位拆开，再交给一个**形参表本身就乱序**的编码函数，
-*    而那个函数正好把两段拼回原序 —— 拆分是死代码。旧移植漏掉还原这一步，把
-*    「偶数位在前、奇数位在后」直接送进 RC4，字节全体错位；再叠加把 `1/256` 写成 `1`，
-*    输出与站点/V4 完全不同。见 {@link XBogus.interleave}。
-* 2. **十六进制解码**：≤ 32 字符一律按站点的判据当摘要解十六进制，旧实现遇到落单的
-*    半字节会悄悄补 0（Python 那版是悄悄丢掉末位），两个不同输入能撞出同一签名。
-*    见 {@link XBogus.md5StrToArray}。
-*
-* ## 时钟
-*
-* V4 把 `time.time()` 烧在函数体里，签名没法在测试里钉死。这里把秒级时间戳做成
-* 注入点（`options.timestamp`），默认值才是 `Date.now()`。
-*
-* @module platforms/douyin/sign/x_bogus
-*/
-/** 输出字母表，与 a_bogus 的 `s2` 相同；两者可以各自演化，所以不共用一份 */
-const CHARACTER = "Dkdpgh4ZKsQB80/Mfvw36XI1R25-WUAlEi7NLboqYTOPuzmFjJnryx9HVGcaStCe=";
-/** 作用在 User-Agent 上的 RC4 密钥（三个控制字节） */
-const UA_KEY = Buffer.from([
-	0,
-	1,
-	12
-]);
-/** 作用在载荷上的 RC4 密钥 */
-const PAYLOAD_KEY = Buffer.from([255]);
-/** 空串的 MD5，算法会把它再哈希一轮，结果是个常量 */
-const EMPTY_MD5 = "d41d8cd98f00b204e9800998ecf8427e";
-/** 载荷开头四个槽位的字面量；`1/256` 那一格会被截断成 `0`，但不能顺手改写成 `0` */
-const PAYLOAD_LEAD = [
-	64,
-	1 / 256,
-	1,
-	12
-];
-/** 每条摘要链贡献的两个字节在 16 字节摘要里的下标 */
-const DIGEST_INDICES = [14, 15];
-/** 信封开头的两个明文字节（`2` 与 `255`），密文接在它们后面 */
-const ENVELOPE_LEAD = [2, 255];
-/** 不传 UA 时使用的默认值，与 V4 一字不差（改它等于改签名） */
-const DEFAULT_USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36 Edg/122.0.0.0";
-/** 小写十六进制字符，V4 与 xbogus.py 都只认这一档 */
-const HEX_DIGITS = "0123456789abcdef";
-var XBogus = class {
-	/** 十六进制字符 → 半字节；未映射的字符取出 `null` 或 `undefined`，两者都算非法 */
-	hexNibbles;
-	/** 内置默认 UA */
-	defaultUa;
-	/** V4 兼容字段：V4 会把结果同步写进 `params` / `xb`，本实现不写 */
-	params;
-	xb;
-	constructor() {
-		this.hexNibbles = new Array(128).fill(null);
-		for (let index = 0; index < 16; index++) this.hexNibbles[HEX_DIGITS.charCodeAt(index)] = index;
-		this.defaultUa = DEFAULT_USER_AGENT;
-	}
-	/**
-	* 十六进制串 → 字节数组；超过 32 字符则按原始文本取码点。
-	*
-	* **长度判据（≤ 32 走十六进制）是站点的**，不是这里加的：站点把任何不超过一份
-	* 摘要长度的字符串都当作摘要来解。真实请求的 path + query 永远长过 32 字符，
-	* 走的是文本分支，所以这条规则碰不到线上行为。
-	*
-	* **旧实现在这里会悄悄吞掉落单的半字节**，两个不同输入因此撞出同一份签名：
-	* 参考实现（Python）用 `range(0, len - 1, 2)`，末位字符直接不参与运算，
-	* `"abcdef"` 与 `"abcdefg"` 同签名；本仓库旧 TS 版把缺失的低半字节当成 0，
-	* `"abc"` 与 `"abc0"` 同签名。两者的共同点是「输入不合法，却拿到一份像模像样的
-	* 签名」—— 这比报错难查得多，所以这里选择**报错**：长度必须是偶数、字符必须是小写
-	* 十六进制，否则抛出，绝不替调用方补位或丢位。
-	*
-	* @param value - 十六进制串 / 原始文本，或现成的字节数组（复制一份返回）
-	* @returns 字节数组
-	*/
-	md5StrToArray(value) {
-		if (Array.isArray(value)) return [...value];
-		if (value.length > 32) {
-			const codePoints = [];
-			for (const char of value) codePoints.push(char.charCodeAt(0));
-			return codePoints;
-		}
-		const bytes = [];
-		for (let index = 0; index < value.length; index += 2) {
-			const pair = value.slice(index, index + 2);
-			const high = this.hexNibbles[value.charCodeAt(index)];
-			const low = index + 1 < value.length ? this.hexNibbles[value.charCodeAt(index + 1)] : null;
-			if (high === null || high === void 0 || low === null || low === void 0) throw new Error(`X-Bogus 签名：${JSON.stringify(value)} 不是偶数长度的小写十六进制串（${JSON.stringify(pair)} 处）`);
-			bytes.push(high << 4 | low);
-		}
-		return bytes;
-	}
-	/** MD5 十六进制摘要；字符串先过 {@link XBogus.md5StrToArray}，数组按原样取字节 */
-	md5(data) {
-		const bytes = typeof data === "string" ? this.md5StrToArray(data) : data;
-		return crypto.createHash("md5").update(Buffer.from(bytes)).digest("hex");
-	}
-	/** query 摘要链：两轮 MD5 */
-	md5Encrypt(urlPath) {
-		return this.md5StrToArray(this.md5(this.md5StrToArray(this.md5(urlPath))));
-	}
-	/**
-	* empty 摘要链：哈希空串，是个常量。
-	*
-	* 它的第 14、15 字节出现在每一份 X-Bogus 里 —— 解码时对不上这两个字节的，
-	* 就不是 X-Bogus。
-	*/
-	emptyDigest() {
-		return this.md5StrToArray(this.md5(this.md5StrToArray(EMPTY_MD5)));
-	}
-	/** UA 摘要链：RC4 → base64 → MD5，再解回字节 */
-	userAgentDigest(userAgent) {
-		const encrypted = this.rc4Encrypt(UA_KEY, Buffer.from(userAgent, "latin1"));
-		return this.md5StrToArray(this.md5(encrypted.toString("base64")));
-	}
-	/** RC4（与 Python 版逐句对应） */
-	rc4Encrypt(key, data) {
-		const box = Array.from({ length: 256 }, (_, index) => index);
-		let j = 0;
-		for (let index = 0; index < 256; index++) {
-			j = (j + box[index] + key[index % key.length]) % 256;
-			[box[index], box[j]] = [box[j], box[index]];
-		}
-		const out = Buffer.alloc(data.length);
-		let i = 0;
-		j = 0;
-		for (let index = 0; index < data.length; index++) {
-			i = (i + 1) % 256;
-			j = (j + box[i]) % 256;
-			[box[i], box[j]] = [box[j], box[i]];
-			out[index] = data[index] ^ box[(box[i] + box[j]) % 256];
-		}
-		return out;
-	}
-	/**
-	* 偶数位在前、奇数位在后 —— 站点对载荷做的拆分。
-	*
-	* 拆分本身是死代码（{@link XBogus.interleave} 会把它原样拼回去），真正的作用只有
-	* 一处：让 `1/256` 那一格被截断成整数。形状照抄站点，为的是别人对着 xbogus.py 读时
-	* 能一句一句对上，也让「漏掉还原」这个坑不至于再犯一次。
-	*/
-	splitEvenOdd(values) {
-		const head = [];
-		const tail = [];
-		for (let index = 0; index < values.length; index++) if (index % 2 === 0) head.push(values[index]);
-		else tail.push(values[index]);
-		return [...head, ...tail];
-	}
-	/**
-	* 把 {@link XBogus.splitEvenOdd} 拆开的两段按下标交错回原序（顺便截断成整数）。
-	*
-	* **这一步不能省**：站点那个编码函数的形参表本身是乱序的 ——
-	* V4 写作 `encoding_conversion(a, b, c, e, d, t, f, r, n, o, i, _, x, u, s, l, v, h, p)`，
-	* 函数体按 `[a, i, b, _, c, x, e, u, d, s, t, l, f, v, r, h, n, p, o]` 拼接，
-	* 传进去的又是拆开的两段，算下来正好还原成原始顺序。旧移植把它当成顺序形参处理，
-	* 于是送进 RC4 的字节全体错位，签名从根上就是错的，还错得看不出来。
-	*/
-	interleave(values) {
-		const head = values.slice(0, 10);
-		const tail = values.slice(10);
-		const merged = [];
-		for (let index = 0; index < head.length; index++) {
-			merged.push(Math.trunc(head[index]));
-			if (index < tail.length) merged.push(Math.trunc(tail[index]));
-		}
-		return merged;
-	}
-	/** 三个载荷字节 → 四个输出字符 */
-	encodeGroup(first, second, third) {
-		const merged = (first & 255) << 16 | (second & 255) << 8 | third & 255;
-		return CHARACTER[(merged & 16515072) >> 18] + CHARACTER[(merged & 258048) >> 12] + CHARACTER[(merged & 4032) >> 6] + CHARACTER[merged & 63];
-	}
-	/**
-	* 生成 X-Bogus 签名。
-	*
-	* @param url - 完整的 URL 地址（签的是它的 pathname + search）
-	* @param ua - 可选的 User-Agent，不提供则使用默认值
-	* @param options - `timestamp` 注入点（秒级），省略时取当前时间
-	* @returns 完整 URL（已带 `X-Bogus=`）、签名值与实际使用的 User-Agent
-	*/
-	getXBogus(url, ua, options = {}) {
-		const parsedUrl = new URL$1.URL(url);
-		const urlPath = parsedUrl.pathname + parsedUrl.search;
-		const userAgent = ua ?? this.defaultUa;
-		const userAgentDigest = this.userAgentDigest(userAgent);
-		const emptyDigest = this.emptyDigest();
-		const queryDigest = this.md5Encrypt(urlPath);
-		const timestamp = options.timestamp ?? Math.floor(Date.now() / 1e3);
-		const payload = [
-			...PAYLOAD_LEAD,
-			queryDigest[DIGEST_INDICES[0]],
-			queryDigest[DIGEST_INDICES[1]],
-			emptyDigest[DIGEST_INDICES[0]],
-			emptyDigest[DIGEST_INDICES[1]],
-			userAgentDigest[DIGEST_INDICES[0]],
-			userAgentDigest[DIGEST_INDICES[1]],
-			timestamp >> 24 & 255,
-			timestamp >> 16 & 255,
-			timestamp >> 8 & 255,
-			timestamp & 255,
-			32,
-			0,
-			190,
-			144
-		];
-		let checksum = Math.trunc(payload[0]);
-		for (let index = 1; index < payload.length; index++) checksum ^= Math.trunc(payload[index]);
-		payload.push(checksum);
-		const merged = this.interleave(this.splitEvenOdd(payload));
-		const encrypted = this.rc4Encrypt(PAYLOAD_KEY, Buffer.from(merged));
-		const garbled = String.fromCharCode(...ENVELOPE_LEAD) + encrypted.toString("latin1");
-		let xbogus = "";
-		for (let index = 0; index + 2 < garbled.length; index += 3) xbogus += this.encodeGroup(garbled.charCodeAt(index), garbled.charCodeAt(index + 1), garbled.charCodeAt(index + 2));
-		return {
-			fullUrl: url.includes("?") ? `${url}&X-Bogus=${xbogus}` : `${url}?X-Bogus=${xbogus}`,
-			xbogus,
-			userAgent
-		};
-	}
-};
-//#endregion
-//#region src/platforms/douyin/sign/index.ts
-const defaultUserAgent$1 = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36";
-var douyinSign$1 = class {
-	/**
-	* 生成一个指定长度的随机字符串
-	* @param length 字符串长度，默认为116
-	* @returns
-	*/
-	static Mstoken(length) {
-		const characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
-		const randomBytes = crypto.randomBytes(length ?? 116);
-		return Array.from(randomBytes, (byte) => characters[byte % 62]).join("");
-	}
-	/**
-	* a_bogus 签名算法
-	* @param url 需要签名的地址
-	* @returns 对此地址签名后的URL查询参数
-	*/
-	static AB(url, userAgent) {
-		return a_bogus_default(url, userAgent ?? defaultUserAgent$1);
-	}
-	/**
-	* X-Bogus 签名算法
-	* @param url 需要签名的地址
-	* @returns 对此地址签名后的URL查询参数
-	*/
-	static XB(url, userAgent) {
-		return new XBogus().getXBogus(url, userAgent ?? defaultUserAgent$1).xbogus;
-	}
-	/**
-	* 生成一个唯一的验证字符串
-	*
-	* 形状与旧实现一致（`verify_<base36 毫秒>_<36 位>`，分隔符在 8/13/18/23、
-	* 版本位在 14、变体位在 19），但时钟来源从 `new Date().getTime()` 换成
-	* `Date.now()` —— 原来那个绕开了 `vi.spyOn(Date, 'now')`，导致这个函数
-	* **无法在测试里被冻结**，只能断言结构。现在可以钉死时钟与随机源了。
-	*/
-	static VerifyFpManager() {
-		return genVerifyFp();
-	}
-};
-//#endregion
-//#region src/platforms/douyin/sign/secsdkWebSign.ts
-/**
-* 抖音主站 `x-secsdk-web-signature` 纯算实现（TypeScript 移植）
-*
-* 移植自 cv-cat/DouYin_Spider `utils/secsdk_web_sign.py`，算法与常量按该实现逐条对齐。
-*
-* ## 算法
-*
-* ```text
-* plain     = {uifid}_{timestamp}_{WEBSIGN_CONST}_{canonical_query}
-* signature = md5(plain) 的 32 位小写十六进制
-* ```
-*
-* `WEBSIGN_CONST` 是 secsdk VMP 常量池里的写死盐，与账号 / 会话无关。
-*
-* ## canonical_query 规范化规则
-*
-* - 保持原始参数顺序，**不排序**；重复参数原样保留。
-* - 每个 value 先解码（`+`→空格、`%XX`→字节）再用 `encodeURIComponent` 重编码。
-* - key **只解码、不重编码**。
-* - 无等号的裸参数补成 `k=`。
-* - `&timestamp={ts}` 追加到 query 末尾后再参与哈希。
-* - query 里没有 `uifid` 时，从 `UIFID` cookie 取值追加到末尾再签。
-*
-* ## 重要
-*
-* 签名算的是**规范化后的 query**，服务端也按收到的 query 校验，所以必须发送
-* {@link signSecsdkWebUrl} 返回的 URL，不能拿原始 URL 直接发。
-*
-* 签名绑 query、**不绑 path**（本项目实测：同一份 query 换 path 仍然 200）。
-*
-* @module platform/douyin/secsdkWebSign
-*/
-/** secsdk VM 常量池里的固定盐（与账号 / 会话无关） */
-const WEBSIGN_CONST = "A96D855A08C0A9707F8BEF0D9A527E4E";
-/** 签名参数名 */
-const SECSDK_SIG_KEY = "x-secsdk-web-signature";
-/** 时间戳参数名 */
-const SECSDK_TS_KEY = "timestamp";
-/** 走 secsdk 签名的 GET 接口路径（来自 SDK 的 webSign 策略配置） */
-const PROTECTED_PATHS_GET = [
-	"/aweme/v1/web/aweme/detail/",
-	"/aweme/v1/web/aweme/post/",
-	"/aweme/v1/web/aweme/favorite/",
-	"/aweme/v1/web/aweme/listcollection/",
-	"/aweme/v1/web/mix/aweme/",
-	"/aweme/v1/web/tab/feed/",
-	"/aweme/v1/web/mix/list/",
-	"/aweme/v1/web/music/aweme/",
-	"/aweme/v1/web/music/list/",
-	"/aweme/v1/web/mix/detail/",
-	"/aweme/v1/web/mix/listcollection/",
-	"/aweme/v1/web/music/detail/",
-	"/aweme/v1/web/collects/list/",
-	"/aweme/v1/web/collects/video/list/"
-];
-/** 走 secsdk 签名的 POST 接口路径 */
-const PROTECTED_PATHS_POST = [
-	"/aweme/v1/web/aweme/detail/",
-	"/aweme/v1/web/aweme/post/",
-	"/aweme/v1/web/aweme/favorite/",
-	"/aweme/v1/web/aweme/listcollection/",
-	"/aweme/v1/web/mix/aweme/",
-	"/aweme/v1/web/tab/feed/"
-];
-const HEX_PAIR = /^[0-9A-Fa-f]{2}$/;
-/**
-* 宽容的百分号解码，等价于 Python `urllib.parse.unquote(..., errors='replace')`：
-* 合法的 `%XX` 解成字节，非法的 `%` 原样保留，最后按 UTF-8 解码（坏字节 → U+FFFD）。
-*
-* 不能直接用 `decodeURIComponent` —— 它遇到 `100%` 这种孤立百分号会抛异常，
-* 而 SDK 的行为是把它当字面量留下（`100%` → 签成 `100%25`）。
-*
-* @param input - 待解码字符串
-* @returns 解码后的字符串
-*/
-const percentDecodeLoose = (input) => {
-	if (!input.includes("%")) return input;
-	const bytes = [];
-	let i = 0;
-	while (i < input.length) {
-		if (input[i] === "%" && HEX_PAIR.test(input.slice(i + 1, i + 3))) {
-			bytes.push(parseInt(input.slice(i + 1, i + 3), 16));
-			i += 3;
-			continue;
-		}
-		for (const byte of Buffer.from(input[i], "utf8")) bytes.push(byte);
-		i += 1;
-	}
-	return Buffer.from(bytes).toString("utf8");
-};
+//#region src/platforms/douyin/sign/signers.ts
 /**
-* 等价于 Python `unquote_plus`：先把 `+` 当空格，再做百分号解码。
+* 抖音签名器表：**只做「注册名 → `SignStep` 清单」的映射，不含算法**。
 *
-* @param input - 待解码字符串
-* @returns 解码后的字符串
-*/
-const unquotePlusLoose = (input) => percentDecodeLoose(input.includes("+") ? input.replace(/\+/g, " ") : input);
-/**
-* 按 SDK 规则规范化 query 字符串：顺序不变，value 解码后用 `encodeURIComponent` 重编码，
-* key 只解码不重编码，无等号的裸参数补成 `k=`。
+* 算法的唯一实现在 `./steps.ts`（含前置条件校验、webid 补参、secsdk 收尾的理由）。
+* 依赖方向是单向的 —— `signers.ts → steps.ts`，永不反向：两份实现并存时会改一边忘一边，
+* 而抖音的签名是**抽样校验**的（签错时大部分请求照样成功，只是被判高风险的概率上升），
+* 这类分叉极难发现。
 *
-* @param query - 原始 query 字符串（不含 `?`）
-* @returns 规范化后的 query 字符串
-*/
-const canonicalQuery = (query) => {
-	const parts = [];
-	for (const pair of query.split("&")) {
-		if (!pair) continue;
-		const eq = pair.indexOf("=");
-		const rawKey = eq === -1 ? pair : pair.slice(0, eq);
-		const rawValue = eq === -1 ? "" : pair.slice(eq + 1);
-		parts.push(`${unquotePlusLoose(rawKey)}=${encodeURIComponent(unquotePlusLoose(rawValue))}`);
-	}
-	return parts.join("&");
-};
-/**
-* 拆成 `[base, query]`，并剥掉已有的 `timestamp` / 签名字段，保证可重复调用。
+* ## 两条路，一份实现
 *
-* @param url - 完整 URL
-* @returns `[base, query]` 二元组
-*/
-const splitUrl = (url) => {
-	const mark = url.indexOf("?");
-	if (mark === -1) return [url, ""];
-	return [url.slice(0, mark), url.slice(mark + 1).split("&").filter((pair) => {
-		if (!pair) return false;
-		const name = pair.split("=", 1)[0];
-		return name !== "timestamp" && name !== "x-secsdk-web-signature";
-	}).join("&")];
-};
-/**
-* 从 cookie 字符串里取 `UIFID`。
+* 端点声明 `sign: douyinBogus(184)` 走清单；`client.douyin.request` 不给 `amagi.sign`
+* 时走字符串 `'a-bogus'`（见 `client/request/profile.ts`）查这张表。两者现在压的是同一份
+* step 清单，所以签出来必然一致。
 *
-* 注意 cookie 里通常还有个 `UIFID_TEMP`，取值时必须锚定 `UIFID=` 前面是行首或分隔符，
-* 否则会取错。
+* ## 为什么注册名对应的是三段清单
 *
-* @param cookie - cookie 字符串
-* @returns `UIFID` 的值，取不到时返回空串
-*/
-const extractUifidFromCookie = (cookie) => {
-	if (!cookie) return "";
-	const hit = /(?:^|;\s*)UIFID=([^;]*)/.exec(cookie);
-	return hit ? hit[1].trim() : "";
-};
-/**
-* 判断该 path 是否需要 secsdk 加签（依据 SDK 的 webSign 策略配置）。
+* 真实浏览器发这些请求的顺序是 **webid → msToken → a_bogus / x_bogus → secsdk**，每一步都改
+* query，颠倒任意一步签名就不成立。顺序不靠这里保证，由 `SignPhase` 的固定次序保证。
 *
-* @param path - URL 的 pathname
-* @param method - HTTP 方法，默认 `GET`
-* @returns 是否需要加签
-*/
-const isSecsdkProtected = (path, method = "GET") => {
-	return (String(method).toUpperCase() === "POST" ? PROTECTED_PATHS_POST : PROTECTED_PATHS_GET).includes(path);
-};
-/**
-* 计算 `x-secsdk-web-signature`。
-*
-* @param url - 完整 API URL（scheme+host+path+query）。已带 `timestamp` /
-*              `x-secsdk-web-signature` 时会自动剥除，可重复调用。
-* @param options - 时间戳与 uifid 兜底值
-* @returns 时间戳、签名与**实际应当发送**的规范化 query
-*/
-const signSecsdkWebQuery = (url, options = {}) => {
-	const ts = Math.trunc(options.ts ?? Date.now() / 1e3);
-	const [, rawQuery] = splitUrl(url);
-	let canon = canonicalQuery(rawQuery);
-	if (!canon.split("&").filter(Boolean).map((pair) => pair.split("=", 1)[0]).includes("uifid") && options.uifid) {
-		const appended = `uifid=${encodeURIComponent(options.uifid)}`;
-		canon = canon ? `${canon}&${appended}` : appended;
-	}
-	const signedQuery = canon ? `${canon}&${SECSDK_TS_KEY}=${ts}` : `${SECSDK_TS_KEY}=${ts}`;
-	let uifidValue = "";
-	for (const pair of signedQuery.split("&")) if (pair.startsWith("uifid=")) {
-		uifidValue = unquotePlusLoose(pair.slice(6));
-		break;
-	}
-	if (!uifidValue && options.uifid) uifidValue = options.uifid;
-	const plain = `${uifidValue}_${ts}_${WEBSIGN_CONST}_${signedQuery}`;
-	return {
-		ts,
-		signature: crypto.createHash("md5").update(plain, "utf8").digest("hex"),
-		signedQuery
-	};
-};
-/**
-* 返回可直接发送的完整 URL（规范化 query + timestamp + 签名）。
+* 其中 webid 与 secsdk 那两段都是「命中才动、否则原样返回」，对不相关的端点是无操作，
+* 所以可以无条件套用 —— 详见 `./steps.ts` 文件头。
 *
-* 服务端按收到的 query 校验签名，所以必须发这个返回值，不能拿原始 URL 直接发。
+* ## 为什么 secsdk 没有自己的注册名
 *
-* @param url - 完整 API URL
-* @param options - 时间戳与 uifid 兜底值
-* @returns 带签名的完整 URL
-*/
-const signSecsdkWebUrl = (url, options = {}) => {
-	const [base] = splitUrl(url);
-	const { signature, signedQuery } = signSecsdkWebQuery(url, options);
-	return `${base}?${signedQuery}&${SECSDK_SIG_KEY}=${signature}`;
-};
-/**
-* 对受保护接口补上 secsdk 签名；path 不在策略表里时原样返回。
-*
-* 这是给取数层用的唯一入口 —— 无条件套在 URL 上即可，不需要调用方判断端点。
+* 它对策略表外的 path 是无操作，无条件复合进这两个名字是安全的；而 `sign` 是单槽位，
+* 另起一个名字只会逼出 `'a-bogus+secsdk'` 这种复合命名。要精细控制的调用方给 step
+* 清单，不是加注册名。
 *
-* @param url - 完整 API URL（应当是**最后一步**，即 a_bogus 等参数都已拼好之后）
-* @param options - cookie / uifid / method / ts
-* @returns 需要加签的返回带签名的 URL，否则原样返回
+* @module platforms/douyin/sign/signers
 */
-const applySecsdkWebSign = (url, options = {}) => {
-	let pathname;
-	try {
-		pathname = new URL(url).pathname;
-	} catch {
-		return url;
-	}
-	if (!isSecsdkProtected(pathname, options.method)) return url;
-	const uifid = options.uifid || extractUifidFromCookie(options.cookie);
-	return signSecsdkWebUrl(url, {
-		ts: options.ts,
-		uifid
-	});
-};
-//#endregion
-//#region src/platforms/douyin/sign/signers.ts
-/**
-* 抖音签名器（SignFn 形式）。
-*
-* 签名器在入口先校验前置条件：
-* - **AB 需绝对 URL**（以 `http(s)://` 开头）。
-* - **XB 需真实接口形态的长路径**（pathname ≥ 3 段且带查询串）。
-*
-* 前置条件不满足时签名器**抛带明确 message 的错误** —— execute 的
-* 单一 catch 把它归因为 `kind: 'internal'` / `INTERNAL_ERROR` 收进失败
-* 信封，调用方不会拿到裸的 `TypeError`。这些条件由 `build` 保证满足
-* （URL 构造器只产出合法绝对地址），签名器里的校验只是防线。
-*
-* ## 为什么这两个签名器前后各多一步
-*
-* 真实浏览器发这些请求的顺序是 **webid → a_bogus / x_bogus → secsdk**，三步都改
-* query，颠倒任意一步签名就不成立。所以两个签名器各自是一条三段的管线，
-* 前后那两段都是「命中才动、否则原样返回」，对不相关的端点是无操作。
-*
-* **前一步 webid**（见 {@link withDouyinWebid}）：抖音会拿 query 里的 `webid` 与 cookie
-* 会话交叉校验，对不上就静默回 0 字节。它是服务端下发的、客户端算不出来，所以只在
-* 按 ttwid 缓存命中时才补 —— 冷启动第一次不带（不带是安全的）。签名器的入参是
-* `(spec, ctx)`，能读 `ctx.cookie`。
-*
-* **后一步 secsdk**：`x-secsdk-web-signature` 是抖音主站的第三种签名，浏览器里由
-* secsdk 的 JS 现算。它与 AB / XB 有三点不同（详见 {@link applySecsdkWebSign} 所在模块）：
-*
-* 1. **它改写整条 URL**，不是返回一个参数值 —— 签名算的是规范化后的 query，
-*    服务端也按收到的 query 校验；
-* 2. **只对 SDK 策略表里的 path 生效**（14 个 GET / 6 个 POST），其余原样返回，
-*    所以可以无条件套用；
-* 3. **必须是最后一步**。
-*
-* 因为第 2 点是无条件安全的，它没有单独注册成第三个签名器名，而是复合进这两个 ——
-* `sign` 是单槽位，另起一个名字只会逼出 `'a-bogus+secsdk'` 这种复合命名。
-* 影响面：`musicInfo`（`music/detail`）、作品详情、用户作品、喜欢列表都在策略表内。
-* `sign: false` 的两条（`emojiList` / `search`）与四条免鉴权端点不经过这里，
-* 它们的 path 也都不在策略表里、也拿不到 webid。
-*/
-/** AB 前置条件：绝对 URL（`http(s)://` 开头） */
-const isAbsoluteUrl = (url) => /^https?:\/\//.test(url);
-/** XB 前置条件：真实接口形态 —— pathname 至少 3 段且带查询串 */
-const isApiLikePath = (url) => {
-	if (!isAbsoluteUrl(url)) return false;
-	const parsed = new URL(url);
-	return parsed.pathname.split("/").filter(Boolean).length >= 3 && parsed.search.length > 0;
-};
 /**
-* 收尾一步：策略表内的 path 补上 `x-secsdk-web-signature`，表外原样返回。
+* 平台签名器表，交给 runtime 的 `signers` 查名。
 *
-* `uifid` 从本次请求的 cookie 里取（query 里已有就用 query 的）。
-* @param spec - 已经加过 a_bogus / x_bogus 的请求描述
-* @param cookie - 本次调用使用的 cookie
-* @returns 需要加签时返回改写过 URL 的请求描述，否则原样返回
-*/
-const withSecsdk = (spec, cookie) => {
-	const url = applySecsdkWebSign(spec.url, {
-		cookie,
-		method: spec.method
-	});
-	return url === spec.url ? spec : {
-		...spec,
-		url
-	};
-};
-/**
-* `a_bogus` 签名器（`sign: 'a-bogus'`）。
-*
-* 前置条件：URL 必须是绝对地址。不满足时抛错，由 execute 归因为
-* `kind: 'internal'`。
-* @param spec - 请求描述（`url` 参与签名）
-* @param ctx - 执行上下文（`userAgent` 用于签名，`cookie` 用于取 secsdk 的 uifid）
-* @returns 带 `a_bogus` 的请求描述；path 在 secsdk 策略表内时再补一层 `x-secsdk-web-signature`
-*/
-const aBogusSigner = (spec, ctx) => {
-	if (!isAbsoluteUrl(spec.url)) throw new Error(`a_bogus 前置条件不满足：URL 必须是绝对地址（收到 "${spec.url}"）`);
-	const url = new URL(withDouyinWebid(spec.url, ctx.cookie));
-	url.searchParams.set("a_bogus", douyinSign$1.AB(url.toString(), ctx.userAgent));
-	return withSecsdk({
-		...spec,
-		url: url.toString()
-	}, ctx.cookie);
-};
-/**
-* `x_bogus` 签名器（`sign: 'x-bogus'`）。
+* 两个名字都取 **184** 那档 msToken 长度：这张表只在 `client.<平台>.request` 那条路上被查到，
+* 而那条路打的是「本库还没收录的接口」—— 猜不出该用 184（作品详情类）还是 116（评论 / 音乐类），
+* 统一取前者。收录进端点的接口各自在声明里写准确的那一档，不经过这里。
 *
-* 前置条件：真实接口形态的长路径（≥3 段且带查询串）。不满足时抛错，由
-* execute 归因为 `kind: 'internal'`。
-* @param spec - 请求描述（`url` 参与签名）
-* @param ctx - 执行上下文（`userAgent` 用于签名）
-* @returns 带 `X-Bogus` 的请求描述；path 在 secsdk 策略表内时再补一层 `x-secsdk-web-signature`
+* 用 `satisfies` 而非显式 `: Record<string, SignFn>` 返回：后者会把键联合抹成宽
+* `string`，而 {@link DouyinSignerName} 要靠 `keyof` 从这张表推导出精确的名字联合。
+* @returns 注册名 → 签名器
 */
-const xBogusSigner = (spec, ctx) => {
-	if (!isApiLikePath(spec.url)) throw new Error(`x_bogus 前置条件不满足：URL 需真实接口形态的长路径（≥3 段且带查询串，收到 "${spec.url}"）`);
-	const url = new URL(withDouyinWebid(spec.url, ctx.cookie));
-	url.searchParams.set("X-Bogus", douyinSign$1.XB(url.toString(), ctx.userAgent));
-	return withSecsdk({
-		...spec,
-		url: url.toString()
-	}, ctx.cookie);
-};
-/** 平台签名器表，交给 runtime 的 `signers` 查名 */
 const createDouyinSigners = () => ({
-	"a-bogus": aBogusSigner,
-	"x-bogus": xBogusSigner
+	"a-bogus": stepsToSigner(douyinBogus(184)),
+	"x-bogus": stepsToSigner(douyinXBogus(184))
 });
 //#endregion
 //#region src/platforms/kuaishou/captcha.ts
@@ -3884,1140 +2859,20 @@ const kuaishouResultVerdict = (raw) => {
 	};
 };
 //#endregion
-//#region src/platforms/kuaishou/sign/hudr.ts
-const KUAISHOU_HUDR_PREFIX = "HUDR_";
-const KUAISHOU_HUDR_MASK_BYTE = 35;
-const KUAISHOU_HUDR_BASE64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-const KUAISHOU_HUDR_CHACHA_KEY = [
-	4183807412,
-	394484062,
-	1106561997,
-	2378328696,
-	630790222,
-	2546784104,
-	2891127470,
-	1922531795
-];
-const KUAISHOU_HUDR_CHACHA_NONCE = [
-	2215853858,
-	1643070585,
-	1849059804
-];
-/** 将字符串转换为 Unicode code point 数组。 */
-const toCodePointArray = (value) => {
-	return Array.from(value).map((char) => char.codePointAt(0) ?? 0);
-};
-/** 以小端序输出固定长度字节数组。 */
-const toLittleEndianBytes = (value, size = 4) => {
-	if (size >= 4 && value >= Math.pow(2, 32)) return [
-		255,
-		255,
-		255,
-		255
-	];
-	const result = [];
-	for (let index = 0; index <= size - 1; index++) result[index] = value >>> 8 * index & 255;
-	return result;
-};
-/** 对字节切片执行标准 Base64 编码。 */
-const encodeBase64Slice = (bytes, start, end) => {
-	const result = [];
-	for (let index = start; index < end; index += 3) {
-		const value = (bytes[index] << 16 & 16711680) + (bytes[index + 1] << 8 & 65280) + (bytes[index + 2] & 255);
-		result.push(KUAISHOU_HUDR_BASE64_ALPHABET[value >> 18 & 63], KUAISHOU_HUDR_BASE64_ALPHABET[value >> 12 & 63], KUAISHOU_HUDR_BASE64_ALPHABET[value >> 6 & 63], KUAISHOU_HUDR_BASE64_ALPHABET[value & 63]);
-	}
-	return result.join("");
-};
-/** 快手 `HUDR_` 使用的 Base64URL 变体编码。 */
-const encodeBase64Url = (bytes) => {
-	const result = [];
-	const remainder = bytes.length % 3;
-	const tripletLength = bytes.length - remainder;
-	for (let index = 0; index < tripletLength; index += 16383) {
-		const end = tripletLength < index + 16383 ? tripletLength : index + 16383;
-		result.push(encodeBase64Slice(bytes, index, end));
-	}
-	if (remainder === 1) {
-		const value = bytes[bytes.length - 1];
-		result.push(KUAISHOU_HUDR_BASE64_ALPHABET[value >> 2], KUAISHOU_HUDR_BASE64_ALPHABET[value << 4 & 63], "==");
-	} else if (remainder === 2) {
-		const value = (bytes[bytes.length - 2] << 8) + bytes[bytes.length - 1];
-		result.push(KUAISHOU_HUDR_BASE64_ALPHABET[value >> 10], KUAISHOU_HUDR_BASE64_ALPHABET[value >> 4 & 63], KUAISHOU_HUDR_BASE64_ALPHABET[value << 2 & 63], "=");
-	}
-	return result.join("").replace(/[+/=]/g, (char) => {
-		if (char === "+") return "-";
-		if (char === "/") return "_";
-		return ".";
-	});
-};
-/**
-* 快手 `HUDR_` 所用的 ChaCha20 变体实现。
-*
-* 该实现并非通用密码库封装，而是为对齐页面 `$encode`
-* 数据流而最小化保留的局部算法。
-*/
-var KuaishouChaChaCipher = class {
-	key;
-	nonce;
-	wordIndex = 0;
-	state = new Array(16).fill(0);
-	constructor(key, nonce) {
-		this.key = key;
-		this.nonce = nonce;
-	}
-	rotateLeft(value, shift) {
-		return (value << shift | value >>> 32 - shift) >>> 0;
-	}
-	quarterRound(target, a, b, c, d) {
-		target[a] = target[a] + target[b] >>> 0;
-		target[d] ^= target[a];
-		target[d] = this.rotateLeft(target[d], 16);
-		target[c] = target[c] + target[d] >>> 0;
-		target[b] ^= target[c];
-		target[b] = this.rotateLeft(target[b], 12);
-		target[a] = target[a] + target[b] >>> 0;
-		target[d] ^= target[a];
-		target[d] = this.rotateLeft(target[d], 8);
-		target[c] = target[c] + target[d] >>> 0;
-		target[b] ^= target[c];
-		target[b] = this.rotateLeft(target[b], 7);
-	}
-	refillBlock() {
-		const working = this.state.slice();
-		for (let round = 0; round < 20; round += 2) {
-			this.quarterRound(working, 0, 4, 8, 12);
-			this.quarterRound(working, 1, 5, 9, 13);
-			this.quarterRound(working, 2, 6, 10, 14);
-			this.quarterRound(working, 3, 7, 11, 15);
-			this.quarterRound(working, 0, 5, 10, 15);
-			this.quarterRound(working, 1, 6, 11, 12);
-			this.quarterRound(working, 2, 7, 8, 13);
-			this.quarterRound(working, 3, 4, 9, 14);
-		}
-		const mixedState = new Array(16).fill(0);
-		for (let index = 0; index < 16; index++) mixedState[index] = working[index] + this.state[index] >>> 0;
-		return mixedState;
-	}
-	encrypt(input) {
-		this.wordIndex = 0;
-		this.state[0] = 394484062;
-		this.state[1] = 2378328696;
-		this.state[2] = 630790222;
-		this.state[3] = 1922531795;
-		for (let index = 0; index < 8; index++) this.state[index + 4] = this.key[index] >>> 0;
-		this.state[12] = 1;
-		this.state[13] = this.nonce[0] >>> 0;
-		this.state[14] = this.nonce[1] >>> 0;
-		this.state[15] = this.nonce[2] >>> 0;
-		let mixedState = this.refillBlock();
-		const output = new Uint8Array(input.length);
-		for (let index = 0; index < input.length; index++) {
-			if (this.wordIndex === 64) {
-				this.state[12] = this.state[12] + 1 >>> 0;
-				mixedState = this.refillBlock();
-				this.wordIndex = 0;
-			}
-			const keystreamByte = mixedState[this.wordIndex >> 2] >>> ((this.wordIndex & 3) << 3) & 255;
-			this.wordIndex += 1;
-			output[index] = input[index] ^ keystreamByte;
-		}
-		return output;
-	}
-};
-/**
-* 构造 `HUDR_` 头部中的 `infoCache` 字段。
-*
-* @param scriptCount - 页面脚本数量
-* @returns `HUDR_` 载荷中的脚本信息缓存字节
-*/
-const buildKuaishouHudrInfoCache = (scriptCount = 0) => {
-	return [68, 0].concat(toLittleEndianBytes(scriptCount, 4));
-};
-/**
-* 构造快手 `HUDR_` 原始载荷。
-*
-* @param context - 生成 `HUDR_` 所需的上下文参数
-* @returns 尚未异或和加密的原始字节载荷
-*/
-const buildKuaishouHudrPayload = (context) => {
-	const stackTail = context.secs?.s ?? "";
-	const secsCount = context.secs?.c ?? 0;
-	const count = context.count || 0;
-	return [
-		45,
-		61,
-		0,
-		2
-	].concat(buildKuaishouHudrInfoCache(context.scriptCount)).concat([112, 0], toLittleEndianBytes(count, 4)).concat([114, 1], toLittleEndianBytes(stackTail.length, 2), toCodePointArray(stackTail)).concat([115, 0], toLittleEndianBytes(secsCount, 4));
-};
-/**
-* 对 `HUDR_` 原始载荷执行页面同款掩码异或。
-*
-* @param payload - 原始 `HUDR_` 字节载荷
-* @returns 掩码处理后的字节数组
-*/
-const maskKuaishouHudrPayload = (payload) => {
-	const masked = new Uint8Array(payload.length);
-	for (let index = 0; index < payload.length; index++) masked[index] = KUAISHOU_HUDR_MASK_BYTE ^ payload[index];
-	return masked;
-};
-/**
-* 推导快手签名中的 `HUDR_` 段。
-*
-* @param context - 生成 `HUDR_` 所需的上下文参数
-* @returns `HUDR_` 的完整结果及若干中间态，便于对拍与调试
-*/
-const deriveKuaishouHudrBody = (context) => {
-	const payload = buildKuaishouHudrPayload(context);
-	const maskedPayload = maskKuaishouHudrPayload(payload);
-	const encrypted = new KuaishouChaChaCipher(KUAISHOU_HUDR_CHACHA_KEY, KUAISHOU_HUDR_CHACHA_NONCE).encrypt(maskedPayload);
-	const body = encodeBase64Url(encrypted);
-	return {
-		body,
-		full: `${KUAISHOU_HUDR_PREFIX}${body}`,
-		infoCache: buildKuaishouHudrInfoCache(context.scriptCount),
-		maskedPayload,
-		nextCount: context.count + 1
-	};
-};
-//#endregion
-//#region src/platforms/kuaishou/sign/primitives.ts
-const KUAISHOU_BLAKE2S_IV = [
-	2837534710,
-	2845986804,
-	2436420605,
-	706843635,
-	719254516,
-	2557931286,
-	2596197199,
-	2432949778
-];
-const KUAISHOU_BLAKE2S_SIGMA = [
-	[
-		0,
-		1,
-		2,
-		3,
-		4,
-		5,
-		6,
-		7,
-		8,
-		9,
-		10,
-		11,
-		12,
-		13,
-		14,
-		15
-	],
-	[
-		14,
-		10,
-		4,
-		8,
-		9,
-		15,
-		13,
-		6,
-		1,
-		12,
-		0,
-		2,
-		11,
-		7,
-		5,
-		3
-	],
-	[
-		11,
-		8,
-		12,
-		0,
-		5,
-		2,
-		15,
-		13,
-		10,
-		14,
-		3,
-		6,
-		7,
-		1,
-		9,
-		4
-	],
-	[
-		7,
-		9,
-		3,
-		1,
-		13,
-		12,
-		11,
-		14,
-		2,
-		6,
-		5,
-		10,
-		4,
-		0,
-		15,
-		8
-	],
-	[
-		9,
-		0,
-		5,
-		7,
-		2,
-		4,
-		10,
-		15,
-		14,
-		1,
-		11,
-		12,
-		6,
-		8,
-		3,
-		13
-	],
-	[
-		2,
-		12,
-		6,
-		10,
-		0,
-		11,
-		8,
-		3,
-		4,
-		13,
-		7,
-		5,
-		15,
-		14,
-		1,
-		9
-	],
-	[
-		12,
-		5,
-		1,
-		15,
-		14,
-		13,
-		4,
-		10,
-		0,
-		7,
-		6,
-		3,
-		9,
-		2,
-		8,
-		11
-	],
-	[
-		13,
-		11,
-		7,
-		14,
-		12,
-		1,
-		3,
-		9,
-		5,
-		0,
-		15,
-		4,
-		8,
-		6,
-		2,
-		10
-	],
-	[
-		6,
-		15,
-		14,
-		9,
-		11,
-		3,
-		0,
-		8,
-		12,
-		2,
-		13,
-		7,
-		1,
-		4,
-		10,
-		5
-	],
-	[
-		10,
-		2,
-		8,
-		4,
-		7,
-		6,
-		1,
-		5,
-		15,
-		11,
-		9,
-		14,
-		3,
-		12,
-		13,
-		0
-	]
-];
-const KUAISHOU_CTS_STATE_VECTOR = new Int8Array([
-	98,
-	0,
-	0,
-	128,
-	49,
-	117,
-	185,
-	253,
-	224,
-	172,
-	104,
-	36,
-	223,
-	155,
-	87,
-	19,
-	32,
-	0,
-	0,
-	64,
-	2,
-	0,
-	0,
-	16,
-	255,
-	255,
-	255,
-	127,
-	255,
-	255,
-	255,
-	63,
-	0,
-	0,
-	0,
-	240,
-	0,
-	0,
-	0,
-	192,
-	0,
-	0,
-	0,
-	128,
-	255,
-	255,
-	255,
-	15
-]);
-const rotateRight = (value, shift) => {
-	return (value >>> shift | value << 32 - shift) >>> 0;
-};
-const toUtf8Int8Array = (value) => {
-	return new Int8Array(unescape(encodeURIComponent(value)).split("").map((char) => char.charCodeAt(0) || 0));
-};
-const toHex32 = (value) => {
-	return (value >>> 0).toString(16).padStart(8, "0");
-};
-const blake2sQuarterRound = (state, a, b, c, d, x, y) => {
-	state[a] = state[a] + state[b] + x >>> 0;
-	state[d] = rotateRight(state[d] ^ state[a], 16);
-	state[c] = state[c] + state[d] >>> 0;
-	state[b] = rotateRight(state[b] ^ state[c], 12);
-	state[a] = state[a] + state[b] + y >>> 0;
-	state[d] = rotateRight(state[d] ^ state[a], 8);
-	state[c] = state[c] + state[d] >>> 0;
-	state[b] = rotateRight(state[b] ^ state[c], 7);
-};
-const blake2sCompress = (hash, words, offset, counter, length, isLastBlock) => {
-	const work = new Array(16).fill(0);
-	const block = new Array(16).fill(0);
-	for (let index = 0; index < 8; index++) {
-		work[index] = hash[index] >>> 0;
-		work[index + 8] = KUAISHOU_BLAKE2S_IV[index] >>> 0;
-	}
-	work[12] ^= counter >>> 0;
-	if (isLastBlock) work[14] ^= 4294967295;
-	for (let index = 0; index < length; index++) block[index % 16] ^= words[offset + index] >>> 0;
-	for (const sigma of KUAISHOU_BLAKE2S_SIGMA) {
-		blake2sQuarterRound(work, 0, 4, 8, 12, block[sigma[0]], block[sigma[1]]);
-		blake2sQuarterRound(work, 1, 5, 9, 13, block[sigma[2]], block[sigma[3]]);
-		blake2sQuarterRound(work, 2, 6, 10, 14, block[sigma[4]], block[sigma[5]]);
-		blake2sQuarterRound(work, 3, 7, 11, 15, block[sigma[6]], block[sigma[7]]);
-		blake2sQuarterRound(work, 0, 5, 10, 15, block[sigma[8]], block[sigma[9]]);
-		blake2sQuarterRound(work, 1, 6, 11, 12, block[sigma[10]], block[sigma[11]]);
-		blake2sQuarterRound(work, 2, 7, 8, 13, block[sigma[12]], block[sigma[13]]);
-		blake2sQuarterRound(work, 3, 4, 9, 14, block[sigma[14]], block[sigma[15]]);
-	}
-	for (let index = 0; index < 8; index++) hash[index] = (hash[index] ^ work[index] ^ work[index + 8]) >>> 0;
-	return hash;
-};
-const deriveB2hasWords = (value) => {
-	const utf8 = toUtf8Int8Array(value);
-	const padding = utf8.length % 4 === 0 ? 0 : 4 - utf8.length % 4;
-	const padded = new Int8Array(utf8.length + padding);
-	for (let index = 0; index < utf8.length; index++) padded[index] = utf8[index];
-	const words = new Array(padded.length / 4);
-	for (let index = 0; index < padded.length; index += 4) words[index / 4] = new Int32Array(padded.slice(index, index + 4).buffer)[0];
-	return words;
-};
-const deriveB2hasHash = (words) => {
-	const hash = KUAISHOU_BLAKE2S_IV.slice();
-	hash[0] ^= 16842784;
-	let offset = 0;
-	let length = words.length;
-	let counter = 0;
-	while (length > 64) {
-		length -= 64;
-		counter += 64;
-		blake2sCompress(hash, words, offset, counter, 64, false);
-		offset += 64;
-	}
-	return blake2sCompress(hash, words, offset, counter + length, length, true);
-};
-/**
-* 计算快手页面中的 `b2has` 字符串。
-*
-* 这是后续 `b2sa` / `cts` 链路的起点。
-*
-* @param value - 原始输入字符串
-* @returns `b2has` 结果字符串
-*/
-const deriveKuaishouB2has = (value) => {
-	return deriveB2hasHash(deriveB2hasWords(value)).map(toHex32).join("");
-};
-/**
-* 将输入字符串转换为快手 `b2sa` 所需的字节数组。
-*
-* @param value - 原始输入字符串
-* @returns `b2has` 结果转 UTF-8 后的 Int8Array
-*/
-const deriveKuaishouB2sa = (value) => {
-	return toUtf8Int8Array(deriveKuaishouB2has(value));
-};
-const createKuaishouCtsState = () => {
-	return {
-		s: new Int32Array(KUAISHOU_CTS_STATE_VECTOR.slice(12, 16).buffer)[0],
-		u: new Int32Array(KUAISHOU_CTS_STATE_VECTOR.slice(8, 12).buffer)[0],
-		c: new Int32Array(KUAISHOU_CTS_STATE_VECTOR.slice(4, 8).buffer)[0],
-		l: new Int32Array(KUAISHOU_CTS_STATE_VECTOR.slice(0, 4).buffer)[0],
-		p: new Int32Array(KUAISHOU_CTS_STATE_VECTOR.slice(16, 20).buffer)[0],
-		f: new Int32Array(KUAISHOU_CTS_STATE_VECTOR.slice(20, 24).buffer)[0],
-		d: new Int32Array(KUAISHOU_CTS_STATE_VECTOR.slice(24, 28).buffer)[0],
-		y: new Int32Array(KUAISHOU_CTS_STATE_VECTOR.slice(28, 32).buffer)[0],
-		h: new Int32Array(KUAISHOU_CTS_STATE_VECTOR.slice(44, 48).buffer)[0],
-		E: new Int32Array(KUAISHOU_CTS_STATE_VECTOR.slice(40, 44).buffer)[0],
-		m: new Int32Array(KUAISHOU_CTS_STATE_VECTOR.slice(36, 40).buffer)[0],
-		b: new Int32Array(KUAISHOU_CTS_STATE_VECTOR.slice(32, 36).buffer)[0]
-	};
-};
-const seedKuaishouCtsState = (state, seed) => {
-	const chars = new Int8Array(seed.split("").map((char) => char.codePointAt(0) ?? 0)).slice(0, seed.length);
-	for (let index = 0; index < 4; index++) {
-		state.s = (state.s <<= 8) | chars[index + 4];
-		state.u = (state.u <<= 8) | chars[index + 4];
-		state.c = (state.c <<= 8) | chars[index + 4];
-	}
-	if (state.s === 0) state.s = 324508639;
-	if (state.u === 0) state.u = 610839776;
-	if (state.c === 0) state.c = 4256789809;
-};
-const deriveKuaishouCtsByte = (state, value) => {
-	let result = 0;
-	let rightBit = 1 & state.u;
-	let leftBit = 1 & state.c;
-	for (let index = 0; index < 8; index++) {
-		if (1 & state.s) {
-			state.s = state.s ^ state.l >> 1 & 4294967295 | state.E;
-			rightBit = 1 & state.u ? (state.u = state.u ^ state.p >> 1 & 4294967295 | state.m, 1) : (state.u = state.u >> 1 & 4294967295 & state.y, 0);
-		} else {
-			state.s = state.s >> 1 & 4294967295 & state.d;
-			leftBit = 1 & state.c ? (state.c = state.c ^ state.f >> 1 & 4294967295 | state.b, 1) : (state.c = state.c >> 1 & 4294967295 & state.h, 0);
-		}
-		const mixed = result << 1 & 4294967295 | rightBit ^ leftBit;
-		result = mixed > 127 ? mixed - 256 : mixed < -128 ? mixed + 256 : mixed;
-	}
-	return value ^ result + 3;
-};
-/**
-* 执行快手页面中的 `cts` 字节流变换。
-*
-* 该变换会作用在 `b2sa` 的输出上，随后被 `$HE_` 使用。
-*
-* @param input - 输入字节数组
-* @returns 变换后的字节数组
-*/
-const deriveKuaishouCts = (input) => {
-	const state = createKuaishouCtsState();
-	seedKuaishouCtsState(state, "Vuz4fCHxn1CO");
-	const result = new Int8Array(input.length);
-	for (let index = 0; index < input.length; index++) result[index] = deriveKuaishouCtsByte(state, input[index]);
-	return result;
-};
-/**
-* 将字节数组编码为小写 hex 字符串。
-*
-* @param bytes - 任意可按字节访问的数组
-* @returns 小写 hex 字符串
-*/
-const bytesToLowerHex = (bytes) => {
-	let result = "";
-	for (const byte of Array.from(bytes)) {
-		const value = byte & 255;
-		result += value === 0 ? "00" : `${value < 16 ? "0" : ""}${value.toString(16)}`;
-	}
-	return result;
-};
-/**
-* 将 hex 字符串还原为带符号字节数组。
-*
-* @param value - 偶数字节长度的 hex 字符串
-* @returns 带符号 byte 数组
-*/
-const hexToSignedBytes = (value) => {
-	const result = [];
-	for (let index = 0; index < value.length; index += 2) {
-		const parsed = parseInt(value.slice(index, index + 2), 16);
-		const range = Math.pow(2, value.slice(index, index + 2).length / 2 * 8);
-		result.push(parsed > range / 2 - 1 ? parsed - range : parsed);
-	}
-	return result;
-};
-/**
-* 对两个字节数组执行循环异或。
-*
-* @param left - 被处理的字节数组
-* @param right - 异或掩码字节数组
-* @returns 异或后的 Int8Array
-*/
-const xorByteArrays = (left, right) => {
-	let index = 0;
-	const result = new Int8Array(left.length);
-	while (index < left.length) for (let rightIndex = 0; rightIndex < right.length && index < left.length; rightIndex++) {
-		result[index] = left[index] ^ 255 & right[rightIndex];
-		index += 1;
-	}
-	return result;
-};
-/**
-* 将数值编码为固定长度的小端 hex。
-*
-* @param value - 原始数值
-* @param size - 输出字节长度
-* @returns 小端序 hex 字符串
-*/
-const toLittleEndianHex = (value, size) => {
-	const normalized = BigInt.asUintN(size * 8, typeof value === "bigint" ? value : BigInt(Math.trunc(value)));
-	let result = "";
-	for (let index = 0; index < size; index++) {
-		const byte = Number(normalized >> BigInt(8 * index) & 255n);
-		result += byte.toString(16).padStart(2, "0");
-	}
-	return result;
-};
-/**
-* 计算快手 `$HE_` 所使用的 8-bit LRC 校验值。
-*
-* @param sourceHex - 原始 hex 字符串
-* @returns 单字节 LRC 的 hex 表示
-*/
-const computeKuaishouLrcHex = (sourceHex) => {
-	return (-hexToSignedBytes(sourceHex).reduce((total, value) => total + (value & 255), 0) & 255).toString(16).padStart(2, "0");
-};
-/**
-* 对 `$HE_` 的 preHex + checksum 执行最终变换。
-*
-* 页面实现会以最后一个字节为 key，对前面的字节逐个异或，
-* 最后再整体转回小写 hex。
-*
-* @param prefixHex - 不含最终 LRC 的前缀 hex
-* @param checksumHex - 最终 LRC hex
-* @returns `$HE_` 最终输出的 hex 字符串
-*/
-const transformKuaishouHeHex = (prefixHex, checksumHex) => {
-	const input = hexToSignedBytes(`${prefixHex}${checksumHex}`);
-	const output = new Int8Array(input.length);
-	const xorKey = input[input.length - 1];
-	for (let index = 0; index < input.length - 1; index++) output[index] = input[index] ^ xorKey;
-	output[input.length - 1] = xorKey;
-	return bytesToLowerHex(output);
-};
-//#endregion
-//#region src/platforms/kuaishou/sign/he.ts
-const KUAISHOU_HE_HEADER_HEX = "4B54";
-const KUAISHOU_HE_VERSION_HEX = "cda9";
-const KUAISHOU_HE_STARTUP_MARKER_HEX = "ab";
-const KUAISHOU_HE_FIXED_BODY_HEX = "0100000001";
-const KUAISHOU_HE_INPUT_XOR_MASK = [
-	45,
-	211,
-	69,
-	192
-];
-const KUAISHOU_HE_COUNTER_XOR_MASK = 3131873467;
-const KUAISHOU_HE_TIME_XOR_MASK = 3360347992n;
-const KUAISHOU_HE_TAIL_HEX = "9b563eda7b563e";
-const KUAISHOU_HE_RANDOM_MAX = 0xffffffffffff;
-/**
-* 计算 `$HE_` 中的 hash field。
-*
-* 它由 `signInput + HUDRBody` 经 `b2sa -> cts -> 截断 -> 异或掩码`
-* 这条链路导出，是 `$HE_` 中与接口输入最直接相关的一段。
-*
-* @param signInput - 快手 `__NS_hxfalcon` 的 sign input
-* @param hudrBody - `HUDR_` 去前缀后的主体
-* @returns `$HE_` 载荷中的 4 字节 hash field hex
-*/
-const deriveKuaishouHeHashFieldHex = (signInput, hudrBody) => {
-	const hashInput = `${signInput}HUDR_${hudrBody}`;
-	const digestHex = bytesToLowerHex(deriveKuaishouCts(deriveKuaishouB2sa(hashInput))).slice(0, 8);
-	return bytesToLowerHex(xorByteArrays(hexToSignedBytes(digestHex), KUAISHOU_HE_INPUT_XOR_MASK));
-};
-/**
-* 推导快手签名中的 `$HE_` 段。
-*
-* @param context - 生成 `$HE_` 所需的上下文参数
-* @returns `$HE_` 的最终 hex、中间 hash field 和 preHex
-*/
-const deriveKuaishouHeHex = (context) => {
-	const random48 = Math.floor(context.randomValue * KUAISHOU_HE_RANDOM_MAX);
-	const hashFieldHex = deriveKuaishouHeHashFieldHex(context.signInput, context.hudrBody);
-	const timeXor = BigInt(context.timestamp) ^ KUAISHOU_HE_TIME_XOR_MASK;
-	const preHex = [
-		KUAISHOU_HE_HEADER_HEX,
-		KUAISHOU_HE_VERSION_HEX,
-		KUAISHOU_HE_STARTUP_MARKER_HEX,
-		toLittleEndianHex(context.startupRandom, 6),
-		toLittleEndianHex(random48, 6),
-		KUAISHOU_HE_FIXED_BODY_HEX,
-		toLittleEndianHex(context.count ^ KUAISHOU_HE_COUNTER_XOR_MASK, 4),
-		hashFieldHex,
-		toLittleEndianHex(timeXor, 6),
-		KUAISHOU_HE_TAIL_HEX,
-		computeKuaishouLrcHex(KUAISHOU_HE_TAIL_HEX)
-	].join("");
-	return {
-		finalHex: transformKuaishouHeHex(preHex, computeKuaishouLrcHex(preHex)),
-		hashFieldHex,
-		preHex
-	};
-};
-/**
-* 一次性推导快手完整纯算法签名。
-*
-* 该方法会先生成 `HUDR_`，再拼出 `$HE_`，最终返回完整
-* `HUDR_...$HE_...` 形式的 `__NS_hxfalcon`。
-*
-* @param context - 快手纯算法签名上下文
-* @returns 完整签名结果及关键中间态
-*/
-const deriveKuaishouPureSignature = (context) => {
-	const hudr = deriveKuaishouHudrBody(context);
-	const he = deriveKuaishouHeHex({
-		count: context.count,
-		hudrBody: hudr.body,
-		randomValue: context.randomValue,
-		signInput: context.signInput,
-		startupRandom: context.startupRandom,
-		timestamp: context.timestamp
-	});
-	return {
-		...hudr,
-		he,
-		signResult: `${hudr.full}$HE_${he.finalHex}`
-	};
-};
-//#endregion
-//#region src/platforms/kuaishou/sign/helpers.ts
-const SIGN_INPUT_SKIP_KEYWORD$1 = "__NS";
-const KUAISHOU_ANONYMOUS_KWW_KEY$1 = "K8wm5PvY9nX7qJc2";
-const KUAISHOU_ANONYMOUS_KWW_SUFFIX$1 = "###ssrd";
-const KUAISHOU_ANONYMOUS_KWW_ALPHABET$1 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
-/** 创建一份独立的匿名 kww 缓存 */
-const createKuaishouAnonymousKwwCache = () => {
-	const cache = {
-		value: "",
-		get: () => {
-			if (!cache.value) cache.value = `${encryptKuaishouAnonymousKwwSeed$1(generateKuaishouAnonymousKwwSeed$1())}${KUAISHOU_ANONYMOUS_KWW_SUFFIX$1}`;
-			return cache.value;
-		}
-	};
-	return cache;
-};
-/** 模块级单例缓存；生产代码用 createKuaishouAnonymousKwwCache */
-let kuaishouAnonymousKwwCache$1 = "";
-const compareLexicographically$1 = (left, right) => {
-	if (left === right) return 0;
-	return left < right ? -1 : 1;
-};
-const toComparableEntry$1 = (key, value) => {
-	if (typeof value === "object" && value !== null && !Array.isArray(value)) return `${key}=[object Object]`;
-	return `${key}=${String(value)}`;
-};
-const normalizePathname$1 = (urlOrPath) => {
-	try {
-		return new URL(urlOrPath).pathname;
-	} catch {
-		return urlOrPath.split("?")[0] ?? urlOrPath;
-	}
-};
-const sortSearchParams$1 = (searchParams) => {
-	return [...searchParams.entries()].sort(([leftKey], [rightKey]) => compareLexicographically$1(leftKey, rightKey)).reduce((result, [key, value]) => {
-		result[key] = value;
-		return result;
-	}, {});
-};
-/**
-* 解析快手签名所使用的规范路径。
-*
-* 快手部分 `live_api` 接口的公开 URL 与算法内部参与签名的路径并不一致，
-* 因此这里优先使用调用方显式传入的 `signPath`，否则回退到 URL 自身的 pathname。
-*
-* @param urlOrPath - 原始 URL 或路径
-* @param signPath - 调用方声明的规范签名路径
-* @returns 参与签名的规范 pathname
-*/
-const resolveKuaishouHxfalconSignPath$1 = (urlOrPath, signPath) => {
-	const pathname = normalizePathname$1(signPath ?? urlOrPath);
-	if (!pathname.startsWith("/")) throw new Error(`Invalid Kuaishou signing path: ${pathname}`);
-	return pathname;
-};
-/**
-* 从请求 URL 构造快手签名载荷。
-*
-* `requestBody` **必须**由调用方透下来：`buildKuaishouHxfalconSignInput` 会把
-* `JSON.stringify(requestBody)` 拼在 sign input 尾部。漏传时校验松的接口
-* （`simple/info` / `comment/list`）仍会放行，而 `photo/info` 一类严格校验的接口
-* 会一律 `result=50 签名验证失败`。
-* 参见 @OduckO 的 kuaishou-parser（GPL-3.0-only）`sign/helpers.ts:78-81`
-* 与其 `TODO.md:193-195`。
-*
-* @param url - 实际请求 URL
-* @param signPath - 可选的规范签名路径
-* @param requestBody - 参与签名的请求体（POST 端点必传，GET 端点保持缺省）
-* @returns 供纯算法签名链路使用的结构化载荷
-*/
-const buildKuaishouHxfalconPayload$1 = (url, signPath, requestBody = {}) => {
-	const parsedUrl = new URL(url);
-	const realPath = resolveKuaishouHxfalconSignPath$1(parsedUrl.pathname, signPath);
-	const query = sortSearchParams$1(parsedUrl.searchParams);
-	if (!query.caver) throw new Error(`Missing caver query parameter for Kuaishou signing: ${url}`);
-	return {
-		url: realPath,
-		query,
-		form: {},
-		requestBody
-	};
-};
-/**
-* 构造快手 `__NS_hxfalcon` 的 sign input。
-*
-* 该字符串就是后续 `HUDR_` / `$HE_` 两段算法共同依赖的输入材料。
-*
-* @param payload - 已标准化的签名载荷
-* @returns 按快手页面规则拼接后的 sign input
-*/
-const buildKuaishouHxfalconSignInput$1 = (payload) => {
-	const combinedParams = {
-		...payload.query,
-		...payload.form
-	};
-	const serializedParams = Object.keys(combinedParams).filter((key) => !key.includes(SIGN_INPUT_SKIP_KEYWORD$1)).map((key) => toComparableEntry$1(key, combinedParams[key])).sort(compareLexicographically$1).join("");
-	const requestBody = Object.keys(payload.requestBody).length > 0 ? JSON.stringify(payload.requestBody) : "";
-	return `${normalizePathname$1(payload.url)}${serializedParams}${requestBody}`;
-};
-/**
-* 从 Cookie 字符串中提取指定键值。
-*
-* @param cookie - 原始 Cookie 字符串
-* @param key - 目标键名
-* @returns 命中的 Cookie 值；未命中时返回空字符串
-*/
-const extractCookieValue$1 = (cookie, key) => {
-	if (!cookie?.trim()) return "";
-	const pattern = new RegExp(`(?:^|;\\s*)${key}=([^;]*)`);
-	return cookie.match(pattern)?.[1] ?? "";
-};
-const generateKuaishouAnonymousKwwSeed$1 = () => {
-	let randomPart = "";
-	for (let index = 0; index < 8; index++) {
-		const randomIndex = Math.floor(Math.random() * 62);
-		randomPart += KUAISHOU_ANONYMOUS_KWW_ALPHABET$1[randomIndex];
-	}
-	return `${Date.now()}|${randomPart}`;
-};
-const encryptKuaishouAnonymousKwwSeed$1 = (seed) => {
-	const key = Buffer.from(KUAISHOU_ANONYMOUS_KWW_KEY$1, "utf8");
-	const cipher = crypto.createCipheriv("aes-128-cbc", key, key);
-	return Buffer.concat([cipher.update(seed, "utf8"), cipher.final()]).toString("base64");
-};
-/**
-* 生成匿名访问快手 `live_api` 时所需的 `kww`。
-*
-* 页面未持有 `kwfv1` 时，会退回到一段本地 AES 生成值。
-* 传入 `cache` 时按实例缓存（同一实例内复用同一份访客标识）；
-* 不传时用模块级单例缓存。
-*
-* @param cache - 可选的实例级匿名 kww 缓存
-* @returns 可用于匿名请求的 `kww`
-*/
-const deriveKuaishouAnonymousKww$1 = (cache) => {
-	if (cache) return cache.get();
-	if (!kuaishouAnonymousKwwCache$1) kuaishouAnonymousKwwCache$1 = `${encryptKuaishouAnonymousKwwSeed$1(generateKuaishouAnonymousKwwSeed$1())}${KUAISHOU_ANONYMOUS_KWW_SUFFIX$1}`;
-	return kuaishouAnonymousKwwCache$1;
-};
-/**
-* 解析快手 `kww` 请求头。
-*
-* 当前页面存在两条路径：
-* 1. 若已有 `kwfv1`，则 `kww` 直接复用该值
-* 2. 若还没有访客 Cookie，则退回到页面本地生成的匿名 `kww`
-*
-* @param cookie - 原始 Cookie 字符串
-* @param cache - 可选的实例级匿名 kww 缓存
-* @returns 可用于请求头的 `kww` 值
-*/
-const deriveKuaishouKww$1 = (cookie, cache) => {
-	const kwfv1 = extractCookieValue$1(cookie, "kwfv1");
-	if (kwfv1) return kwfv1;
-	return deriveKuaishouAnonymousKww$1(cache);
-};
-//#endregion
-//#region src/platforms/kuaishou/sign/state.ts
-const KUAISHOU_DEFAULT_CAT_VERSION$1 = "2";
-const KUAISHOU_DEFAULT_COUNT$1 = 100;
-const KUAISHOU_SECS_STACK_LIMIT$1 = 100;
-const captureKuaishouEncodeStack$1 = () => {
-	try {
-		throw new Error();
-	} catch (error) {
-		return error instanceof Error ? error.stack ?? "" : "";
-	}
-};
-/**
-* 计算快手 `SECS.s` 所需的调用栈尾部。
-*
-* 真实页面会取 `Error().stack` 的最后 100 个字符，
-* 这里保持同样的裁剪规则。
-*
-* @param stack - 可选的完整调用栈；不传时会即时捕获
-* @returns 用于 `SECS.s` 的栈尾字符串
-*/
-const deriveKuaishouSecsStackTail$1 = (stack = captureKuaishouEncodeStack$1()) => {
-	return stack.length > KUAISHOU_SECS_STACK_LIMIT$1 ? stack.slice(-100) : stack;
-};
-/**
-* 构造快手 `window.SECS` 的纯算法等价状态。
-*
-* @param count - 当前签名计数器
-* @param stack - 可选的完整调用栈
-* @returns 包含 `s` 与 `c` 的 `SECS` 状态对象
-*/
-const deriveKuaishouSecsState$1 = (count, stack) => {
-	return {
-		s: deriveKuaishouSecsStackTail$1(stack),
-		c: count
-	};
-};
-/**
-* 创建一份独立的快手签名运行时状态。
-*
-* 每次调用创建独立副本，`count` / `startupRandom` 随签名器实例走。
-*
-* @returns 新的签名运行时状态（`count` 从默认值 100 起步）
-*/
-const createKuaishouPureRuntimeState = () => ({
-	catVersion: KUAISHOU_DEFAULT_CAT_VERSION$1,
-	count: KUAISHOU_DEFAULT_COUNT$1,
-	startupRandom: Date.now()
-});
-//#endregion
-//#region src/platforms/kuaishou/sign/index.ts
-/**
-* 快手签名器（**实例级**）。
-*
-* 签名状态（`count` / `startupRandom` / 匿名 `kww` 缓存）随实例走，不挂在模块级
-* 单例上 —— 同进程内两个 client 的签名互不干扰：
-* - `count` 每次签名递增，但只影响当前实例。
-* - 匿名 `kww` 按实例缓存（同一实例内复用，不同实例各自生成）。
-* - `startupRandom` 按实例生成。
-*/
-var KuaishouSigner = class {
-	runtimeState;
-	anonymousKwwCache;
-	constructor() {
-		this.runtimeState = createKuaishouPureRuntimeState();
-		this.anonymousKwwCache = createKuaishouAnonymousKwwCache();
-	}
-	/**
-	* 获取当前纯算法运行时使用的 `caver`。
-	* @returns 快手 `caver` 值
-	*/
-	getCatVersion() {
-		return this.runtimeState.catVersion;
-	}
-	/**
-	* 生成快手请求头中的 `kww` 值（匿名分支按实例缓存）。
-	* @param cookie - 原始 Cookie 字符串
-	* @returns `kww` 请求头值
-	*/
-	generateKww(cookie) {
-		return deriveKuaishouKww$1(cookie, this.anonymousKwwCache);
-	}
-	/**
-	* 根据结构化签名载荷生成 `__NS_hxfalcon`。
-	*
-	* `count` 随实例递增：同一实例内连续签名结果不同（防重放），
-	* 但两个实例的 `count` 互不干扰。
-	*
-	* @param payload - 已标准化的快手签名载荷
-	* @returns 包含最终签名串、sign input 与 `caver` 的结果
-	*/
-	generateHxfalconFromPayload(payload) {
-		const signInput = buildKuaishouHxfalconSignInput$1(payload);
-		const count = this.runtimeState.count;
-		const secs = deriveKuaishouSecsState$1(count);
-		const scriptCount = globalThis.document?.scripts?.length ?? 0;
-		const catVersion = this.runtimeState.catVersion;
-		const signResult = deriveKuaishouPureSignature({
-			count,
-			randomValue: Math.random(),
-			scriptCount,
-			secs,
-			signInput,
-			startupRandom: this.runtimeState.startupRandom,
-			timestamp: Date.now()
-		}).signResult;
-		this.runtimeState.count += 1;
-		return {
-			signResult,
-			signInput,
-			catVersion
-		};
-	}
-	/**
-	* 为快手 `live_api` / H5 URL 签名。
-	* @param url - 实际请求 URL
-	* @param cookie - 原始 Cookie 字符串
-	* @param signPath - 可选的规范签名路径
-	* @param requestBody - 参与签名的请求体（POST 端点必传，见 helpers 的说明）
-	* @returns 带签名 URL、附加请求头和调试信息
-	*/
-	signLiveApiUrl(url, cookie, signPath, requestBody = {}) {
-		const payload = buildKuaishouHxfalconPayload$1(url, signPath, requestBody);
-		const { signResult, signInput, catVersion } = this.generateHxfalconFromPayload(payload);
-		const signedUrl = new URL(url);
-		const headers = {};
-		const kww = deriveKuaishouKww$1(cookie, this.anonymousKwwCache);
-		signedUrl.searchParams.set("__NS_hxfalcon", signResult);
-		signedUrl.searchParams.set("caver", catVersion);
-		if (kww) headers.kww = kww;
-		return {
-			url: signedUrl.toString(),
-			headers,
-			signResult,
-			signInput,
-			catVersion
-		};
-	}
-	/**
-	* 为结构化的快手 `live_api` 请求描述对象签名。
-	*
-	* 入参与静态类 {@link kuaishouSign} 相同，但状态随实例。
-	*
-	* @param request - 快手 `live_api` 请求描述对象
-	* @param cookie - 原始 Cookie 字符串
-	* @param requestBody - 参与签名的请求体
-	* @returns 带签名 URL、附加请求头和调试信息
-	*/
-	signLiveApiRequest(request, cookie, requestBody = {}) {
-		return this.signLiveApiUrl(request.url, cookie, request.signPath, requestBody);
-	}
-};
-/**
-* 创建一个快手签名器实例。
-*
-* 每个 client 持有一个实例，签名状态（`count` / `startupRandom` /
-* 匿名 `kww`）随实例走。
-* @returns 新的签名器实例
-*/
-const createKuaishouSigner = () => new KuaishouSigner();
-//#endregion
 //#region src/platforms/kuaishou/sign/signers.ts
 /**
-* 快手签名器表。
-*
-* 一张表只有一个签名器：快手的 `live_api`（`/rest/k/*`）与 H5（`/rest/wd/*`）
-* 共用 `__NS_hxfalcon` 这一套算法，区别只在喂什么料。
-*/
-/** 签名时必须出现在 query 里的版本标记 —— 它参与 sign input，不能只在发送时补 */
-const CAVER_PARAM = "caver";
-/**
-* 取参与签名的请求体。
-*
-* 只认普通对象：签名把 `JSON.stringify(body)` 拼在 sign input 尾部，而 transport
-* 交给 axios 的也是同一个对象（同样 `JSON.stringify`），两边逐字一致才算签对。
-* 若 body 已被端点预先序列化成字符串或换成了别的形状，签名与实发就会错位 ——
-* 这正是「签名验证失败」最难查的形态，所以这里直接抛，不静默签一个错的。
-* @param spec - 请求描述
-* @returns 参与签名的请求体
-*/
-const signableBody = (spec) => {
-	if (spec.body === void 0 || spec.body === null) return {};
-	if (typeof spec.body !== "object" || Array.isArray(spec.body)) throw new Error(`快手签名只支持普通对象 body，收到 ${Array.isArray(spec.body) ? "array" : typeof spec.body}`);
-	return spec.body;
-};
-/**
-* 造 `__NS_hxfalcon` 签名器。
-*
-* 签名的三份料全部从 spec 上取 —— 走正规 `sign` 声明这条路，`body` 天然可得，
-* 不需要在 request 层手动把 body 递给签名器：
-* - query：从 `spec.url` 解析，必须含 `caver`（缺就按签名器自己的 `catVersion`
-*   补上，补的值与最终发出去的一致）
-* - `spec.signPath`：规范签名路径（端点已在 spec 里填好）
-* - `spec.body`：POST 端点的请求体，`photo/info` 一类严格校验的接口非它不可
-* @param signer - 签名器实例（状态随实例：`count` / `startupRandom` / 匿名 kww）
-* @returns 签名函数
-*/
-const createHxfalconSigner = (signer) => (spec, ctx) => {
-	const url = new URL(spec.url);
-	if (!url.searchParams.get(CAVER_PARAM)) url.searchParams.set(CAVER_PARAM, signer.getCatVersion());
-	const signed = signer.signLiveApiUrl(url.toString(), ctx.cookie, spec.signPath, signableBody(spec));
-	const headers = new AmagiHeaders(spec.headers);
-	for (const [key, value] of Object.entries(signed.headers)) headers.set(key, value);
-	return {
-		...spec,
-		url: signed.url,
-		headers: headers.toJSON()
-	};
-};
-/**
 * 创建快手签名器表。
 *
 * 表由 `PLATFORM_RUNTIME.kuaishou.signers` 持有，与另外三个平台同构 ——
 * client fetcher / `createKuaishouRoutes` / 静态 fetcher 三个入口共用同一张表，
 * 保证任何入口下的签名行为一致。
 *
-* `signer` 可注入：签名器实例带状态（`count` / `startupRandom` / 匿名 kww）；
-* 表里只放 `SignFn`，混进一个实例会让它不再满足 `Record<string, SignFn>`。
-* @param signer - 签名器实例，缺省新建一个
+* `signer` 可注入：缺省用 `steps.ts` 的模块级 {@link sharedKuaishouSigner}，于是端点
+* 声明与 `client.kuaishou.request` 两条路共用一个 `count`；测试可注入独立实例做隔离。
+* @param signer - 签名器实例，缺省用共享实例
 * @returns 签名器表
 */
-const createKuaishouSigners = (signer = createKuaishouSigner()) => ({ hxfalcon: createHxfalconSigner(signer) });
+const createKuaishouSigners = (signer = sharedKuaishouSigner) => ({ hxfalcon: stepsToSigner([hxfalcon(signer)]) });
 //#endregion
 //#region src/platforms/xiaohongshu/config.ts
 /**
@@ -5083,392 +2938,50 @@ const xiaohongshuJudge = (raw, http) => {
 	return verdictFromHttpStatus(http.status) ?? { ok: true };
 };
 //#endregion
-//#region src/platforms/xiaohongshu/sign/config.ts
-/** 初始化签名配置。 */
-const createXiaohongshuCryptoConfig = () => new CryptoConfig().withOverrides({
-	DATA_WEB_BUILD: "6.12.3",
-	SIGNATURE_DATA_TEMPLATE: {
-		x0: "4.4.3",
-		x1: "xhs-pc-web",
-		x2: "Windows",
-		x3: "",
-		x4: ""
-	},
-	SIGNATURE_XSCOMMON_TEMPLATE: {
-		s0: 5,
-		s1: "",
-		x0: "1",
-		x1: "4.3.5",
-		x2: "Windows",
-		x3: "xhs-pc-web",
-		x4: "6.12.3",
-		x5: "",
-		x6: "",
-		x7: "",
-		x8: "",
-		x9: -596800761,
-		x10: 0,
-		x11: "normal"
-	}
-});
-//#endregion
-//#region src/platforms/xiaohongshu/sign/guestCookie.ts
-/** @see https://github.com/Cialle/RedCrack */
-/** 小红书 Web 端游客会话初始化使用的浏览器请求头。 */
-const GUEST_HEADERS$1 = {
-	accept: "application/json, text/plain, */*",
-	"accept-language": "zh-CN,zh;q=0.9,en;q=0.8,en-GB;q=0.7,en-US;q=0.6",
-	"content-type": "application/json;charset=UTF-8",
-	origin: "https://www.xiaohongshu.com",
-	priority: "u=1, i",
-	referer: "https://www.xiaohongshu.com/",
-	"sec-ch-ua": "\"Microsoft Edge\";v=\"141\", \"Not?A_Brand\";v=\"8\", \"Chromium\";v=\"141\"",
-	"sec-ch-ua-mobile": "?0",
-	"sec-ch-ua-platform": "\"Windows\"",
-	"sec-fetch-dest": "empty",
-	"sec-fetch-mode": "cors",
-	"sec-fetch-site": "same-site",
-	"user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36 Edg/141.0.0.0"
-};
-/** 生成 a1 随机段时使用的 Web 端字符集。 */
-const COOKIE_RANDOM_CHARS$1 = "abcdefghijklmnopqrstuvwxyz1234567890";
-/** 将 Cookie Jar 序列化为可直接写入 HTTP Cookie 请求头的字符串。 */
-const toCookieString$1 = (cookies) => Object.entries(cookies).map(([key, value]) => `${key}=${value}`).join("; ");
-/** 将响应头中的 Set-Cookie 字段合并到当前游客会话的 Cookie Jar。 */
-const updateCookiesFromResponse$1 = (cookies, setCookie) => {
-	const headers = Array.isArray(setCookie) ? setCookie : setCookie ? [setCookie] : [];
-	for (const header of headers) {
-		const [nameValue] = header.split(";", 1);
-		const separatorIndex = nameValue.indexOf("=");
-		if (separatorIndex > 0) cookies[nameValue.slice(0, separatorIndex).trim()] = nameValue.slice(separatorIndex + 1).trim();
-	}
-};
-/** 按小红书 Web 端规则生成 a1，以及由 a1 派生的 webId。 */
-const generateA1AndWebId$1 = () => {
-	const source = `${Date.now().toString(16)}${Array.from(randomBytes(30), (byte) => COOKIE_RANDOM_CHARS$1[byte % 36]).join("")}5000`;
-	const a1 = `${source}${crc32$1(source)}`.slice(0, 52);
-	return {
-		a1,
-		webId: createHash("md5").update(a1).digest("hex")
-	};
-};
-/** 计算与浏览器端实现兼容的无符号 CRC32 校验值。 */
-const crc32$1 = (input) => {
-	let value = 4294967295;
-	for (const byte of Buffer.from(input)) {
-		value ^= byte;
-		for (let bit = 0; bit < 8; bit += 1) value = value & 1 ? value >>> 1 ^ 3988292384 : value >>> 1;
-	}
-	return (value ^ 4294967295) >>> 0;
-};
-/** 从 scripting 接口返回的 VMP 数据中解码 websectiga Cookie。 */
-const generateWebsectiga$1 = (payload) => {
-	const bMatch = payload.match(/"b":"(.*?)",/);
-	const dMatch = payload.match(/"d":(.*?)\}\)/);
-	if (!bMatch || !dMatch) throw new Error("小红书 scripting 响应格式异常，无法生成 websectiga");
-	const decoderData = JSON.parse(dMatch[1]);
-	const encoded = Buffer.from(bMatch[1], "base64").toString("utf8");
-	const logicList = [];
-	for (let index = 0; index < encoded.length; index += 5) logicList.push(Array.from(encoded.slice(index, index + 5), (char) => char.charCodeAt(0) - 1));
-	const start = decoderData[92];
-	const end = decoderData[93];
-	const target = logicList.slice(start, end + 1);
-	const key = Array.from({ length: 64 }, (_, index) => {
-		const item = target[675 + index * 2];
-		if (!item) throw new Error("小红书 scripting 响应缺少 websectiga 解码数据");
-		return decoderData[item[2]];
-	});
-	return Array.from({ length: 8 }, (_, group) => {
-		const offset = 56 - group * 8;
-		return String.fromCharCode(...key.slice(offset, offset + 8));
-	}).join("");
-};
-/** 将浏览器指纹编码为 webprofile 接口要求的 DES-ECB profileData。 */
-const encryptProfileData$1 = (fingerprint, desKey) => {
-	const encoded = Buffer.from(JSON.stringify(fingerprint)).toString("base64");
-	const blockSize = 8;
-	const padding = blockSize - encoded.length % blockSize;
-	const plaintext = Buffer.concat([Buffer.from(encoded), Buffer.alloc(padding)]);
-	const cipher = createCipheriv("des-ede3", Buffer.from(desKey.repeat(3)), null);
-	cipher.setAutoPadding(false);
-	return Buffer.concat([cipher.update(plaintext), cipher.final()]).toString("hex");
-};
-/** 将 scripting 的 JSON 或 JSONP 响应统一还原为结构化数据。 */
-const unwrapScriptingResponse$1 = (data) => {
-	if (typeof data === "string") {
-		const json = data.match(/^[^(]+\((.*)\)$/s)?.[1];
-		return JSON.parse(json ?? data);
-	}
-	return data;
-};
-/**
-* 创建小红书 Web 端游客会话 Cookie。
-*
-* 该流程对应 Web 端首次访问时的 Cookie 初始化：生成 a1/webId，完成
-* scripting、webprofile 与 activate 三个会话请求，并返回最终 Cookie 字符串。
-*
-* 会话请求经注入的 `send` 走 transport —— 调用方配的
-* proxy / agent / 超时对它生效；请求头、响应处理与 Cookie 合并逻辑
-* 不随发送方式改变。
-* @param send - 注入的底层发送函数（来自 transport）
-* @param requestConfig - 调用方请求配置，透传
-* @returns 游客 Cookie 字符串
-*/
-const createXiaohongshuGuestCookie$1 = async (send, requestConfig) => {
-	const cryptoConfig = createXiaohongshuCryptoConfig();
-	const signer = new Xhshow(cryptoConfig);
-	const cookies = {
-		...generateA1AndWebId$1(),
-		webBuild: cryptoConfig.DATA_WEB_BUILD,
-		xsecappid: "xhs-pc-web",
-		loadts: String(Date.now()),
-		abRequestId: randomUUID()
-	};
-	const { headers: requestHeaders } = requestConfig ?? {};
-	/** 发送会话初始化请求，并将响应中的 Set-Cookie 合并回当前 Cookie Jar。 */
-	const request = async (url, data, signed = false) => {
-		const signatureHeaders = signed ? signer.signHeadersPost(new URL(url).pathname, cookies, "xhs-pc-web", data) : {};
-		const response = await send({
-			method: "POST",
-			url,
-			body: data,
-			headers: {
-				...GUEST_HEADERS$1,
-				...requestHeaders,
-				...signatureHeaders,
-				Cookie: toCookieString$1(cookies)
-			}
-		});
-		const setCookie = response.setCookie;
-		updateCookiesFromResponse$1(cookies, setCookie);
-		if (response.status < 200 || response.status >= 300) throw new Error(`小红书游客会话初始化失败：${url} 返回 HTTP ${response.status}`);
-		return response.body;
-	};
-	const scriptingData = unwrapScriptingResponse$1(await request("https://as.xiaohongshu.com/api/sec/v1/scripting", {
-		callFrom: "web",
-		callback: "seccallback"
-	})).data;
-	if (!scriptingData?.data || !scriptingData.secPoisonId) throw new Error("小红书 scripting 响应缺少游客会话数据");
-	cookies.websectiga = generateWebsectiga$1(scriptingData.data);
-	cookies.sec_poison_id = scriptingData.secPoisonId;
-	const fingerprint = new FingerprintGenerator(cryptoConfig).generate(cookies, GUEST_HEADERS$1["user-agent"]);
-	await request(cryptoConfig.GID_URL, {
-		platform: cryptoConfig.DATA_PLATFORM,
-		profileData: encryptProfileData$1(fingerprint, cryptoConfig.DES_KEY),
-		sdkVersion: cryptoConfig.DATA_SDK_VERSION,
-		svn: cryptoConfig.DATA_SVN
-	}, true);
-	await request("https://edith.xiaohongshu.com/api/sns/web/v1/login/activate", {}, true);
-	if (!cookies.web_session) throw new Error("小红书游客会话初始化失败：未获取到 web_session");
-	return toCookieString$1(cookies);
-};
-//#endregion
-//#region src/platforms/xiaohongshu/sign/index.ts
+//#region src/platforms/xiaohongshu/sign/signers.ts
 /**
-* 小红书签名算法。
+* 小红书签名器表：**只做「注册名 → `SignStep` 清单」的映射，不含算法**。
 *
-* 包装 `@ikenxuan/xhshow-ts` 的 `Xhshow` 实例，提供 GET / POST / X-S-Common /
-* X-T / X-B3-Traceid / X-Xray-Traceid / X-Rap-Param / 搜索 ID / 搜索 request_id
-* 的生成函数。a1 从 cookie 取值的逻辑用 `contracts/cookie.ts` 的 `getCookieValue`。
+* 算法的唯一实现在 `./steps.ts`（四个基础签名器、helper，以及 XYS_/XYW_ 协议区别、
+* 签名路径为何取 signPath 等理由都在那边的文件头）。依赖方向单向 —— `signers.ts → steps.ts`，
+* 永不反向：两份实现并存时会改一边忘一边，而小红书签名错了往往整条请求被判 406，这类分叉极难发现。
 *
-* `Xhshow` 实例是模块级单例，行为与性能无额外开销。
+* ## 两条路，一份实现
 *
-* 上游 2026-02 之后的新协议由这里落地：
-* - **XYW_ 格式**（`generateXSGetXyw` / `generateXSPostXyw`）：数据获取类接口
-*   （`user_posted`、`user/otherinfo` 等）自 2026-03 起以 HTTP 406 拒绝传统 XYS_
-*   格式，改用基于 AES-128-CBC 的 XYW_ 签名。x-s 值以 `XYW_` 开头。
-* - **x-rap-param**（`generateXRapParam`）：feed / 搜索 / 发布类接口的额外校验头。
-* - **x-xray-traceid**（`generateXrayTraceid`）：追踪头，随现代浏览器每次请求下发。
-* - **search request_id**（`getSearchRequestId`）：搜索接口所需的 `{random}-{ts_ms}`。
-*/
-/** 模块级 Xhshow 单例 */
-const client = new Xhshow(createXiaohongshuCryptoConfig());
-/**
-* 生成 GET 请求的 X-S 签名。
-* @param path - API 路径，如 `/api/sns/web/v1/feed`
-* @param a1Cookie - a1 cookie 值
-* @param clientType - 客户端类型，默认 `'xhs-pc-web'`
-* @param params - 查询参数对象
-* @returns X-S 签名
-*/
-const generateXSGet = (path, a1Cookie, clientType = "xhs-pc-web", params = {}) => client.signXsGet(path, a1Cookie, clientType, params);
-/**
-* 生成 POST 请求的 X-S 签名。
-* @param path - API 路径
-* @param a1Cookie - a1 cookie 值
-* @param clientType - 客户端类型，默认 `'xhs-pc-web'`
-* @param body - 请求体对象
-* @returns X-S 签名
-*/
-const generateXSPost = (path, a1Cookie, clientType = "xhs-pc-web", body = {}) => client.signXsPost(path, a1Cookie, clientType, body);
-/**
-* 生成 GET 请求的 XYW_ 格式 X-S 签名（AES-128-CBC）。
+* 端点声明 `sign: [xs('get', 'xyw'), traceId()]` 走清单；`client.xiaohongshu.request` 不给
+* `amagi.sign` 时走字符串 `'xhs-get'` 这类名字查这张表。两者现在压的是同一批 step，签出来必然一致。
 *
-* 数据获取类接口（`user_posted` 等）自 2026-03 起以 HTTP 406 拒绝 XYS_ 格式，
-* 需改用本函数。返回值以 `XYW_` 开头，走独立于 `signXsGet` 的加密路径。
-* @param path - API 路径，如 `/api/sns/web/v1/user_posted`
-* @param a1Cookie - a1 cookie 值
-* @param clientType - 客户端类型，默认 `'xhs-pc-web'`
-* @param params - 查询参数对象
-* @returns XYW_ 格式 X-S 签名
-*/
-const generateXSGetXyw = (path, a1Cookie, clientType = "xhs-pc-web", params = {}) => client.signXyw("GET", path, a1Cookie, clientType, params);
-/**
-* 生成 POST 请求的 XYW_ 格式 X-S 签名（AES-128-CBC）。
-* @param path - API 路径
-* @param a1Cookie - a1 cookie 值
-* @param clientType - 客户端类型，默认 `'xhs-pc-web'`
-* @param body - 请求体对象
-* @returns XYW_ 格式 X-S 签名
-*/
-const generateXSPostXyw = (path, a1Cookie, clientType = "xhs-pc-web", body = {}) => client.signXyw("POST", path, a1Cookie, clientType, body);
-/**
-* 生成 X-Rap-Param 请求头（feed / 搜索 / 发布类接口的额外校验）。
-* @param api - 请求 API，形如 `//edith.xiaohongshu.com/api/sns/web/v1/feed`（含 host、去协议）
-* @param body - 请求体对象（GET 传空对象）
-* @returns Base64 编码的 x-rap-param 字符串
-*/
-const generateXRapParam = (api, body = {}) => xRapParam(api, body);
-/**
-* 生成 X-S-Common 参数。
-* @param cookies - cookie 字符串
-* @returns Base64 编码的随机字符串
-*/
-const generateXSCommon = (cookies) => client.signXsCommon(cookies);
-/**
-* 生成 X-T 时间戳。
-* @returns 当前时间戳（毫秒）
-*/
-const generateXT = () => client.getXT();
-/**
-* 生成 X-B3-Traceid。
-* @returns 16 位随机字符串
-*/
-const generateXB3Traceid = () => client.getB3TraceId();
-/**
-* 生成 X-Xray-Traceid。
-*
-* 32 位字符（16 位时间戳+序列 + 16 位随机），随现代浏览器每次请求下发。
-* @returns X-Xray-Traceid 字符串
-*/
-const generateXrayTraceid = () => client.getXrayTraceId();
-/**
-* 生成搜索 ID。
-*
-* 交由上游 `client.getSearchId()`：base36 编码的 `(timestamp_ms << 64) + random`。
-* 旧的本地实现把 BigInt 与 string 相加，得到「十进制拼 base36 后缀」而非预期的
-* 位运算结果 —— 上游修正后此处直接复用，不再自行拼装。
-* @returns 搜索 ID 字符串
-*/
-const getSearchId = () => client.getSearchId();
-//#endregion
-//#region src/platforms/xiaohongshu/sign/signers.ts
-/**
-* 小红书签名器表。
+* ## 七个注册名
 *
 * XYS_（传统）路径：
-* - `'xhs-post'`：POST 请求，`x-s` 用 `signXsPost` 对 body 签名
-* - `'xhs-get'`：GET 请求，`x-s` 用 `signXsGet` 对 query 签名
+* - `'xhs-post'`：POST，x-s 用 `signXsPost` 对 body 签名
+* - `'xhs-get'`：GET，x-s 用 `signXsGet` 对 query 签名
 * - `'xhs-get-trace'`：GET + `x-b3-traceid`（userNoteList 专用）
 * - `'xhs-post-rap'`：POST + `x-rap-param`（feed / 搜索 / 发布类接口的额外校验）
 *
-* XYW_（2026-03 之后）路径 —— 数据获取类接口以 HTTP 406 拒绝 XYS_，`x-s` 改用
-* 以 `XYW_` 开头的 AES-128-CBC 签名：
-* - `'xhs-get-xyw'`：GET，`x-s` 用 `signXyw`
-* - `'xhs-post-xyw'`：POST，`x-s` 用 `signXyw`
+* XYW_（2026-03 之后）路径 —— 数据获取类接口以 HTTP 406 拒绝 XYS_，x-s 改用以 `XYW_`
+* 开头的 AES-128-CBC 签名：
+* - `'xhs-get-xyw'`：GET，x-s 用 `signXyw`
+* - `'xhs-post-xyw'`：POST，x-s 用 `signXyw`
 * - `'xhs-get-xyw-trace'`：GET XYW + `x-b3-traceid`（userNoteList 专用）
 *
-* 签名路径取自 `spec.signPath`（build 里填 `apiPath`），不是 `spec.url`：
-* 小红书签名只用接口路径，与完整 URL 无关。x-rap-param 例外，它要 host + path。
-*
-* 签名输入：a1 取自 cookie，POST 签名含 body，GET 签名含 query。
+* @module platforms/xiaohongshu/sign/signers
 */
-/** 从 cookie 取 a1：用 `getCookieValue` 按名精确匹配 */
-const a1Of = (cookie) => getCookieValue(cookie, "a1") ?? "";
-/** 签名路径：优先 `spec.signPath`（build 填的 apiPath），缺省取 URL 的 pathname */
-const apiPathOf = (spec) => spec.signPath ?? new URL(spec.url).pathname;
 /**
-* 取签名用的 query 参数：GET 端点在 `build` 里把原始 params 放进 `extra.signParams`。
-* 小红书 GET 的 x-s 必须覆盖 query（路径 + 参数），只签路径会被判非法请求返回 406。
-* 无参数端点（emojiList / userProfile）返回空对象，签名退化为只签路径，行为不变。
-*/
-const signParamsOf = (spec) => spec.extra?.signParams ?? {};
-/** x-rap-param 的 api 入参：去协议、保留 `//host/path`（不含 query） */
-const rapApiOf = (spec) => {
-	const url = new URL(spec.url);
-	return `//${url.host}${url.pathname}`;
-};
-/**
-* 注入 x-s / x-s-common / x-t / x-xray-traceid 四个签名头。
+* 平台签名器表，交给 runtime 的 `signers` 查名。
 *
-* `x-xray-traceid` 是真实浏览器每次请求都带的追踪头（见 noteComments 的抓包）；
-* 早期只发前三个，`comment/page` 这类接口会因此被判为非法请求，返回 HTTP 406。
-* 所有平台签名器共用本 helper，因此补上后对全部端点生效。
+* 用 `satisfies` 而非显式 `: Record<string, SignFn>` 返回：后者会把键联合抹成宽
+* `string`，而 {@link XiaohongshuSignerName} 要靠 `keyof` 从这张表推导精确名字联合。
+* @returns 注册名 → 签名器
 */
-const signHeaders = (spec, ctx, xs) => {
-	const headers = new AmagiHeaders(spec.headers).set("x-s", xs).set("x-s-common", generateXSCommon(ctx.cookie)).set("x-t", String(generateXT())).set("x-xray-traceid", generateXrayTraceid());
-	return {
-		...spec,
-		headers: headers.toJSON()
-	};
-};
-/** POST 签名器：x-s = signXsPost(apiPath, a1, 'xhs-pc-web', body) */
-const xhsPostSigner = (spec, ctx) => {
-	const xs = generateXSPost(apiPathOf(spec), a1Of(ctx.cookie), "xhs-pc-web", spec.body ?? {});
-	return signHeaders(spec, ctx, xs);
-};
-/** GET 签名器：x-s = signXsGet(apiPath, a1, 'xhs-pc-web', signParams) */
-const xhsGetSigner = (spec, ctx) => {
-	const xs = generateXSGet(apiPathOf(spec), a1Of(ctx.cookie), "xhs-pc-web", signParamsOf(spec));
-	return signHeaders(spec, ctx, xs);
-};
-/** GET + x-b3-traceid（userNoteList 专用） */
-const xhsGetTraceSigner = async (spec, ctx) => {
-	const signed = await xhsGetSigner(spec, ctx);
-	const headers = new AmagiHeaders(signed.headers).set("x-b3-traceid", generateXB3Traceid());
-	return {
-		...signed,
-		headers: headers.toJSON()
-	};
-};
-/** POST + x-rap-param（feed / 搜索 / 发布类接口的额外校验） */
-const xhsPostRapSigner = async (spec, ctx) => {
-	const signed = await xhsPostSigner(spec, ctx);
-	const rap = generateXRapParam(rapApiOf(spec), spec.body ?? {});
-	const headers = new AmagiHeaders(signed.headers).set("x-rap-param", rap);
-	return {
-		...signed,
-		headers: headers.toJSON()
-	};
-};
-/** XYW GET 签名器：x-s = signXyw('GET', apiPath, a1, 'xhs-pc-web', signParams)，绕过数据接口 406 */
-const xhsGetXywSigner = (spec, ctx) => {
-	const xs = generateXSGetXyw(apiPathOf(spec), a1Of(ctx.cookie), "xhs-pc-web", signParamsOf(spec));
-	return signHeaders(spec, ctx, xs);
-};
-/** XYW POST 签名器：x-s = signXyw('POST', apiPath, a1, 'xhs-pc-web', body) */
-const xhsPostXywSigner = (spec, ctx) => {
-	const xs = generateXSPostXyw(apiPathOf(spec), a1Of(ctx.cookie), "xhs-pc-web", spec.body ?? {});
-	return signHeaders(spec, ctx, xs);
-};
-/** XYW GET + x-b3-traceid（userNoteList 专用，2026-03 之后） */
-const xhsGetXywTraceSigner = async (spec, ctx) => {
-	const signed = await xhsGetXywSigner(spec, ctx);
-	const headers = new AmagiHeaders(signed.headers).set("x-b3-traceid", generateXB3Traceid());
-	return {
-		...signed,
-		headers: headers.toJSON()
-	};
-};
-/** 平台签名器表，交给 runtime 的 `signers` 查名 */
 const createXiaohongshuSigners = () => ({
-	"xhs-post": xhsPostSigner,
-	"xhs-get": xhsGetSigner,
-	"xhs-get-trace": xhsGetTraceSigner,
-	"xhs-post-rap": xhsPostRapSigner,
-	"xhs-get-xyw": xhsGetXywSigner,
-	"xhs-post-xyw": xhsPostXywSigner,
-	"xhs-get-xyw-trace": xhsGetXywTraceSigner
+	"xhs-post": stepsToSigner([xs("post", "xys")]),
+	"xhs-get": stepsToSigner([xs("get", "xys")]),
+	"xhs-get-trace": stepsToSigner([xs("get", "xys"), traceId()]),
+	"xhs-post-rap": stepsToSigner([xs("post", "xys"), rap()]),
+	"xhs-get-xyw": stepsToSigner([xs("get", "xyw")]),
+	"xhs-post-xyw": stepsToSigner([xs("post", "xyw")]),
+	"xhs-get-xyw-trace": stepsToSigner([xs("get", "xyw"), traceId()])
 });
 //#endregion
 //#region src/runtime/events.ts
@@ -6377,7 +3890,10 @@ const runPaginated = async (def, params, runPage) => {
 	const limitKey = def.limitParam ?? "number";
 	const countKey = def.countParam ?? limitKey;
 	const target = resolveTarget(params[limitKey], def.maxPageSize);
-	const pages = [];
+	if (target === 0) return {
+		ok: true,
+		value: { empty: true }
+	};
 	const collected = [];
 	let current = params;
 	let lastPage;
@@ -6394,7 +3910,6 @@ const runPaginated = async (def, params, runPage) => {
 			error: outcome.error
 		};
 		const page = outcome.value;
-		pages.push(page);
 		lastPage = page;
 		const list = def.items(page);
 		if (Array.isArray(list) && list.length > 0) collected.push(...list);
@@ -6406,9 +3921,9 @@ const runPaginated = async (def, params, runPage) => {
 	return {
 		ok: true,
 		value: {
+			empty: false,
 			lastPage,
-			pages,
-			items: target === 0 ? [] : collected.slice(0, target)
+			items: collected.slice(0, target)
 		}
 	};
 };
@@ -6584,6 +4099,8 @@ const classifyThrown = (cause, stage) => {
 const resolveSigner = (decl, signers) => {
 	if (decl === void 0 || decl === false) return void 0;
 	if (typeof decl === "function") return decl;
+	if (Array.isArray(decl)) return stepsToSigner(decl);
+	if (typeof decl === "object") return stepsToSigner([decl]);
 	const signer = signers?.[decl];
 	if (!signer) throw new Error(`未注册的签名器：'${decl}'`);
 	return signer;
@@ -6760,7 +4277,10 @@ const execute = async (def, input, options) => {
 			});
 			if (!paged.ok) return failWith(paged.error);
 			stage = "normalize";
-			return succeed(def.normalize ? def.normalize(paged.value, params) : paged.value);
+			const outcome = paged.value;
+			if (outcome.empty) return succeed(void 0);
+			const merge = def.paginate.merge;
+			return succeed(merge ? merge(outcome, params) : outcome);
 		}
 		stage = "build";
 		const built = def.build(params, ctx);
@@ -6784,6 +4304,15 @@ const execute = async (def, input, options) => {
 			if (firstFailure) return failWith(firstFailure.error);
 		}
 		stage = "normalize";
+		if (isMulti && def.aggregate) {
+			const parts = outcomes.map((o) => o.ok ? o.value : void 0);
+			const head = parts.find((p) => p !== void 0);
+			const aggregate = def.aggregate;
+			return succeed(aggregate({
+				parts,
+				head
+			}, params));
+		}
 		const decodedValue = isMulti ? outcomes.map((o) => o.ok ? o.value : void 0) : outcomes[0].value;
 		return succeed(def.normalize ? def.normalize(decodedValue, params) : decodedValue);
 	} catch (cause) {
@@ -7197,7 +4726,6 @@ var DouyinAPI$1 = class {
 			platform: "PC",
 			downlink: "10",
 			effective_type: "4g",
-			msToken: douyinSign$1.Mstoken(184),
 			verifyFp: fp$1,
 			fp: fp$1
 		};
@@ -7301,7 +4829,6 @@ var DouyinAPI$1 = class {
 			device_id: "7326472315356857893",
 			aweme_ids: `[${data.aweme_id}]`,
 			request_source: "200",
-			msToken: douyinSign$1.Mstoken(116),
 			verifyFp: fp$1,
 			fp: fp$1
 		};
@@ -7423,7 +4950,6 @@ var DouyinAPI$1 = class {
 			downlink: "10",
 			effective_type: "4g",
 			round_trip_time: "50",
-			msToken: douyinSign$1.Mstoken(184),
 			verifyFp: fp$1,
 			fp: fp$1
 		};
@@ -7551,8 +5077,7 @@ var DouyinAPI$1 = class {
 	}
 	/** 获取互动表情数据 */
 	getDynamicEmojiList() {
-		const baseUrl = "https://www.douyin.com/aweme/v1/web/im/strategy/config";
-		const params = {
+		return `https://www.douyin.com/aweme/v1/web/im/strategy/config?${buildQueryString$3({
 			device_platform: "webapp",
 			aid: "1128",
 			channel: "channel_pc_web",
@@ -7581,11 +5106,9 @@ var DouyinAPI$1 = class {
 			downlink: "1.5",
 			effective_type: "4g",
 			round_trip_time: "350",
-			msToken: douyinSign$1.Mstoken(116),
 			verifyFp: fp$1,
 			fp: fp$1
-		};
-		return `${baseUrl}?${buildQueryString$3(params)}`;
+		})}`;
 	}
 	/** 获取背景音乐数据 */
 	getMusicInfo(data) {
@@ -7617,7 +5140,6 @@ var DouyinAPI$1 = class {
 			downlink: "1.5",
 			effective_type: "4g",
 			round_trip_time: "350",
-			msToken: douyinSign$1.Mstoken(116),
 			verifyFp: fp$1,
 			fp: fp$1
 		};
@@ -7646,7 +5168,6 @@ var DouyinAPI$1 = class {
 			is_need_double_stream: "false",
 			insert_task_id: "",
 			live_reason: "",
-			msToken: douyinSign$1.Mstoken(116),
 			verifyFp: fp$1,
 			fp: fp$1
 		};
@@ -7687,7 +5208,6 @@ var DouyinAPI$1 = class {
 			engine_version: "140.0.0.0",
 			downlink: "1.55",
 			round_trip_time: "200",
-			msToken: douyinSign$1.Mstoken(116),
 			verifyFp: fp$1,
 			fp: fp$1
 		};
@@ -7697,6 +5217,19 @@ var DouyinAPI$1 = class {
 /** 默认的 DouyinAPI 实例（使用默认浏览器版本 125.0.0.0） */
 const douyinApiUrls$1 = new DouyinAPI$1();
 //#endregion
+//#region src/platforms/douyin/endpoints/define.ts
+/**
+* 抖音端点声明。
+*
+* 就是 {@link defineEndpoint} 绑定了抖音签名器名联合 {@link DouyinSignerName}：
+* `sign` 的字符串分支被收窄成 `'a-bogus' | 'x-bogus'`，写错名字（如 `'a-bogas'`）
+* 编译期即报错，不必等运行时查表失败。运行时仍是恒等函数，其余行为与通用
+* `defineEndpoint` 完全一致。
+* @param def - 端点声明（`sign` 的名字受抖音签名器表约束）
+* @returns 原样返回 `def`，带上推导好的具体类型
+*/
+const defineDouyinEndpoint = (def) => defineEndpoint(def);
+//#endregion
 //#region src/platforms/douyin/endpoints/commentReplies.ts
 /**
 * 二级评论（声明式翻页，maxPageSize 3，签名用 `x_bogus`）。
@@ -7704,7 +5237,7 @@ const douyinApiUrls$1 = new DouyinAPI$1();
 * 与旧版一致：`getCommentReplies` GET，签名器是 `x_bogus`，游标是 `cursor`
 * （`has_more === 1` 继续），最终形状 `{ ...最后一页, comments, cursor }`。
 */
-const commentReplies = defineEndpoint({
+const commentReplies = defineDouyinEndpoint({
 	name: "douyin.commentReplies",
 	route: "/fetch_video_comment_replies",
 	doc: {
@@ -7721,7 +5254,7 @@ const commentReplies = defineEndpoint({
 		method: "GET",
 		url: douyinApiUrls$1.getCommentReplies(p)
 	}),
-	sign: "x-bogus",
+	sign: [xBogus(), secsdk()],
 	retryOn: ["ANTIBOT_PAGE"],
 	retryFresh: true,
 	paginate: {
@@ -7731,16 +5264,12 @@ const commentReplies = defineEndpoint({
 		nextParams: (params, page) => ({
 			...params,
 			cursor: page.cursor
-		})
-	},
-	normalize: (decoded) => {
-		const { lastPage, items } = decoded;
-		const page = lastPage;
-		return {
-			...page ?? {},
+		}),
+		merge: ({ lastPage, items }) => ({
+			...lastPage,
 			comments: items,
-			cursor: page?.cursor ?? items.length
-		};
+			cursor: lastPage.cursor ?? items.length
+		})
 	},
 	response: type()
 });
@@ -7753,7 +5282,7 @@ const commentReplies = defineEndpoint({
 * `cursor`（`has_more === 1` 继续），最终形状 `{ ...最后一页, comments, cursor }`
 * （`cursor: resp.cursor ?? list.length`）。
 */
-const comments$1 = defineEndpoint({
+const comments$1 = defineDouyinEndpoint({
 	name: "douyin.comments",
 	route: "/fetch_work_comments",
 	doc: {
@@ -7769,7 +5298,7 @@ const comments$1 = defineEndpoint({
 		method: "GET",
 		url: douyinApiUrls$1.getComments(p)
 	}),
-	sign: "a-bogus",
+	sign: douyinBogus(184),
 	retryOn: ["ANTIBOT_PAGE"],
 	retryFresh: true,
 	paginate: {
@@ -7779,16 +5308,12 @@ const comments$1 = defineEndpoint({
 		nextParams: (params, page) => ({
 			...params,
 			cursor: page.cursor
-		})
-	},
-	normalize: (decoded) => {
-		const { lastPage, items } = decoded;
-		const page = lastPage;
-		return {
-			...page ?? {},
+		}),
+		merge: ({ lastPage, items }) => ({
+			...lastPage,
 			comments: items,
-			cursor: page?.cursor ?? items.length
-		};
+			cursor: lastPage.cursor ?? items.length
+		})
 	},
 	response: type()
 });
@@ -7805,7 +5330,7 @@ const comments$1 = defineEndpoint({
 * 整体（execute 的 tolerate：**全部分片都失败时仍返回失败信封**），
 * `normalize` 负责合并与排序。
 */
-const danmakuList$1 = defineEndpoint({
+const danmakuList$1 = defineDouyinEndpoint({
 	name: "douyin.danmakuList",
 	route: "/fetch_work_danmaku",
 	doc: {
@@ -7853,37 +5378,18 @@ const danmakuList$1 = defineEndpoint({
 			tag: `segment-${index + 1}`
 		}));
 	},
-	sign: "a-bogus",
+	sign: douyinBogus(116),
 	retryOn: ["ANTIBOT_PAGE"],
 	retryFresh: true,
 	partial: "tolerate",
-	normalize: (decoded, params) => {
-		const parts = decoded;
-		const startTime = params.start_time ?? 0;
-		const endTime = params.end_time ?? params.duration;
-		const merged = [];
-		let finalExtra = null;
-		let finalLogPb = null;
-		let finalStatusCode = 0;
-		parts.forEach((segmentData, index) => {
-			if (segmentData && Array.isArray(segmentData.danmaku_list)) {
-				merged.push(...segmentData.danmaku_list);
-				if (index === 0) {
-					finalExtra = segmentData.extra;
-					finalLogPb = segmentData.log_pb;
-					finalStatusCode = segmentData.status_code ?? 0;
-				}
-			}
-		});
-		merged.sort((a, b) => (a.offset_time ?? 0) - (b.offset_time ?? 0));
+	aggregate: ({ parts, head }, params) => {
+		const merged = parts.flatMap((seg) => seg?.danmaku_list ?? []).sort((a, b) => a.offset_time - b.offset_time);
 		return {
+			...head,
 			danmaku_list: merged,
-			start_time: startTime,
-			end_time: endTime,
-			total: merged.length,
-			status_code: finalStatusCode,
-			extra: finalExtra,
-			log_pb: finalLogPb
+			start_time: params.start_time ?? 0,
+			end_time: params.end_time ?? params.duration,
+			total: merged.length
 		};
 	},
 	response: type()
@@ -7895,7 +5401,7 @@ const danmakuList$1 = defineEndpoint({
 *
 * 与旧版一致：`getDynamicEmojiList` GET + a_bogus 签名。
 */
-const dynamicEmojiList = defineEndpoint({
+const dynamicEmojiList = defineDouyinEndpoint({
 	name: "douyin.dynamicEmojiList",
 	route: "/fetch_emoji_pro_list",
 	doc: {
@@ -7907,7 +5413,7 @@ const dynamicEmojiList = defineEndpoint({
 		method: "GET",
 		url: douyinApiUrls$1.getDynamicEmojiList()
 	}),
-	sign: "a-bogus",
+	sign: douyinBogus(116),
 	retryOn: ["ANTIBOT_PAGE"],
 	retryFresh: true,
 	response: type()
@@ -7919,7 +5425,7 @@ const dynamicEmojiList = defineEndpoint({
 *
 * 与旧版一致：`getEmojiList` GET，**不带签名参数**。
 */
-const emojiList$3 = defineEndpoint({
+const emojiList$3 = defineDouyinEndpoint({
 	name: "douyin.emojiList",
 	route: "/fetch_emoji_list",
 	doc: {
@@ -7931,7 +5437,7 @@ const emojiList$3 = defineEndpoint({
 		method: "GET",
 		url: douyinApiUrls$1.getEmojiList()
 	}),
-	sign: false,
+	sign: [msToken(184)],
 	response: type()
 });
 //#endregion
@@ -7953,7 +5459,7 @@ const emojiList$3 = defineEndpoint({
 * 超时是「本次调用」的属性而不是端点的属性）。
 
 */
-const emojiResourceMeta = defineEndpoint({
+const emojiResourceMeta = defineDouyinEndpoint({
 	name: "douyin.emojiResourceMeta",
 	route: "/fetch_emoji_resource_meta",
 	doc: {
@@ -7988,7 +5494,7 @@ const emojiResourceMeta = defineEndpoint({
 * 接口的 `has_more` 形状还没有样本可依。
 
 */
-const guestMusicAwemeList = defineEndpoint({
+const guestMusicAwemeList = defineDouyinEndpoint({
 	name: "douyin.guestMusicAwemeList",
 	route: "/fetch_guest_music_aweme_list",
 	doc: {
@@ -8019,7 +5525,7 @@ const guestMusicAwemeList = defineEndpoint({
 * `extra.extract_item_id` 就是创建这条原声的那个作品。哪条优先由调用方按场景排。
 
 */
-const guestMusicInfo = defineEndpoint({
+const guestMusicInfo = defineDouyinEndpoint({
 	name: "douyin.guestMusicInfo",
 	route: "/fetch_guest_music_info",
 	doc: {
@@ -8049,7 +5555,7 @@ const guestMusicInfo = defineEndpoint({
 * 「设备参数 × 会话」的交叉校验，这条接口本来不需要身份。
 
 */
-const guestUserInfo = defineEndpoint({
+const guestUserInfo = defineDouyinEndpoint({
 	name: "douyin.guestUserInfo",
 	route: "/fetch_guest_user_info",
 	doc: {
@@ -8072,7 +5578,7 @@ const guestUserInfo = defineEndpoint({
 *
 * 行为与旧版一致：`getWorkDetail` GET + a_bogus 签名。
 */
-const imageAlbumWork = defineEndpoint({
+const imageAlbumWork = defineDouyinEndpoint({
 	name: "douyin.imageAlbumWork",
 	route: "/fetch_image_album_work",
 	doc: {
@@ -8084,7 +5590,7 @@ const imageAlbumWork = defineEndpoint({
 		method: "GET",
 		url: douyinApiUrls$1.getWorkDetail(p)
 	}),
-	sign: "a-bogus",
+	sign: douyinBogus(184),
 	retryOn: ["ANTIBOT_PAGE"],
 	retryFresh: true,
 	response: type()
@@ -8131,7 +5637,7 @@ const withDouyinReferer = (ctx, page) => {
 * 与旧版一致：`getLiveRoomInfo` GET + a_bogus 签名，
 * Referer 指向 `https://live.douyin.com/{web_rid}`。
 */
-const liveRoomInfo$1 = defineEndpoint({
+const liveRoomInfo$1 = defineDouyinEndpoint({
 	name: "douyin.liveRoomInfo",
 	route: "/fetch_user_live_videos",
 	doc: {
@@ -8150,7 +5656,7 @@ const liveRoomInfo$1 = defineEndpoint({
 			webRid: p.web_rid
 		})
 	}),
-	sign: "a-bogus",
+	sign: douyinBogus(116),
 	retryOn: ["ANTIBOT_PAGE"],
 	retryFresh: true,
 	response: type()
@@ -8166,7 +5672,7 @@ const liveRoomInfo$1 = defineEndpoint({
 * 映射条目 `DyLoginQrcode` 是本端点的**原始响应**，与 `DyPassportQrcode`
 * （登录状态机归一化后的形状，runtime/session 用）不是一回事。
 */
-const loginQrcode = defineEndpoint({
+const loginQrcode = defineDouyinEndpoint({
 	name: "douyin.loginQrcode",
 	route: "/fetch_login_qrcode",
 	doc: {
@@ -8178,7 +5684,7 @@ const loginQrcode = defineEndpoint({
 		method: "GET",
 		url: douyinApiUrls$1.getLoginQrcode(p)
 	}),
-	sign: "a-bogus",
+	sign: [aBogus$1(), secsdk()],
 	retryOn: ["ANTIBOT_PAGE"],
 	retryFresh: true,
 	response: type()
@@ -8190,7 +5696,7 @@ const loginQrcode = defineEndpoint({
 *
 * 与旧版一致：`getMusicInfo` GET + a_bogus 签名。
 */
-const musicInfo = defineEndpoint({
+const musicInfo = defineDouyinEndpoint({
 	name: "douyin.musicInfo",
 	route: "/fetch_music_work",
 	doc: {
@@ -8202,7 +5708,7 @@ const musicInfo = defineEndpoint({
 		method: "GET",
 		url: douyinApiUrls$1.getMusicInfo(p)
 	}),
-	sign: "a-bogus",
+	sign: douyinBogus(116),
 	retryOn: ["ANTIBOT_PAGE"],
 	retryFresh: true,
 	response: type()
@@ -8216,7 +5722,7 @@ const musicInfo = defineEndpoint({
 * 其余 4 个各占新路径。
 * 与旧版一致：`getWorkDetail` GET + a_bogus 签名，返回原始响应。
 */
-const parseWork = defineEndpoint({
+const parseWork = defineDouyinEndpoint({
 	name: "douyin.parseWork",
 	route: "/fetch_one_work",
 	doc: {
@@ -8228,7 +5734,7 @@ const parseWork = defineEndpoint({
 		method: "GET",
 		url: douyinApiUrls$1.getWorkDetail(p)
 	}),
-	sign: "a-bogus",
+	sign: douyinBogus(184),
 	retryOn: ["ANTIBOT_PAGE"],
 	retryFresh: true,
 	response: type()
@@ -8360,7 +5866,7 @@ const SEARCH_TYPE_FIELD = "__search_type";
 *
 * 与旧版一致：**不签名**。
 */
-const search = defineEndpoint({
+const search = defineDouyinEndpoint({
 	name: "douyin.search",
 	route: "/fetch_search_info",
 	doc: {
@@ -8397,7 +5903,7 @@ const search = defineEndpoint({
 			})
 		};
 	},
-	sign: false,
+	sign: [msToken(184)],
 	decode: (raw) => {
 		if (typeof raw !== "string") return raw;
 		const chunks = parseDouyinMultiJson(raw);
@@ -8417,50 +5923,47 @@ const search = defineEndpoint({
 	judge: searchJudge,
 	paginate: {
 		maxPageSize: 15,
+		page: type(),
 		items: (page) => {
-			const p = page;
-			if (Array.isArray(p.user_list)) return p.user_list;
-			return p.data ?? [];
+			if (Array.isArray(page.user_list)) return page.user_list;
+			return page.data ?? [];
 		},
 		hasMore: (page) => page.has_more !== 0,
 		nextParams: (params, page) => {
 			const p = page;
 			const nextSearchId = (typeof p.rid === "string" && p.rid.length > 0 ? p.rid : void 0) ?? (typeof p.log_pb?.impr_id === "string" ? p.log_pb.impr_id : void 0) ?? params.search_id;
 			const currentOffset = params.offset ?? 0;
-			const items = Array.isArray(page && page.user_list) ? page.user_list : page.data ?? [];
+			const items = Array.isArray(page.user_list) ? page.user_list : page.data ?? [];
 			const nextOffset = typeof p.cursor === "number" && p.cursor > currentOffset ? p.cursor : currentOffset + items.length;
 			return {
 				...params,
 				search_id: nextSearchId,
 				offset: nextOffset
 			};
+		},
+		merge: ({ lastPage, items }, params) => {
+			/**
+			* 判别值 = **响应形状** 与 **请求类型** 的组合，各管一半：
+			*
+			* - **user 只看结构**：成功路径上 user 必有 `user_list`、video / general 必有 `data`
+			*   （`searchJudge` 就是按这条判反爬的），所以 `user_list` 在不在是可靠信号。
+			* - **general 与 video 之间没有可靠结构信号**，只能取 `params.type`。
+			*   **反爬包装的形态跟逻辑类型不是一回事，不能当判据** —— 分页最后一页是单个
+			*   合法 JSON，会被解析成对象，按 wire body 形态判会把 general 误标成 video。
+			* - 两者矛盾时（请求 user、回的却是 data 形状）按 `general` 记：「不是 user」比
+			*   「请求说是 user」更硬。
+			*/
+			const requested = params.type ?? "general";
+			const searchType = Array.isArray(lastPage.user_list) ? "user" : requested === "user" ? "general" : requested;
+			const out = {
+				...lastPage,
+				[SEARCH_TYPE_FIELD]: searchType
+			};
+			if (Array.isArray(lastPage.user_list)) out.user_list = items;
+			else out.data = items;
+			return out;
 		}
 	},
-	normalize: (decoded, params) => {
-		const { lastPage, items } = decoded;
-		const page = lastPage;
-		/**
-		* 判别值 = **响应形状** 与 **请求类型** 的组合，各管一半：
-		*
-		* - **user 只看结构**：成功路径上 user 必有 `user_list`、video / general 必有 `data`
-		*   （`searchJudge` 就是按这条判反爬的），所以 `user_list` 在不在是可靠信号。
-		* - **general 与 video 之间没有可靠结构信号**，只能取 `params.type`。
-		*   **反爬包装的形态跟逻辑类型不是一回事，不能当判据** —— 分页最后一页是单个
-		*   合法 JSON，会被解析成对象，按 wire body 形态判会把 general 误标成 video。
-		* - 两者矛盾时（请求 user、回的却是 data 形状）按 `general` 记：「不是 user」比
-		*   「请求说是 user」更硬 —— 记成 user 会让下游收窄到「有 `user_list` 的那一支」，
-		*   而那恰恰是它没有的东西。
-		*/
-		const requested = params.type ?? "general";
-		const searchType = Array.isArray(page?.user_list) ? "user" : requested === "user" ? "general" : requested;
-		const out = {
-			...page ?? {},
-			[SEARCH_TYPE_FIELD]: searchType
-		};
-		if (Array.isArray(page?.user_list)) out.user_list = items;
-		else out.data = items;
-		return out;
-	},
 	response: type()
 });
 //#endregion
@@ -8470,7 +5973,7 @@ const search = defineEndpoint({
 *
 * 行为与旧版一致：`getWorkDetail` GET + a_bogus 签名。
 */
-const slidesWork = defineEndpoint({
+const slidesWork = defineDouyinEndpoint({
 	name: "douyin.slidesWork",
 	route: "/fetch_slides_work",
 	doc: {
@@ -8482,7 +5985,7 @@ const slidesWork = defineEndpoint({
 		method: "GET",
 		url: douyinApiUrls$1.getWorkDetail(p)
 	}),
-	sign: "a-bogus",
+	sign: douyinBogus(184),
 	retryOn: ["ANTIBOT_PAGE"],
 	retryFresh: true,
 	response: type()
@@ -8495,7 +5998,7 @@ const slidesWork = defineEndpoint({
 * 与旧版一致：`getSuggestWords` GET + a_bogus 签名，
 * Referer 指向 `https://www.douyin.com/search/{query}`。
 */
-const suggestWords = defineEndpoint({
+const suggestWords = defineDouyinEndpoint({
 	name: "douyin.suggestWords",
 	route: "/fetch_suggest_words",
 	doc: {
@@ -8511,7 +6014,7 @@ const suggestWords = defineEndpoint({
 			query: p.query
 		})
 	}),
-	sign: "a-bogus",
+	sign: douyinBogus(184),
 	retryOn: ["ANTIBOT_PAGE"],
 	retryFresh: true,
 	response: type()
@@ -8523,7 +6026,7 @@ const suggestWords = defineEndpoint({
 *
 * 行为与旧版一致：`getWorkDetail` GET + a_bogus 签名。
 */
-const textWork = defineEndpoint({
+const textWork = defineDouyinEndpoint({
 	name: "douyin.textWork",
 	route: "/fetch_text_work",
 	doc: {
@@ -8535,7 +6038,7 @@ const textWork = defineEndpoint({
 		method: "GET",
 		url: douyinApiUrls$1.getWorkDetail(p)
 	}),
-	sign: "a-bogus",
+	sign: douyinBogus(184),
 	retryOn: ["ANTIBOT_PAGE"],
 	retryFresh: true,
 	response: type()
@@ -8548,7 +6051,7 @@ const textWork = defineEndpoint({
 * 与旧版一致：`getUserFavoriteList` GET + a_bogus 签名，
 * 游标是 `max_cursor`（`has_more === 1` 继续），Referer 指向用户主页。
 */
-const userFavoriteList = defineEndpoint({
+const userFavoriteList = defineDouyinEndpoint({
 	name: "douyin.userFavoriteList",
 	route: "/fetch_user_favorite_list",
 	doc: {
@@ -8568,7 +6071,7 @@ const userFavoriteList = defineEndpoint({
 			secUid: p.sec_uid
 		})
 	}),
-	sign: "a-bogus",
+	sign: douyinBogus(184),
 	retryOn: ["ANTIBOT_PAGE"],
 	retryFresh: true,
 	paginate: {
@@ -8578,14 +6081,11 @@ const userFavoriteList = defineEndpoint({
 		nextParams: (params, page) => ({
 			...params,
 			max_cursor: page.max_cursor?.toString() ?? "0"
-		})
-	},
-	normalize: (decoded) => {
-		const { lastPage, items } = decoded;
-		return {
-			...lastPage ?? {},
+		}),
+		merge: ({ lastPage, items }) => ({
+			...lastPage,
 			aweme_list: items
-		};
+		})
 	},
 	response: type()
 });
@@ -8597,7 +6097,7 @@ const userFavoriteList = defineEndpoint({
 * 与旧版一致：`getUserProfile` GET + a_bogus 签名，
 * Referer 指向 `https://www.douyin.com/user/{sec_uid}`（由 {@link withDouyinReferer} 注入）。
 */
-const userProfile$3 = defineEndpoint({
+const userProfile$3 = defineDouyinEndpoint({
 	name: "douyin.userProfile",
 	route: "/fetch_user_info",
 	doc: {
@@ -8613,7 +6113,7 @@ const userProfile$3 = defineEndpoint({
 			secUid: p.sec_uid
 		})
 	}),
-	sign: "a-bogus",
+	sign: douyinBogus(184),
 	retryOn: ["ANTIBOT_PAGE"],
 	retryFresh: true,
 	response: type()
@@ -8627,7 +6127,7 @@ const userProfile$3 = defineEndpoint({
 * 签名，游标是 `max_cursor`。**`hasMore` 判的是 `has_more === true`（布尔）**，
 * 与 userVideoList / userFavoriteList 的 `=== 1` 不同。
 */
-const userRecommendList = defineEndpoint({
+const userRecommendList = defineDouyinEndpoint({
 	name: "douyin.userRecommendList",
 	route: "/fetch_user_recommend_list",
 	doc: {
@@ -8647,7 +6147,7 @@ const userRecommendList = defineEndpoint({
 			secUid: p.sec_uid
 		})
 	}),
-	sign: "a-bogus",
+	sign: douyinBogus(184),
 	retryOn: ["ANTIBOT_PAGE"],
 	retryFresh: true,
 	paginate: {
@@ -8657,14 +6157,11 @@ const userRecommendList = defineEndpoint({
 		nextParams: (params, page) => ({
 			...params,
 			max_cursor: page.max_cursor?.toString() ?? "0"
-		})
-	},
-	normalize: (decoded) => {
-		const { lastPage, items } = decoded;
-		return {
-			...lastPage ?? {},
+		}),
+		merge: ({ lastPage, items }) => ({
+			...lastPage,
 			aweme_list: items
-		};
+		})
 	},
 	response: type()
 });
@@ -8677,7 +6174,7 @@ const userRecommendList = defineEndpoint({
 * 游标是 `max_cursor`（字符串，`has_more === 1` 继续），Referer 指向用户主页。
 * 最终形状 `{ ...最后一页, aweme_list }`。
 */
-const userVideoList = defineEndpoint({
+const userVideoList = defineDouyinEndpoint({
 	name: "douyin.userVideoList",
 	route: "/fetch_user_post_videos",
 	doc: {
@@ -8697,7 +6194,7 @@ const userVideoList = defineEndpoint({
 			secUid: p.sec_uid
 		})
 	}),
-	sign: "a-bogus",
+	sign: douyinBogus(184),
 	retryOn: ["ANTIBOT_PAGE"],
 	retryFresh: true,
 	paginate: {
@@ -8707,14 +6204,11 @@ const userVideoList = defineEndpoint({
 		nextParams: (params, page) => ({
 			...params,
 			max_cursor: page.max_cursor?.toString() ?? "0"
-		})
-	},
-	normalize: (decoded) => {
-		const { lastPage, items } = decoded;
-		return {
-			...lastPage ?? {},
+		}),
+		merge: ({ lastPage, items }) => ({
+			...lastPage,
 			aweme_list: items
-		};
+		})
 	},
 	response: type()
 });
@@ -8731,7 +6225,7 @@ const userVideoList = defineEndpoint({
 */
 const douyinRegistry = {
 	parseWork,
-	videoWork: defineEndpoint({
+	videoWork: defineDouyinEndpoint({
 		name: "douyin.videoWork",
 		route: "/fetch_video_work",
 		doc: {
@@ -8743,7 +6237,7 @@ const douyinRegistry = {
 			method: "GET",
 			url: douyinApiUrls$1.getWorkDetail(p)
 		}),
-		sign: "a-bogus",
+		sign: douyinBogus(184),
 		retryOn: ["ANTIBOT_PAGE"],
 		retryFresh: true,
 		response: type(),
@@ -10979,6 +8473,18 @@ const kuaishouDidState = createKuaishouDidState();
 */
 const kuaishouDidPrepare = async (ctx) => ({ cookie: buildKuaishouDidCookie(kuaishouDidState.getDid(), ctx.cookie) });
 //#endregion
+//#region src/platforms/kuaishou/endpoints/define.ts
+/**
+* 快手端点声明。
+*
+* 就是 {@link defineEndpoint} 绑定了快手签名器名联合 {@link KuaishouSignerName}：
+* `sign` 的字符串分支被收窄成 `'hxfalcon'`，写错名字编译期即报错，不必等运行时
+* 查表失败。运行时仍是恒等函数，其余行为与通用 `defineEndpoint` 完全一致。
+* @param def - 端点声明（`sign` 的名字受快手签名器表约束）
+* @returns 原样返回 `def`，带上推导好的具体类型
+*/
+const defineKuaishouEndpoint = (def) => defineEndpoint(def);
+//#endregion
 //#region src/platforms/kuaishou/endpoints/comments.ts
 /**
 * 获取作品评论（H5 `photo/comment/list`，POST + 声明式翻页）。
@@ -10998,7 +8504,7 @@ const kuaishouDidPrepare = async (ctx) => ({ cookie: buildKuaishouDidCookie(kuai
 * 翻页：调用方传 `number` 指定目标条数，`pcursor` 由 `paginate` 声明管理，
 * 不暴露为自由参数。
 */
-const comments = defineEndpoint({
+const comments = defineKuaishouEndpoint({
 	name: "kuaishou.comments",
 	route: "/fetch_work_comments",
 	doc: {
@@ -11009,7 +8515,7 @@ const comments = defineEndpoint({
 		photoId: zod.string().min(1, { error: "photoId 不能为空" }).describe("作品 ID"),
 		number: zod.coerce.number().int().min(1).max(500).optional().describe("目标条数，默认一页")
 	}),
-	sign: "hxfalcon",
+	sign: [hxfalcon()],
 	prepare: kuaishouDidPrepare,
 	build: (p) => {
 		const req = kuaishouApiUrls$1.comments(p);
@@ -11031,14 +8537,11 @@ const comments = defineEndpoint({
 		nextParams: (params, page) => ({
 			...params,
 			pcursor: page.pcursor ?? ""
-		})
-	},
-	normalize: (decoded) => {
-		const { lastPage, items } = decoded;
-		return {
-			...lastPage ?? {},
+		}),
+		merge: ({ lastPage, items }) => ({
+			...lastPage,
 			rootComments: items
-		};
+		})
 	},
 	response: type()
 });
@@ -11114,7 +8617,7 @@ const resolveScanRange = (p) => {
 * 同许可）：https://github.com/OduckO —— `src/platform/kuaishou/danmaku.ts` 与
 * `TODO.md:140-164`。
 */
-const danmakuList = defineEndpoint({
+const danmakuList = defineKuaishouEndpoint({
 	name: "kuaishou.danmakuList",
 	route: "/fetch_danmaku_list",
 	doc: {
@@ -11176,39 +8679,38 @@ const danmakuList = defineEndpoint({
 	retryOn: ["PLATFORM_UNAVAILABLE"],
 	partial: "tolerate",
 	/**
-	* 合并多个窗口：去重 → 按时间升序 → 放回最后一个窗口的原位。
+	* 合并多个窗口：去重 → 按时间升序 → 写回整体扫描范围。
+	*
+	* 这不是「归一化」，只是把分段拿到的条目放回原位（与 `comments` 的跨页累积同语义），
+	* 所以返回类型仍描述真实 GraphQL 形状；只有 `positionFromInclude` / `positionToExclude`
+	* 被改写成本次**整体**扫描范围（单窗口时就等于那一窗的值）。
 	*
-	* 这不是「归一化」，只是把分段拿到的条目放回它本来的位置（与 `comments` 的跨页累积
-	* 同一个语义），所以返回类型仍然描述真实的 GraphQL 形状。只有
-	* `positionFromInclude` / `positionToExclude` 被改写成本次**整体**扫描范围 ——
-	* 单窗口调用时它们就等于那一窗的值。
-	* @param decoded - 每个窗口 decode 之后的值（失败窗口是 `undefined`）
+	* 走 typed 的 aggregate（而非 normalize）：`parts` 已收窄成 `Array<…Response | undefined>`、
+	* `head` 恒有值，去重 / 排序 / `...head` 全程无断言。
+	* @param value - 各窗口累积值（`parts` 含失败窗口的 undefined，`head` 恒有值）
 	* @param params - 校验后的参数
 	* @returns 合并后的响应
 	*/
-	normalize: (decoded, params) => {
-		const windows = decoded;
+	aggregate: ({ parts, head }, params) => {
 		const { from, to } = resolveScanRange(params);
 		const merged = [];
 		const seen = /* @__PURE__ */ new Set();
-		for (const win of windows) {
+		for (const win of parts) {
 			const node = win?.data?.visionDanmaku;
 			if (!node) continue;
-			for (const row of node.danmakus ?? []) {
-				const key = row.id === void 0 || row.id === null ? `${row.position ?? 0}:${row.body ?? ""}` : String(row.id);
-				if (seen.has(key)) continue;
-				seen.add(key);
+			for (const row of node.danmakus) {
+				if (seen.has(row.id)) continue;
+				seen.add(row.id);
 				merged.push(row);
 			}
 		}
-		merged.sort((a, b) => (a.position ?? 0) - (b.position ?? 0));
-		const firstBody = windows.find((win) => Boolean(win?.data?.visionDanmaku));
+		merged.sort((a, b) => a.position - b.position);
 		return {
-			...firstBody ?? {},
+			...head,
 			data: {
-				...firstBody?.data ?? {},
+				...head.data,
 				visionDanmaku: {
-					...firstBody?.data?.visionDanmaku ?? {},
+					...head.data.visionDanmaku,
 					positionFromInclude: from,
 					positionToExclude: to,
 					danmakus: merged
@@ -11230,7 +8732,7 @@ const danmakuList = defineEndpoint({
 * 也正因为它零凭证，它是「无 cookie 能不能取到数」的**基线探针** ——
 * 这条通而 videoWork 不通，问题就在签名或 did，不在网络环境。
 */
-const emojiList$2 = defineEndpoint({
+const emojiList$2 = defineKuaishouEndpoint({
 	name: "kuaishou.emojiList",
 	route: "/fetch_emoji_list",
 	doc: {
@@ -11261,7 +8763,7 @@ const emojiList$2 = defineEndpoint({
 * 返回结构直接包含 `liveStream` / `author` / `gameInfo` / `noticeList` 等。
 * 响应判定用快手 judge（`result=1` 才进 data）。
 */
-const liveRoomInfo = defineEndpoint({
+const liveRoomInfo = defineKuaishouEndpoint({
 	name: "kuaishou.liveRoomInfo",
 	route: "/fetch_live_room_info",
 	doc: {
@@ -11269,7 +8771,7 @@ const liveRoomInfo = defineEndpoint({
 		description: "取直播间聚合信息（直播流、主播、公告等）；只看直播间时比 `userProfile` 轻。"
 	},
 	params: zod.object({ principalId: zod.string().min(1, { error: "principalId 不能为空" }).describe("用户 ID") }),
-	sign: "hxfalcon",
+	sign: [hxfalcon()],
 	build: (p) => {
 		return {
 			method: "POST",
@@ -11511,7 +9013,7 @@ const mapLiveDetailToUserProfileLiveInfo = (detailData, author) => {
 * 到空值 —— 这正是「部分失败」语义：build 返回 12 个请求并发发出，
 * 失败分片在 normalize 里留空，**全部分片都失败时仍返回失败信封**。
 */
-const userProfile$2 = defineEndpoint({
+const userProfile$2 = defineKuaishouEndpoint({
 	name: "kuaishou.userProfile",
 	route: "/fetch_user_profile",
 	doc: {
@@ -11519,7 +9021,7 @@ const userProfile$2 = defineEndpoint({
 		description: "取用户主页聚合信息（资料、作品列表、直播间等）。部分数据取不到时留空，不整体失败。"
 	},
 	params: zod.object({ principalId: zod.string().min(1, { error: "principalId 不能为空" }).describe("用户 ID") }),
-	sign: "hxfalcon",
+	sign: [hxfalcon()],
 	build: (p) => {
 		const principalId = p.principalId;
 		const refererPath = `profile/${encodeURIComponent(principalId)}`;
@@ -11611,7 +9113,7 @@ const userProfile$2 = defineEndpoint({
 * `profilePublic` 的查询参数（`userWorkList` 是 `profilePublic` 的
 * 领域化封装）。
 */
-const userWorkList = defineEndpoint({
+const userWorkList = defineKuaishouEndpoint({
 	name: "kuaishou.userWorkList",
 	route: "/fetch_user_work_list",
 	doc: {
@@ -11622,7 +9124,7 @@ const userWorkList = defineEndpoint({
 		principalId: zod.string().min(1, { error: "principalId 不能为空" }).describe("用户 ID"),
 		number: zod.coerce.number().int().min(1).max(500).optional().describe("目标条数，默认 12")
 	}),
-	sign: "hxfalcon",
+	sign: [hxfalcon()],
 	build: (p) => {
 		return {
 			method: "POST",
@@ -11643,19 +9145,17 @@ const userWorkList = defineEndpoint({
 		nextParams: (params, page) => ({
 			...params,
 			pcursor: page.data?.pcursor ?? ""
-		})
-	},
-	normalize: (decoded, params) => {
-		const { lastPage, items } = decoded;
-		const page = lastPage;
-		const pcursor = page?.data?.pcursor;
-		return {
-			principalId: params.principalId,
-			list: items,
-			pcursor: typeof pcursor === "string" ? pcursor : "",
-			hasMore: typeof pcursor === "string" && pcursor.length > 0,
-			result: page?.data?.result ?? 1
-		};
+		}),
+		merge: ({ lastPage, items }, params) => {
+			const pcursor = lastPage.data?.pcursor;
+			return {
+				principalId: params.principalId,
+				list: items,
+				pcursor: typeof pcursor === "string" ? pcursor : "",
+				hasMore: typeof pcursor === "string" && pcursor.length > 0,
+				result: lastPage.data?.result ?? 1
+			};
+		}
 	},
 	response: type()
 });
@@ -11676,7 +9176,7 @@ const userWorkList = defineEndpoint({
 * 第 8 条 `/fetch_danmaku_list` 是弹幕。它**完全免鉴权**（不签名、不要 cookie）。
 */
 const kuaishouRegistry = {
-	videoWork: defineEndpoint({
+	videoWork: defineKuaishouEndpoint({
 		name: "kuaishou.videoWork",
 		route: "/fetch_one_work",
 		doc: {
@@ -11696,7 +9196,7 @@ const kuaishouRegistry = {
 		},
 		response: type()
 	}),
-	videoWorkFull: defineEndpoint({
+	videoWorkFull: defineKuaishouEndpoint({
 		name: "kuaishou.videoWorkFull",
 		route: "/fetch_one_work_full",
 		doc: {
@@ -11704,7 +9204,7 @@ const kuaishouRegistry = {
 			description: "日常取作品信息请用 `videoWork`；这条是唯一可能返回图集预渲染地址与同类推荐的通道。"
 		},
 		params: zod.object({ photoId: zod.string().min(1, { error: "photoId 不能为空" }).describe("作品 ID") }),
-		sign: "hxfalcon",
+		sign: [hxfalcon()],
 		prepare: kuaishouDidPrepare,
 		build: (p) => {
 			const req = kuaishouApiUrls$1.videoWorkFull(p);
@@ -12200,6 +9700,18 @@ const xiaohongshuApiUrls$1 = {
 	searchNotes: searchNotes$1
 };
 //#endregion
+//#region src/platforms/xiaohongshu/endpoints/define.ts
+/**
+* 小红书端点声明。
+*
+* 就是 {@link defineEndpoint} 绑定了小红书签名器名联合 {@link XiaohongshuSignerName}：
+* `sign` 的字符串分支被收窄成小红书那几个 `xhs-*` 名字，写错名字编译期即报错，不必
+* 等运行时查表失败。运行时仍是恒等函数，其余行为与通用 `defineEndpoint` 完全一致。
+* @param def - 端点声明（`sign` 的名字受小红书签名器表约束）
+* @returns 原样返回 `def`，带上推导好的具体类型
+*/
+const defineXiaohongshuEndpoint = (def) => defineEndpoint(def);
+//#endregion
 //#region src/platforms/xiaohongshu/endpoints/emojiList.ts
 /**
 * 表情列表（GET，无参数）。
@@ -12207,7 +9719,7 @@ const xiaohongshuApiUrls$1 = {
 * 没有业务参数 —— 用空对象 schema（`zod.object({})`），
 * fetcher 方法可以不传 options。
 */
-const emojiList = defineEndpoint({
+const emojiList = defineXiaohongshuEndpoint({
 	name: "xiaohongshu.emojiList",
 	route: "/fetch_emoji_list",
 	doc: {
@@ -12223,7 +9735,7 @@ const emojiList = defineEndpoint({
 			signPath: apiPath
 		};
 	},
-	sign: "xhs-get",
+	sign: [xs("get", "xys")],
 	response: type()
 });
 //#endregion
@@ -12238,7 +9750,7 @@ const emojiList = defineEndpoint({
 * 进 trace）。已有 a1 直接跳过 —— guest cookie 流程有真实网络开销，
 * 不能每次调用都重跑。
 */
-const homeFeed = defineEndpoint({
+const homeFeed = defineXiaohongshuEndpoint({
 	name: "xiaohongshu.homeFeed",
 	route: "/fetch_home_feed",
 	doc: {
@@ -12266,7 +9778,7 @@ const homeFeed = defineEndpoint({
 			signPath: apiPath
 		};
 	},
-	sign: "xhs-post-rap",
+	sign: [xs("post", "xys"), rap()],
 	response: type()
 });
 //#endregion
@@ -12281,7 +9793,7 @@ const homeFeed = defineEndpoint({
 * `data.has_more` 是 boolean，与抖音的 `has_more === 1` 不同 ——
 * 差异收敛在 `paginate` 声明里，管线不感知。
 */
-const noteComments = defineEndpoint({
+const noteComments = defineXiaohongshuEndpoint({
 	name: "xiaohongshu.noteComments",
 	route: "/fetch_note_comments",
 	doc: {
@@ -12302,7 +9814,7 @@ const noteComments = defineEndpoint({
 			extra: { signParams }
 		};
 	},
-	sign: "xhs-get-trace",
+	sign: [xs("get", "xys"), traceId()],
 	paginate: {
 		maxPageSize: 50,
 		items: (page) => page.data?.comments ?? [],
@@ -12310,18 +9822,14 @@ const noteComments = defineEndpoint({
 		nextParams: (params, page) => ({
 			...params,
 			cursor: page.data?.cursor ?? ""
-		})
-	},
-	normalize: (decoded) => {
-		const { lastPage, items } = decoded;
-		const page = lastPage;
-		return {
-			...page ?? {},
+		}),
+		merge: ({ lastPage, items }) => ({
+			...lastPage,
 			data: {
-				...page?.data ?? {},
+				...lastPage.data,
 				comments: items
 			}
-		};
+		})
 	},
 	response: type()
 });
@@ -12332,7 +9840,7 @@ const noteComments = defineEndpoint({
 *
 * `note_id` 与 `xsec_token` 都要求 `min(1)`：空字符串会发出一个必败的请求。
 */
-const noteDetail = defineEndpoint({
+const noteDetail = defineXiaohongshuEndpoint({
 	name: "xiaohongshu.noteDetail",
 	route: "/fetch_one_note",
 	doc: {
@@ -12352,7 +9860,7 @@ const noteDetail = defineEndpoint({
 			signPath: apiPath
 		};
 	},
-	sign: "xhs-post-rap",
+	sign: [xs("post", "xys"), rap()],
 	response: type()
 });
 //#endregion
@@ -12363,7 +9871,7 @@ const noteDetail = defineEndpoint({
 * `search_id` 是每次搜索的随机 id：在 `build` 里显式生成并传给
 * `api.searchNotes(data, searchId)`（api 保持纯函数，随机源归 `sign/`）。
 */
-const searchNotes = defineEndpoint({
+const searchNotes = defineXiaohongshuEndpoint({
 	name: "xiaohongshu.searchNotes",
 	route: "/fetch_search_notes",
 	doc: {
@@ -12384,7 +9892,7 @@ const searchNotes = defineEndpoint({
 			signPath: apiPath
 		};
 	},
-	sign: "xhs-post-rap",
+	sign: [xs("post", "xys"), rap()],
 	response: type()
 });
 //#endregion
@@ -12396,7 +9904,7 @@ const searchNotes = defineEndpoint({
 * XYS_ 签名会被平台以 HTTP 406 拒绝，因此用 `'xhs-get-xyw-trace'`
 * （XYW_ GET 签名 + traceid），而不是给所有 GET 都换。
 */
-const userNoteList = defineEndpoint({
+const userNoteList = defineXiaohongshuEndpoint({
 	name: "xiaohongshu.userNoteList",
 	route: "/fetch_user_notes",
 	doc: {
@@ -12418,7 +9926,7 @@ const userNoteList = defineEndpoint({
 			extra: { signParams }
 		};
 	},
-	sign: "xhs-get-xyw-trace",
+	sign: [xs("get", "xyw"), traceId()],
 	response: type()
 });
 //#endregion
@@ -12435,7 +9943,7 @@ const xiaohongshuRegistry = {
 	homeFeed,
 	noteDetail,
 	noteComments,
-	userProfile: defineEndpoint({
+	userProfile: defineXiaohongshuEndpoint({
 		name: "xiaohongshu.userProfile",
 		route: "/fetch_user_profile",
 		doc: {
@@ -12452,7 +9960,7 @@ const xiaohongshuRegistry = {
 				responseType: "text"
 			};
 		},
-		sign: "xhs-get",
+		sign: [xs("get", "xys")],
 		decode: (raw) => {
 			if (typeof raw !== "string") return raw;
 			const match = raw.match(/<script>window\.__INITIAL_STATE__=(.+)<\/script>/m);
@@ -54014,7 +51522,7 @@ const buildOpenApiSpec = (options = {}) => {
 		openapi: "3.1.0",
 		info: {
 			title: "amagi HTTP API",
-			version: options.version ?? "7.0.0-beta.4",
+			version: options.version ?? "7.0.0-beta.6",
 			description: [
 				"由端点注册表派生的规范 —— 手写的那份已经漂移，这份不会（`gen-openapi --check` 进 CI）。",
 				"",
@@ -54070,38 +51578,12 @@ const mountOpenApiSpec = (app) => {
 };
 //#endregion
 //#region src/client/request/profile.ts
-/**
-* 抖音：重抽 URL 里已有的 `msToken`。
-*
-* Argus 按整组 token 判定，只换 `a_bogus` 不够。`msToken` 是调用方的 URL
-* 构造器写进去的（这一层**不补**参数），所以能换的只有「URL 里本来就有」的
-* 那一种情况 —— 长度保持原样（作品详情 184、其余 116），因为长度本身就是
-* 参数的一部分。
-* @param spec - 上一次用的请求描述
-* @returns 换过 msToken 的请求描述；没有可换的就原样返回
-*/
-const refreshDouyinMsToken = (spec) => {
-	let url;
-	try {
-		url = new URL(spec.url);
-	} catch {
-		return spec;
-	}
-	const current = url.searchParams.get("msToken");
-	if (current === null || current === "") return spec;
-	url.searchParams.set("msToken", douyinSign$1.Mstoken(current.length));
-	return {
-		...spec,
-		url: url.toString()
-	};
-};
 /** 平台档案表。四个平台必须齐全 —— 少一项不会编译报错，会静默不签名 */
 const PROFILES = {
 	douyin: {
 		defaultSign: "a-bogus",
 		retryOn: ["ANTIBOT_PAGE"],
-		retryFresh: true,
-		refresh: refreshDouyinMsToken
+		retryFresh: true
 	},
 	bilibili: {
 		defaultSign: false,
@@ -54235,10 +51717,15 @@ const buildRequestSpec = (config, url, amagi) => ({
 /**
 * 现场合成一个一次性的端点声明。
 *
-* `build` 的写法值得说明：`execute` 在 `retryFresh` 重试时会把 `build` **再调一次**
-* （见 `runtime/execute.ts` 的 `rebuildAt`），而我们要的是「第一次给原 spec、
-* 之后每次给刷新过的 spec」。所以这里返回当前值的同时把下一个算好 ——
-* 不用计数器，也就没有「第几次调用」这种隐藏状态。
+* `build` 恒返回同一个 `spec`，**这不等于「重试会原样重放」**：`execute` 在 `retryFresh`
+* 重试时会把 `build` 再调一次、**并紧接着重新签名**（见 `runtime/execute.ts` 的
+* `rebuildAt`），换参数是后者干的 —— 抖音的 `msToken` / `a_bogus` 都出自签名 step，
+* 每次签名现生成，所以重试拿到的是一整套新 token。
+*
+* 这里曾经有一个「返回当前值的同时把下一个算好」的双缓冲写法，配合平台档案的
+* `refresh` 钩子重抽 URL 里的 `msToken`。msToken 下沉到签名 step 之后那个钩子
+* 恒为无操作（URL 里本来就没有它可抽），连同这套机制一起删了 —— 裸请求的 `spec`
+* 是调用方给的、本身没有「下一次该长什么样」这种状态。
 * @param platform - 平台
 * @param spec - 本次调用的请求描述
 * @param method - HTTP 方法（小红书按它推默认签名器）
@@ -54247,16 +51734,11 @@ const buildRequestSpec = (config, url, amagi) => ({
 */
 const makeRequestDef = (platform, spec, method, amagi) => {
 	const profile = requestProfileOf(platform);
-	let current = spec;
 	return defineEndpoint({
 		name: `${platform}.request`,
 		route: REQUEST_ROUTE,
 		params: zod.object({}),
-		build: () => {
-			const out = current;
-			current = profile.refresh ? profile.refresh(spec) : spec;
-			return out;
-		},
+		build: () => spec,
 		sign: amagi.sign ?? resolveDefaultSign(profile, method),
 		...profile.retryOn === void 0 ? {} : { retryOn: profile.retryOn },
 		...profile.retryFresh === void 0 ? {} : { retryFresh: profile.retryFresh }
@@ -54597,17 +52079,6 @@ const createStaticFetcher = (platform, registry) => {
 * ```
 */
 const bilibiliFetcher = createStaticFetcher("bilibili", bilibiliRegistry);
-/**
-* 创建绑定了 Cookie 和请求配置的B站 Fetcher
-* @param cookie - B站 Cookie
-* @param requestConfig - 请求配置 (可选)
-* @returns 绑定了 Cookie 的 Fetcher 对象，调用时无需传递 cookie
-* @example
-* ```typescript
-* const fetcher = createBoundBilibiliFetcher('your_cookie')
-* const result = await fetcher.fetchVideoInfo({ bvid: 'BV1xx411c7mD' })
-* ```
-*/
 const createBoundBilibiliFetcher = (cookie, requestConfig) => createFetcherFromRegistry("bilibili", bilibiliRegistry, makeClientCtx("bilibili", cookie, requestConfig, "bound-bilibili"));
 //#endregion
 //#region src/model/fetchers/douyin/auth.ts
@@ -54855,17 +52326,6 @@ const createBoundDouyinFetcher = (cookie, requestConfig) => createFetcherFromReg
 * ```
 */
 const kuaishouFetcher = createStaticFetcher("kuaishou", kuaishouRegistry);
-/**
-* 创建绑定了 Cookie 和请求配置的快手 Fetcher
-* @param cookie - 快手 Cookie
-* @param requestConfig - 请求配置 (可选)
-* @returns 绑定了 Cookie 的 Fetcher 对象，调用时无需传递 cookie
-* @example
-* ```typescript
-* const fetcher = createBoundKuaishouFetcher('your_cookie')
-* const result = await fetcher.fetchVideoWork({ photoId: '3x123456789' })
-* ```
-*/
 const createBoundKuaishouFetcher = (cookie, requestConfig) => createFetcherFromRegistry("kuaishou", kuaishouRegistry, makeClientCtx("kuaishou", cookie, requestConfig, "bound-kuaishou"));
 //#endregion
 //#region src/model/fetchers/xiaohongshu/index.ts
@@ -54888,17 +52348,6 @@ const createBoundKuaishouFetcher = (cookie, requestConfig) => createFetcherFromR
 * ```
 */
 const xiaohongshuFetcher = createStaticFetcher("xiaohongshu", xiaohongshuRegistry);
-/**
-* 创建绑定了 Cookie 和请求配置的小红书 Fetcher
-* @param cookie - 小红书 Cookie
-* @param requestConfig - 请求配置 (可选)
-* @returns 绑定了 Cookie 的 Fetcher 对象，调用时无需传递 cookie
-* @example
-* ```typescript
-* const fetcher = createBoundXiaohongshuFetcher('your_cookie')
-* const result = await fetcher.fetchNoteDetail({ note_id: 'n1', xsec_token: 'tk' })
-* ```
-*/
 const createBoundXiaohongshuFetcher = (cookie, requestConfig) => createFetcherFromRegistry("xiaohongshu", xiaohongshuRegistry, makeClientCtx("xiaohongshu", cookie, requestConfig, "bound-xiaohongshu"));
 //#endregion
 //#region src/utils/errors.ts
@@ -56837,7 +54286,7 @@ let DynamicType = /* @__PURE__ */ function(DynamicType) {
 * 构建后使用 __VERSION__，开发环境从 package.json 读取
 */
 const getVersion = () => {
-	return "7.0.0-beta.4";
+	return "7.0.0-beta.6";
 };
 const VERSION = getVersion();
 /**