@ikenxuan/amagi 7.0.0-beta.5 → 7.0.0-beta.7

package/dist/{src-DixrwqqA.cjs → src-CNU3-zoM.cjs}

@@ -1,20 +1,92 @@
 const require_rolldown_runtime = require("./rolldown-runtime-C0BPl7ul.cjs");
+const require_steps = require("./steps-BO8NYQHx.cjs");
 const require_tokens = require("./tokens-DHKAuPVW.cjs");
-let node_url = require("node:url");
-node_url = require_rolldown_runtime.__toESM(node_url, 1);
+require("node:url");
 let express = require("express");
 express = require_rolldown_runtime.__toESM(express, 1);
 let zod = require("zod");
 zod = require_rolldown_runtime.__toESM(zod, 1);
+let node_crypto = require("node:crypto");
+node_crypto = require_rolldown_runtime.__toESM(node_crypto, 1);
 let protobufjs = require("protobufjs");
 protobufjs = require_rolldown_runtime.__toESM(protobufjs, 1);
 let axios = require("axios");
 axios = require_rolldown_runtime.__toESM(axios, 1);
 let node_events = require("node:events");
-let node_crypto = require("node:crypto");
-node_crypto = require_rolldown_runtime.__toESM(node_crypto, 1);
 let _ikenxuan_xhshow_ts = require("@ikenxuan/xhshow-ts");
 //#region src/platforms/bilibili/api.ts
+/**
+* B站评论区类型代码（`comments` / `commentReplies` 的 `type` 参数）。
+*
+* 完整对照表（部分 oid 含义官方未明确，转写自 bilibili-API-collect）：
+*
+* | 代码 | 评论区类型 | oid 的意义 |
+* | --- | --- | --- |
+* | 1 | 视频稿件 | 稿件 avid |
+* | 2 | 话题 | 话题 id |
+* | 4 | 活动 | 活动 id |
+* | 5 | 小视频 | 小视频 id |
+* | 6 | 小黑屋封禁信息 | 封禁公示 id |
+* | 7 | 公告信息 | 公告 id |
+* | 8 | 直播活动 | 直播间 id |
+* | 9 | 活动稿件 | (?) |
+* | 10 | 直播公告 | (?) |
+* | 11 | 相簿（图片动态） | 相簿 id |
+* | 12 | 专栏 | 专栏 cvid |
+* | 13 | 票务 | (?) |
+* | 14 | 音频 | 音频 auid |
+* | 15 | 风纪委员会 | 众裁项目 id |
+* | 16 | 点评 | (?) |
+* | 17 | 动态（纯文字动态&分享） | 动态 id |
+* | 18 | 播单 | (?) |
+* | 19 | 音乐播单 | (?) |
+* | 20 | 漫画 | (?) |
+* | 21 | 漫画 | (?) |
+* | 22 | 漫画 | 漫画 mcid |
+* | 33 | 课程 | 课程 epid |
+*
+* @see https://github.com/SocialSisterYi/bilibili-API-collect/blob/master/docs/comment/readme.md#%E8%AF%84%E8%AE%BA%E5%8C%BA%E7%B1%BB%E5%9E%8B%E4%BB%A3%E7%A0%81
+*/
+const commentTypeUnion = zod.default.union([
+	zod.default.literal(1),
+	zod.default.literal(2),
+	zod.default.literal(4),
+	zod.default.literal(5),
+	zod.default.literal(6),
+	zod.default.literal(7),
+	zod.default.literal(8),
+	zod.default.literal(9),
+	zod.default.literal(10),
+	zod.default.literal(11),
+	zod.default.literal(12),
+	zod.default.literal(13),
+	zod.default.literal(14),
+	zod.default.literal(15),
+	zod.default.literal(16),
+	zod.default.literal(17),
+	zod.default.literal(18),
+	zod.default.literal(19),
+	zod.default.literal(20),
+	zod.default.literal(21),
+	zod.default.literal(22),
+	zod.default.literal(33)
+], { error: "无效的评论区类型" });
+/**
+* `type` 参数的完整 schema：HTTP query 的字符串先 coerce 成数字，再 pipe 进合法代码
+* 联合收窄 —— SDK 签名拿到的是 `CommentType` 而不是裸 `number`，非法代码报
+* 「无效的评论区类型」。`zod.enum` 在 zod 4.6.5 不接受数字数组（values 恒空、恒报错），
+* 所以用 literal 联合。
+*/
+const commentTypeSchema = zod.default.coerce.number().pipe(commentTypeUnion);
+/** `mode` 的合法值联合：0/1/2/3 之外（含 coerce 出的 NaN）统一报错 */
+const commentModeUnion = zod.default.union([
+	zod.default.literal(0),
+	zod.default.literal(1),
+	zod.default.literal(2),
+	zod.default.literal(3)
+], { error: "排序方式只能是 0、1、2、3" });
+/** `mode` 参数的完整 schema：coerce + 收窄到 `0 | 1 | 2 | 3` */
+const commentModeSchema = zod.default.coerce.number().pipe(commentModeUnion);
 /** B站 API URL 构建类（所有方法只拼 URL，不发起请求） */
 var BilibiliAPI$1 = class {
 	/** 获取登录基本信息 */
@@ -175,6 +247,34 @@ 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;
+	};
+};
 /**
 * 声明一个端点。运行时是恒等函数（原样返回 `def`），全部价值在类型推导：
 * `TParams` 从 `params` 推、`TData` 从 `response` / `compute` 推。
@@ -182,6 +282,36 @@ const type = () => ({});
 * @param def - 端点声明
 */
 const defineEndpoint = (def) => def;
+/**
+* 标记一个端点参数为「内部参数」。
+*
+* 内部参数照常参与 zod 校验、`paginate.nextParams` 的写入与 URL 构造，但三个消费点
+* 都看不见它：
+* - **调用方签名**（fetcher / 静态 fetcher 的 options，见 `PublicParamsOf`）——对象
+*   字面量里传入会被 excess property check 拒掉；
+* - **openapi 的 query parameters**（`parametersOf` 经 `internalParamKeysOf` 过滤）；
+* - **文档参数表**（生成器读 openapi 产物，随上一条自动跟随）。
+*
+* 标记与字段声明焊在同一个表达式里（`pagination_str: internalParam(...)`），不存在
+* 「写了字段忘了登记到某张清单」的漂移面 —— 这也是它不做成 EndpointDef 字段的理由：
+* def 上已经够多键了，而且分离的清单必然漂移。运行时经 `.meta()` 挂进 zod 全局
+* registry（文档生成器已在用 meta 传 examples，同一机制）。
+*/
+const internalParam = (schema) => schema.meta({ amagiInternal: true });
+/**
+* 运行时判断一个 params 字段是否内部参数（openapi 生成器的过滤依据）。
+*
+* 读 `.meta()` 而不是别的运行时痕迹：meta 是 zod 官方的元数据通道，克隆与管道都保留。
+*/
+const isInternalParam = (schema) => {
+	return (schema?.meta?.())?.amagiInternal === true;
+};
+/** 端点 params 里全部内部参数的键名（运行时）。非 object schema 返回空集 */
+const internalParamKeysOf = (params) => {
+	const shape = params.shape;
+	if (shape === void 0) return /* @__PURE__ */ new Set();
+	return new Set(Object.keys(shape).filter((key) => isInternalParam(shape[key])));
+};
 //#endregion
 //#region src/platforms/bilibili/endpoints/define.ts
 /**
@@ -415,7 +545,7 @@ const bangumiStream = defineBilibiliEndpoint({
 			ep_id: p.ep_id.replace("ep", "")
 		})
 	}),
-	sign: "qtparam",
+	sign: [require_steps.qtparam()],
 	retryOn: ["RISK_CONTROL"],
 	response: type()
 });
@@ -486,45 +616,17 @@ const commentReplies$1 = defineBilibiliEndpoint({
 	},
 	params: zod.default.object({
 		oid: zod.default.string().min(1, { error: "OID不能为空" }).describe("目标对象 ID，视频稿件填 avid"),
-		type: zod.default.coerce.number().int().min(1).refine((val) => COMMENT_TYPES$1.includes(val), { error: "无效的评论区类型" }).describe("评论区类型，视频稿件填 1"),
+		type: commentTypeSchema.describe("评论区类型代码：1 视频稿件（oid=avid）、11 相簿/图片动态、12 专栏（cvid）、17 动态等；完整对照表见 bilibili-API-collect「评论区类型代码」"),
 		root: zod.default.string().min(1, { error: "根评论ID不能为空" }).describe("根评论 ID，即要展开的一级评论"),
 		number: zod.default.coerce.number().int().positive().default(20).optional().describe("该根评论下的回复条数，不翻页，默认 20")
 	}),
 	build: (p) => ({
 		method: "GET",
-		url: bilibiliApiUrls$1.getCommentReplies({
-			...p,
-			type: p.type
-		})
+		url: bilibiliApiUrls$1.getCommentReplies(p)
 	}),
 	retryOn: ["RISK_CONTROL"],
 	response: type()
 });
-/** 评论区类型枚举 */
-const COMMENT_TYPES$1 = [
-	1,
-	2,
-	4,
-	5,
-	6,
-	7,
-	8,
-	9,
-	10,
-	11,
-	12,
-	13,
-	14,
-	15,
-	16,
-	17,
-	18,
-	19,
-	20,
-	21,
-	22,
-	33
-];
 //#endregion
 //#region src/platforms/bilibili/endpoints/comments.ts
 /**
@@ -549,23 +651,19 @@ const comments$2 = defineBilibiliEndpoint({
 	},
 	params: zod.default.object({
 		oid: zod.default.string().min(1, { error: "OID不能为空" }).describe("目标对象 ID，视频稿件填 avid"),
-		type: zod.default.coerce.number().int().min(1).refine((val) => COMMENT_TYPES.includes(val), { error: "无效的评论区类型" }).describe("评论区类型，视频稿件填 1"),
+		type: commentTypeSchema.describe("评论区类型代码：1 视频稿件（oid=avid）、2 话题、11 相簿/图片动态、12 专栏（cvid）、14 音频（auid）、17 动态、33 课程（epid）等；完整对照表见 bilibili-API-collect「评论区类型代码」"),
 		number: zod.default.coerce.number().int().positive().default(20).optional().describe("目标条数，自动翻页合并后去重，默认 20"),
-		mode: zod.default.coerce.number().int().min(0).max(3).optional().describe("排序方式，默认 3"),
-		pagination_str: zod.default.string().optional().describe("翻页游标，由端点接管，不用传"),
+		mode: commentModeSchema.optional().describe("排序方式：0 和 3 仅热度，1 按热度+按时间，2 仅时间；默认 3"),
+		pagination_str: internalParam(zod.default.string().optional().describe("翻页游标，由端点接管，不用传")),
 		plat: zod.default.coerce.number().int().optional().describe("平台类型，默认 1"),
 		seek_rpid: zod.default.string().optional().describe("定位到某条评论，默认空"),
 		web_location: zod.default.string().optional().describe("web 位置参数，默认 1315875")
 	}),
 	build: (p) => ({
 		method: "GET",
-		url: bilibiliApiUrls$1.getComments({
-			...p,
-			type: p.type,
-			mode: p.mode
-		})
+		url: bilibiliApiUrls$1.getComments(p)
 	}),
-	sign: "wbi",
+	sign: [require_steps.wbi()],
 	paginate: {
 		maxPageSize: 100,
 		items: (page) => page.data?.replies ?? [],
@@ -594,31 +692,6 @@ const comments$2 = defineBilibiliEndpoint({
 	retryOn: ["RISK_CONTROL"],
 	response: type()
 });
-/** 评论区类型枚举 */
-const COMMENT_TYPES = [
-	1,
-	2,
-	4,
-	5,
-	6,
-	7,
-	8,
-	9,
-	10,
-	11,
-	12,
-	13,
-	14,
-	15,
-	16,
-	17,
-	18,
-	19,
-	20,
-	21,
-	22,
-	33
-];
 //#endregion
 //#region src/platforms/bilibili/endpoints/dynamicDetail.ts
 /**
@@ -820,112 +893,6 @@ const userCard = defineBilibiliEndpoint({
 	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 注入）。
@@ -944,7 +911,7 @@ const userDynamicList = defineBilibiliEndpoint({
 	},
 	params: zod.default.object({ host_mid: zod.default.coerce.number().int().min(1, { error: "UP主UID必须大于等于1" }).describe("UP 主 UID") }),
 	build: (p, ctx) => {
-		const callerHeaders = new AmagiHeaders(ctx.requestConfig?.headers);
+		const callerHeaders = new require_steps.AmagiHeaders(ctx.requestConfig?.headers);
 		const headers = { Origin: "https://space.bilibili.com" };
 		if (!callerHeaders.has("referer")) headers.Referer = `https://space.bilibili.com/${p.host_mid}/dynamic`;
 		return {
@@ -953,7 +920,7 @@ const userDynamicList = defineBilibiliEndpoint({
 			headers
 		};
 	},
-	sign: "wbi",
+	sign: [require_steps.wbi()],
 	retryOn: ["RISK_CONTROL"],
 	response: type()
 });
@@ -998,7 +965,7 @@ const userSpaceInfo = defineBilibiliEndpoint({
 		method: "GET",
 		url: bilibiliApiUrls$1.getUserSpaceInfo(p)
 	}),
-	sign: "wbi",
+	sign: [require_steps.wbi()],
 	retryOn: ["RISK_CONTROL"],
 	response: type()
 });
@@ -1207,7 +1174,7 @@ const bilibiliRegistry = {
 			method: "GET",
 			url: bilibiliApiUrls$1.getVideoStream(p)
 		}),
-		sign: "qtparam",
+		sign: [require_steps.qtparam()],
 		retryOn: ["RISK_CONTROL"],
 		response: type()
 	}),
@@ -1466,7 +1433,7 @@ var TypedEventEmitter = class extends node_events.EventEmitter {
 * @description 单例模式，所有模块共享同一个事件总线
 * @example
 * ```typescript
-* import { amagiEvents } from '../model/events'
+* import { amagiEvents } from '@ikenxuan/amagi'
 *
 * // 监听 API 成功事件
 * amagiEvents.on('api:success', (data) => {
@@ -1988,7 +1955,7 @@ const bilibiliApiUrls = new BilibiliAPI();
 /**
 * 混合密钥编码表，用于对 imgKey 和 subKey 进行字符顺序打乱编码
 */
-const mixinKeyEncTab$1 = [
+const mixinKeyEncTab = [
 	46,
 	47,
 	18,
@@ -2059,7 +2026,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 - 请求参数对象，键值对形式
@@ -2067,8 +2034,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 });
@@ -2103,7 +2070,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
@@ -2186,10 +2153,10 @@ const generateSecChUa = (userAgent) => {
 * GET / POST），不属于基线。
 */
 const createBilibiliConfig = (cookie, requestConfig) => {
-	const userAgent = new AmagiHeaders(requestConfig?.headers).get("user-agent") ?? "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36";
+	const userAgent = new require_steps.AmagiHeaders(requestConfig?.headers).get("user-agent") ?? "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36";
 	const secChUa = generateSecChUa(userAgent);
 	return {
-		headers: new AmagiHeaders().set("accept", "application/json, text/plain, */*").set("accept-language", "zh-CN,zh;q=0.9").set("accept-encoding", "gzip, deflate, br, zstd").set("cache-control", "no-cache").set("pragma", "no-cache").set("priority", "u=1, i").set("referer", "https://www.bilibili.com/").set("sec-ch-ua", secChUa).set("sec-ch-ua-mobile", "?0").set("sec-ch-ua-platform", "\"Windows\"").set("sec-fetch-dest", "empty").set("sec-fetch-mode", "cors").set("sec-fetch-site", "same-site").set("user-agent", userAgent).set("cookie", cookie?.trim() ?? "").merge(requestConfig?.headers),
+		headers: new require_steps.AmagiHeaders().set("accept", "application/json, text/plain, */*").set("accept-language", "zh-CN,zh;q=0.9").set("accept-encoding", "gzip, deflate, br, zstd").set("cache-control", "no-cache").set("pragma", "no-cache").set("priority", "u=1, i").set("referer", "https://www.bilibili.com/").set("sec-ch-ua", secChUa).set("sec-ch-ua-mobile", "?0").set("sec-ch-ua-platform", "\"Windows\"").set("sec-fetch-dest", "empty").set("sec-fetch-mode", "cors").set("sec-fetch-site", "same-site").set("user-agent", userAgent).set("cookie", cookie?.trim() ?? "").merge(requestConfig?.headers),
 		requestConfig: {
 			timeout: 1e4,
 			...requestConfig
@@ -2407,254 +2374,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=${node_crypto.default.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([require_steps.wbi()]),
+	qtparam: stepsToSigner([require_steps.qtparam()])
+});
 //#endregion
 //#region src/platforms/douyin/config.ts
 /**
@@ -2668,10 +2401,10 @@ const createBilibiliSigners = () => {
 * `method` 归端点声明（抖音端点各自声明 GET / POST），不属于基线。
 */
 const createDouyinConfig = (cookie, requestConfig) => {
-	const userAgent = new AmagiHeaders(requestConfig?.headers).get("user-agent") ?? "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36";
+	const userAgent = new require_steps.AmagiHeaders(requestConfig?.headers).get("user-agent") ?? "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36";
 	const secChUa = generateSecChUa(userAgent);
 	return {
-		headers: new AmagiHeaders().set("accept", "application/json, text/plain, */*").set("accept-encoding", "gzip, deflate, br, zstd").set("accept-language", "zh-CN,zh;q=0.9,en;q=0.8,en-GB;q=0.7,en-US;q=0.6").set("priority", "u=1, i").set("referer", "https://www.douyin.com/").set("sec-ch-ua", secChUa).set("sec-ch-ua-mobile", "?0").set("sec-ch-ua-platform", "\"Windows\"").set("sec-fetch-dest", "empty").set("sec-fetch-mode", "cors").set("sec-fetch-site", "same-origin").set("user-agent", userAgent).set("cookie", cookie?.trim() ?? "").merge(requestConfig?.headers),
+		headers: new require_steps.AmagiHeaders().set("accept", "application/json, text/plain, */*").set("accept-encoding", "gzip, deflate, br, zstd").set("accept-language", "zh-CN,zh;q=0.9,en;q=0.8,en-GB;q=0.7,en-US;q=0.6").set("priority", "u=1, i").set("referer", "https://www.douyin.com/").set("sec-ch-ua", secChUa).set("sec-ch-ua-mobile", "?0").set("sec-ch-ua-platform", "\"Windows\"").set("sec-fetch-dest", "empty").set("sec-fetch-mode", "cors").set("sec-fetch-site", "same-origin").set("user-agent", userAgent).set("cookie", cookie?.trim() ?? "").merge(requestConfig?.headers),
 		requestConfig: {
 			timeout: 1e4,
 			...requestConfig
@@ -2768,777 +2501,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 node_crypto.default.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 node_url.default.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 = node_crypto.default.randomBytes(length ?? 116);
-		return Array.from(randomBytes, (byte) => characters[byte % 62]).join("");
-	}
-	/**
-	* a_bogus 签名算法
-	* @param url 需要签名的地址
-	* @returns 对此地址签名后的URL查询参数
-	*/
-	static AB(url, userAgent) {
-		return require_tokens.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 require_tokens.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 策略配置）。
-*
-* @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: node_crypto.default.createHash("md5").update(plain, "utf8").digest("hex"),
-		signedQuery
-	};
-};
-/**
-* 返回可直接发送的完整 URL（规范化 query + timestamp + 签名）。
+* 真实浏览器发这些请求的顺序是 **webid → msToken → a_bogus / x_bogus → secsdk**，每一步都改
+* query，颠倒任意一步签名就不成立。顺序不靠这里保证，由 `SignPhase` 的固定次序保证。
 *
-* 服务端按收到的 query 校验签名，所以必须发这个返回值，不能拿原始 URL 直接发。
+* 其中 webid 与 secsdk 那两段都是「命中才动、否则原样返回」，对不相关的端点是无操作，
+* 所以可以无条件套用 —— 详见 `./steps.ts` 文件头。
 *
-* @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 不在策略表里时原样返回。
+* ## 为什么 secsdk 没有自己的注册名
 *
-* 这是给取数层用的唯一入口 —— 无条件套在 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`，表外原样返回。
-*
-* `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'`）。
-*
-* 前置条件：真实接口形态的长路径（≥3 段且带查询串）。不满足时抛错，由
-* execute 归因为 `kind: 'internal'`。
-* @param spec - 请求描述（`url` 参与签名）
-* @param ctx - 执行上下文（`userAgent` 用于签名）
-* @returns 带 `X-Bogus` 的请求描述；path 在 secsdk 策略表内时再补一层 `x-secsdk-web-signature`
-*/
-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` 查名。
 *
+* 两个名字都取 **184** 那档 msToken 长度：这张表只在 `client.<平台>.request` 那条路上被查到，
+* 而那条路打的是「本库还没收录的接口」—— 猜不出该用 184（作品详情类）还是 116（评论 / 音乐类），
+* 统一取前者。收录进端点的接口各自在声明里写准确的那一档，不经过这里。
+*
 * 用 `satisfies` 而非显式 `: Record<string, SignFn>` 返回：后者会把键联合抹成宽
 * `string`，而 {@link DouyinSignerName} 要靠 `keyof` 从这张表推导出精确的名字联合。
+* @returns 注册名 → 签名器
 */
 const createDouyinSigners = () => ({
-	"a-bogus": aBogusSigner,
-	"x-bogus": xBogusSigner
+	"a-bogus": stepsToSigner(require_steps.douyinBogus(184)),
+	"x-bogus": stepsToSigner(require_steps.douyinXBogus(184))
 });
 //#endregion
 //#region src/platforms/kuaishou/captcha.ts
@@ -3686,7 +2693,7 @@ const parseKuaishouCaptcha = (raw) => {
 const KUAISHOU_DEFAULT_TIMEOUT = 1e4;
 /** 从请求配置里取 UA：大小写不敏感，取不到用集中维护的默认值 */
 const userAgentOf$1 = (requestConfig) => {
-	return new AmagiHeaders(requestConfig?.headers).get("user-agent") ?? "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36";
+	return new require_steps.AmagiHeaders(requestConfig?.headers).get("user-agent") ?? "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36";
 };
 /**
 * 构造快手默认请求配置。
@@ -3700,7 +2707,7 @@ const createKuaishouConfig = (cookie, requestConfig) => {
 	const userAgent = userAgentOf$1(requestConfig);
 	const secChUa = generateSecChUa(userAgent);
 	return {
-		headers: new AmagiHeaders().set("accept", "application/json, text/plain, */*").set("accept-encoding", "gzip, deflate, br, zstd").set("accept-language", "zh-CN,zh;q=0.9,en;q=0.8,en-GB;q=0.7,en-US;q=0.6").set("content-type", "application/json").set("priority", "u=0, i").set("origin", "https://www.kuaishou.com").set("referer", "https://www.kuaishou.com/new-reco").set("sec-ch-ua", secChUa).set("sec-ch-ua-mobile", "?0").set("sec-ch-ua-platform", "\"Windows\"").set("sec-fetch-dest", "empty").set("sec-fetch-mode", "cors").set("sec-fetch-site", "same-site").set("user-agent", userAgent).merge(requestConfig?.headers),
+		headers: new require_steps.AmagiHeaders().set("accept", "application/json, text/plain, */*").set("accept-encoding", "gzip, deflate, br, zstd").set("accept-language", "zh-CN,zh;q=0.9,en;q=0.8,en-GB;q=0.7,en-US;q=0.6").set("content-type", "application/json").set("priority", "u=0, i").set("origin", "https://www.kuaishou.com").set("referer", "https://www.kuaishou.com/new-reco").set("sec-ch-ua", secChUa).set("sec-ch-ua-mobile", "?0").set("sec-ch-ua-platform", "\"Windows\"").set("sec-fetch-dest", "empty").set("sec-fetch-mode", "cors").set("sec-fetch-site", "same-site").set("user-agent", userAgent).merge(requestConfig?.headers),
 		requestConfig: {
 			timeout: KUAISHOU_DEFAULT_TIMEOUT,
 			...requestConfig
@@ -3903,1140 +2910,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 = node_crypto.default.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 = require_steps.sharedKuaishouSigner) => ({ hxfalcon: stepsToSigner([require_steps.hxfalcon(signer)]) });
 //#endregion
 //#region src/platforms/xiaohongshu/config.ts
 /**
@@ -5056,7 +2943,7 @@ const createKuaishouSigners = (signer = createKuaishouSigner()) => ({ hxfalcon:
 const XIAOHONGSHU_DEFAULT_TIMEOUT = 1e4;
 /** 从请求配置里取 UA：大小写不敏感，取不到用集中维护的默认值 */
 const userAgentOf = (requestConfig) => {
-	return new AmagiHeaders(requestConfig?.headers).get("user-agent") ?? "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36";
+	return new require_steps.AmagiHeaders(requestConfig?.headers).get("user-agent") ?? "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36";
 };
 /**
 * 构造小红书默认请求配置。
@@ -5068,7 +2955,7 @@ const createXiaohongshuConfig = (cookie, requestConfig) => {
 	const userAgent = userAgentOf(requestConfig);
 	const secChUa = generateSecChUa(userAgent);
 	return {
-		headers: new AmagiHeaders().set("accept", "application/json, text/plain, */*").set("accept-language", "zh-CN,zh;q=0.9,en;q=0.8,en-GB;q=0.7,en-US;q=0.6").set("cache-control", "no-cache").set("content-type", "application/json;charset=UTF-8").set("pragma", "no-cache").set("priority", "u=1, i").set("referer", "https://www.xiaohongshu.com/").set("sec-ch-ua", secChUa).set("sec-ch-ua-mobile", "?0").set("sec-ch-ua-platform", "\"Windows\"").set("sec-fetch-dest", "empty").set("sec-fetch-mode", "cors").set("sec-fetch-site", "same-site").set("user-agent", userAgent).set("cookie", cookie?.trim() ?? "").merge(requestConfig?.headers),
+		headers: new require_steps.AmagiHeaders().set("accept", "application/json, text/plain, */*").set("accept-language", "zh-CN,zh;q=0.9,en;q=0.8,en-GB;q=0.7,en-US;q=0.6").set("cache-control", "no-cache").set("content-type", "application/json;charset=UTF-8").set("pragma", "no-cache").set("priority", "u=1, i").set("referer", "https://www.xiaohongshu.com/").set("sec-ch-ua", secChUa).set("sec-ch-ua-mobile", "?0").set("sec-ch-ua-platform", "\"Windows\"").set("sec-fetch-dest", "empty").set("sec-fetch-mode", "cors").set("sec-fetch-site", "same-site").set("user-agent", userAgent).set("cookie", cookie?.trim() ?? "").merge(requestConfig?.headers),
 		requestConfig: {
 			timeout: XIAOHONGSHU_DEFAULT_TIMEOUT,
 			...requestConfig
@@ -5102,397 +2989,50 @@ const xiaohongshuJudge = (raw, http) => {
 	return verdictFromHttpStatus(http.status) ?? { ok: true };
 };
 //#endregion
-//#region src/platforms/xiaohongshu/sign/config.ts
-/** 初始化签名配置。 */
-const createXiaohongshuCryptoConfig = () => new _ikenxuan_xhshow_ts.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((0, node_crypto.randomBytes)(30), (byte) => COOKIE_RANDOM_CHARS$1[byte % 36]).join("")}5000`;
-	const a1 = `${source}${crc32$1(source)}`.slice(0, 52);
-	return {
-		a1,
-		webId: (0, node_crypto.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 = (0, node_crypto.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 _ikenxuan_xhshow_ts.Xhshow(cryptoConfig);
-	const cookies = {
-		...generateA1AndWebId$1(),
-		webBuild: cryptoConfig.DATA_WEB_BUILD,
-		xsecappid: "xhs-pc-web",
-		loadts: String(Date.now()),
-		abRequestId: (0, node_crypto.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 _ikenxuan_xhshow_ts.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
 /**
-* 小红书签名算法。
-*
-* 包装 `@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`。
+* 小红书签名器表：**只做「注册名 → `SignStep` 清单」的映射，不含算法**。
 *
-* `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 _ikenxuan_xhshow_ts.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）。
+* 算法的唯一实现在 `./steps.ts`（四个基础签名器、helper，以及 XYS_/XYW_ 协议区别、
+* 签名路径为何取 signPath 等理由都在那边的文件头）。依赖方向单向 —— `signers.ts → steps.ts`，
+* 永不反向：两份实现并存时会改一边忘一边，而小红书签名错了往往整条请求被判 406，这类分叉极难发现。
 *
-* 数据获取类接口（`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 = {}) => (0, _ikenxuan_xhshow_ts.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。
+* 端点声明 `sign: [xs('get', 'xyw'), traceId()]` 走清单；`client.xiaohongshu.request` 不给
+* `amagi.sign` 时走字符串 `'xhs-get'` 这类名字查这张表。两者现在压的是同一批 step，签出来必然一致。
 *
-* 交由上游 `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。
-*/
-/** 从 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）返回空对象，签名退化为只签路径，行为不变。
+* @module platforms/xiaohongshu/sign/signers
 */
-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 四个签名头。
-*
-* `x-xray-traceid` 是真实浏览器每次请求都带的追踪头（见 noteComments 的抓包）；
-* 早期只发前三个，`comment/page` 这类接口会因此被判为非法请求，返回 HTTP 406。
-* 所有平台签名器共用本 helper，因此补上后对全部端点生效。
-*/
-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` 查名。
 *
 * 用 `satisfies` 而非显式 `: Record<string, SignFn>` 返回：后者会把键联合抹成宽
 * `string`，而 {@link XiaohongshuSignerName} 要靠 `keyof` 从这张表推导精确名字联合。
+* @returns 注册名 → 签名器
 */
 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([require_steps.xs("post", "xys")]),
+	"xhs-get": stepsToSigner([require_steps.xs("get", "xys")]),
+	"xhs-get-trace": stepsToSigner([require_steps.xs("get", "xys"), require_steps.traceId()]),
+	"xhs-post-rap": stepsToSigner([require_steps.xs("post", "xys"), require_steps.rap()]),
+	"xhs-get-xyw": stepsToSigner([require_steps.xs("get", "xyw")]),
+	"xhs-post-xyw": stepsToSigner([require_steps.xs("post", "xyw")]),
+	"xhs-get-xyw-trace": stepsToSigner([require_steps.xs("get", "xyw"), require_steps.traceId()])
 });
 //#endregion
 //#region src/runtime/events.ts
@@ -5889,10 +3429,10 @@ const stripEdgeToken = (headers) => {
 * @returns 归一化后的容器
 */
 const toAmagiHeaders = (headers) => {
-	if (!headers) return new AmagiHeaders();
+	if (!headers) return new require_steps.AmagiHeaders();
 	const source = headers;
 	const plain = typeof source.toJSON === "function" ? source.toJSON() : headers;
-	const out = new AmagiHeaders();
+	const out = new require_steps.AmagiHeaders();
 	for (const [name, value] of Object.entries(plain)) out.set(name, Array.isArray(value) ? value.join("; ") : value);
 	return out;
 };
@@ -6052,7 +3592,7 @@ var HttpClient = class {
 	* @returns axios 配置
 	*/
 	buildAxiosConfig(spec, perCall) {
-		const headers = new AmagiHeaders(this.options.headers).merge(this.options.requestConfig?.headers).merge(perCall?.headers).merge(spec.headers);
+		const headers = new require_steps.AmagiHeaders(this.options.headers).merge(this.options.requestConfig?.headers).merge(perCall?.headers).merge(spec.headers);
 		for (const name of spec.dropHeaders ?? []) headers.delete(name);
 		const { headers: _baseHeaders, ...baseRest } = this.options.requestConfig ?? {};
 		const { headers: _callHeaders, ...callRest } = perCall ?? {};
@@ -6145,7 +3685,7 @@ const PLATFORM_RUNTIME = {
 	douyin: {
 		signers: createDouyinSigners(),
 		judge: douyinJudge,
-		observe: observeDouyinWebid
+		observe: require_steps.observeDouyinWebid
 	},
 	bilibili: {
 		signers: (() => {
@@ -6291,7 +3831,15 @@ const SUCCESS_MESSAGE = "获取成功";
 * `T | undefined`）。数组回调里没有 `if` 可用，`filter` 又只认类型谓词
 * —— 这就是必须有守卫的场景：
 *
-* ```ts
+* ```ts twoslash
+* import { isSuccess, type AmagiResult } from '@ikenxuan/amagi'
+*
+* declare const ids: string[]
+* declare const fetchOne: (id: string) => Promise<AmagiResult<Work>>
+* interface Work {
+*   id: string
+* }
+*
 * const list: AmagiResult<Work>[] = await Promise.all(ids.map(fetchOne))
 * const works = list.filter(isSuccess).map((r) => r.data)   // Work[]
 * ```
@@ -6449,7 +3997,7 @@ const runPaginated = async (def, params, runPage) => {
 */
 const attachCookie = (spec, cookie) => {
 	if (!cookie) return spec;
-	const headers = new AmagiHeaders(spec.headers);
+	const headers = new require_steps.AmagiHeaders(spec.headers);
 	if (headers.has("cookie")) return spec;
 	headers.set("Cookie", cookie);
 	return {
@@ -6610,11 +4158,44 @@ 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;
 };
 /**
+* 限额并发地跑异步任务，结果按 `items` 下标顺序收齐（单任务结局语义同
+* `Promise.allSettled`）。
+*
+* 派发顺序仍按 `items` 顺序（FIFO），只是同时在途的不超过 `limit`。单个任务的
+* 抛错经 `then` 的第二参落进对应下标、不惊动其它任务 —— 不写 `try/catch` 是因为
+* execute 的「唯一一处 catch」是源码级契约（execute.test.ts 有断言），这里与
+* `Promise.allSettled` 同构即可。
+*/
+const settledWithConcurrency = async (items, limit, task) => {
+	const queue = items.map((item, index) => ({
+		item,
+		index
+	})).reverse();
+	const settled = new Array(items.length);
+	const worker = async () => {
+		while (true) {
+			const job = queue.pop();
+			if (job === void 0) return;
+			settled[job.index] = await task(job.item, job.index).then((value) => ({
+				status: "fulfilled",
+				value
+			}), (reason) => ({
+				status: "rejected",
+				reason
+			}));
+		}
+	};
+	await Promise.all(Array.from({ length: Math.min(limit, items.length) }, worker));
+	return settled;
+};
+/**
 * 执行一条端点声明，产出信封。
 *
 * **永不 reject。** 唯一的例外是调用方自己传入的回调抛出（如会话的
@@ -6800,15 +4381,18 @@ const execute = async (def, input, options) => {
 		const isMulti = signed.length > 1 || Array.isArray(built);
 		const reason = isMulti ? "segment" : "initial";
 		const tolerate = def.partial === "tolerate";
+		const settled = await settledWithConcurrency(signed, 10, (spec, index) => runSpec(spec, reason, refreshFor(params, index)));
 		let outcomes;
 		if (tolerate) {
-			outcomes = (await Promise.allSettled(signed.map((spec, index) => runSpec(spec, reason, refreshFor(params, index))))).map((r) => r.status === "fulfilled" ? r.value : {
+			outcomes = settled.map((r) => r.status === "fulfilled" ? r.value : {
 				ok: false,
 				error: classifyThrown(r.reason, "send")
 			});
 			if (outcomes.every((o) => !o.ok)) return failWith(outcomes[0].error);
 		} else {
-			outcomes = await Promise.all(signed.map((spec, index) => runSpec(spec, reason, refreshFor(params, index))));
+			const rejected = settled.find((r) => r.status === "rejected");
+			if (rejected) throw rejected.reason;
+			outcomes = settled.map((r) => r.value);
 			const firstFailure = outcomes.find((o) => !o.ok);
 			if (firstFailure) return failWith(firstFailure.error);
 		}
@@ -6958,7 +4542,7 @@ const methodNameOf = (platform, endpoint) => METHOD_NAMES[fullNameOf(platform, e
 * @returns 本次调用的有效 cookie 与合并后的请求配置
 */
 const resolveBoundRequest = (boundCookie, base, override) => {
-	const headers = new AmagiHeaders(base?.headers).merge(override?.headers);
+	const headers = new require_steps.AmagiHeaders(base?.headers).merge(override?.headers);
 	return {
 		cookie: headers.get("cookie") ?? boundCookie,
 		requestConfig: {
@@ -6996,7 +4580,7 @@ const methodNameFor = (platform, endpoint) => methodNameOf(platform, endpoint) ?
 */
 const callEndpoint = (def, ctx, options, requestConfig) => {
 	const merged = resolveBoundRequest(ctx.cookie, ctx.requestConfig, requestConfig);
-	const mergedUA = merged.requestConfig ? new AmagiHeaders(merged.requestConfig.headers).get("user-agent") ?? ctx.userAgent : ctx.userAgent;
+	const mergedUA = merged.requestConfig ? new require_steps.AmagiHeaders(merged.requestConfig.headers).get("user-agent") ?? ctx.userAgent : ctx.userAgent;
 	const now = ctx.now ?? Date.now;
 	const startedAt = now();
 	const requestId = (ctx.requestId ?? defaultRequestId)();
@@ -7189,7 +4773,7 @@ const extractBrowserVersion$1 = (userAgent) => {
 const buildQueryString$3 = (params) => {
 	return Object.entries(params).filter(([_, value]) => value !== void 0 && value !== null).map(([key, value]) => `${key}=${encodeURIComponent(value)}`).join("&");
 };
-const fp$1 = douyinSign$1.VerifyFpManager();
+const fp$1 = require_steps.douyinSign.VerifyFpManager();
 /** iesdouyin v2 游客接口前缀：不需要 cookie、不需要签名 */
 const GUEST_BASE$1 = "https://www.iesdouyin.com/web/api/v2";
 /** 表情资源包元信息，走 App 接口，同样免鉴权（需要 Android UA，由端点声明覆盖） */
@@ -7235,7 +4819,6 @@ var DouyinAPI$1 = class {
 			platform: "PC",
 			downlink: "10",
 			effective_type: "4g",
-			msToken: douyinSign$1.Mstoken(184),
 			verifyFp: fp$1,
 			fp: fp$1
 		};
@@ -7339,7 +4922,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
 		};
@@ -7461,7 +5043,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
 		};
@@ -7589,8 +5170,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",
@@ -7619,11 +5199,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) {
@@ -7655,7 +5233,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
 		};
@@ -7684,7 +5261,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
 		};
@@ -7725,7 +5301,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
 		};
@@ -7766,13 +5341,13 @@ const commentReplies = defineDouyinEndpoint({
 		aweme_id: zod.default.string().min(1, { error: "作品ID不能为空" }).describe("作品 ID"),
 		comment_id: zod.default.string().min(1, { error: "评论ID不能为空" }).describe("要取回复的评论 ID"),
 		number: zod.default.coerce.number().int().min(1).optional().describe("目标条数，默认 3"),
-		cursor: zod.default.coerce.number().int().min(0).optional().describe("翻页游标，一般不用传")
+		cursor: internalParam(zod.default.coerce.number().int().min(0).optional().describe("翻页游标，一般不用传"))
 	}),
 	build: (p) => ({
 		method: "GET",
 		url: douyinApiUrls$1.getCommentReplies(p)
 	}),
-	sign: "x-bogus",
+	sign: [require_steps.xBogus(), require_steps.secsdk()],
 	retryOn: ["ANTIBOT_PAGE"],
 	retryFresh: true,
 	paginate: {
@@ -7810,13 +5385,13 @@ const comments$1 = defineDouyinEndpoint({
 	params: zod.default.object({
 		aweme_id: zod.default.string().min(1, { error: "作品ID不能为空" }).describe("作品 ID"),
 		number: zod.default.coerce.number().int().min(1).optional().describe("目标条数，默认 50"),
-		cursor: zod.default.coerce.number().int().min(0).optional().describe("翻页游标，一般不用传")
+		cursor: internalParam(zod.default.coerce.number().int().min(0).optional().describe("翻页游标，一般不用传"))
 	}),
 	build: (p) => ({
 		method: "GET",
 		url: douyinApiUrls$1.getComments(p)
 	}),
-	sign: "a-bogus",
+	sign: require_steps.douyinBogus(184),
 	retryOn: ["ANTIBOT_PAGE"],
 	retryFresh: true,
 	paginate: {
@@ -7838,9 +5413,21 @@ const comments$1 = defineDouyinEndpoint({
 //#endregion
 //#region src/platforms/douyin/endpoints/danmakuList.ts
 /**
+* duration 的硬上限（毫秒，7 天）。
+*
+* 纯保险丝：分段并发已由执行器的限额池兜住，真实的超长作品（实测有 27 小时级、
+* 弹幕正常的直播回放）不受影响。挡的是天文数字的 `duration`（如 `9e15`，能通过
+* `.int()` 校验）—— `build` 的切段是同步 while 循环，那种值会在任何请求发出之前
+* 把事件循环卡死、把分段数组撑爆。真实作品离 7 天很远，这个值给足余量。
+*
+* 导出是因为校验层的平行 schema（validation/douyin.ts，v6 门面入口）要用同一个数。
+*/
+const DANMAKU_MAX_DURATION_MS = 6048e5;
+/**
 * 弹幕列表（分段并发 + 合并排序 + `partial: 'tolerate'`）。
 *
-* 总时长 ≤ 32000ms 单段直取；超过则按 32000ms 切成多段并发请求，
+* 总时长 ≤ 32000ms 单段直取；超过则按 32000ms 切成多段，经执行器的限额并发池
+* 发出（`SEGMENT_CONCURRENCY`，完成一个补一个），
 * **单段失败容忍**（失败段返回 null，其余段照常合并），最后按 `offset_time`
 * 升序合并，元信息（`extra` / `log_pb` / `status_code`）取第一段。
 *
@@ -7859,7 +5446,7 @@ const danmakuList$1 = defineDouyinEndpoint({
 		aweme_id: zod.default.string().min(1, { error: "作品ID不能为空" }).describe("作品 ID"),
 		start_time: zod.default.coerce.number().int().min(0).optional().describe("区间起点（毫秒），默认 0"),
 		end_time: zod.default.coerce.number().int().min(0).optional().describe("区间终点（毫秒），默认取总时长"),
-		duration: zod.default.coerce.number().int().min(0).describe("作品总时长（毫秒），也是默认终点")
+		duration: zod.default.coerce.number().int().min(0).max(DANMAKU_MAX_DURATION_MS, { error: "作品总时长不能超过 7 天" }).describe("作品总时长（毫秒），也是默认终点")
 	}).refine((data) => data.end_time === void 0 || data.end_time <= data.duration, {
 		error: "获取弹幕区间的结束时间不能超过视频总时长",
 		path: ["end_time"]
@@ -7896,7 +5483,7 @@ const danmakuList$1 = defineDouyinEndpoint({
 			tag: `segment-${index + 1}`
 		}));
 	},
-	sign: "a-bogus",
+	sign: require_steps.douyinBogus(116),
 	retryOn: ["ANTIBOT_PAGE"],
 	retryFresh: true,
 	partial: "tolerate",
@@ -7931,7 +5518,7 @@ const dynamicEmojiList = defineDouyinEndpoint({
 		method: "GET",
 		url: douyinApiUrls$1.getDynamicEmojiList()
 	}),
-	sign: "a-bogus",
+	sign: require_steps.douyinBogus(116),
 	retryOn: ["ANTIBOT_PAGE"],
 	retryFresh: true,
 	response: type()
@@ -7955,7 +5542,7 @@ const emojiList$3 = defineDouyinEndpoint({
 		method: "GET",
 		url: douyinApiUrls$1.getEmojiList()
 	}),
-	sign: false,
+	sign: [require_steps.msToken(184)],
 	response: type()
 });
 //#endregion
@@ -8108,7 +5695,7 @@ const imageAlbumWork = defineDouyinEndpoint({
 		method: "GET",
 		url: douyinApiUrls$1.getWorkDetail(p)
 	}),
-	sign: "a-bogus",
+	sign: require_steps.douyinBogus(184),
 	retryOn: ["ANTIBOT_PAGE"],
 	retryFresh: true,
 	response: type()
@@ -8144,7 +5731,7 @@ const douyinRefererUrl = (page) => {
 * @returns 需要写进 spec 的 header（可能为空对象）
 */
 const withDouyinReferer = (ctx, page) => {
-	if (new AmagiHeaders(ctx.requestConfig?.headers).has("referer")) return {};
+	if (new require_steps.AmagiHeaders(ctx.requestConfig?.headers).has("referer")) return {};
 	return { referer: douyinRefererUrl(page) };
 };
 //#endregion
@@ -8164,7 +5751,7 @@ const liveRoomInfo$1 = defineDouyinEndpoint({
 	},
 	params: zod.default.object({
 		web_rid: zod.default.string().min(1, { error: "直播间ID不能为空" }).describe("直播间短号（链接里那段）"),
-		room_id: zod.default.string().optional().describe("内部透传，一般不用传")
+		room_id: internalParam(zod.default.string().optional().describe("内部透传，一般不用传"))
 	}),
 	build: (p, ctx) => ({
 		method: "GET",
@@ -8174,7 +5761,7 @@ const liveRoomInfo$1 = defineDouyinEndpoint({
 			webRid: p.web_rid
 		})
 	}),
-	sign: "a-bogus",
+	sign: require_steps.douyinBogus(116),
 	retryOn: ["ANTIBOT_PAGE"],
 	retryFresh: true,
 	response: type()
@@ -8202,7 +5789,7 @@ const loginQrcode = defineDouyinEndpoint({
 		method: "GET",
 		url: douyinApiUrls$1.getLoginQrcode(p)
 	}),
-	sign: "a-bogus",
+	sign: [require_steps.aBogus(), require_steps.secsdk()],
 	retryOn: ["ANTIBOT_PAGE"],
 	retryFresh: true,
 	response: type()
@@ -8226,7 +5813,7 @@ const musicInfo = defineDouyinEndpoint({
 		method: "GET",
 		url: douyinApiUrls$1.getMusicInfo(p)
 	}),
-	sign: "a-bogus",
+	sign: require_steps.douyinBogus(116),
 	retryOn: ["ANTIBOT_PAGE"],
 	retryFresh: true,
 	response: type()
@@ -8252,7 +5839,7 @@ const parseWork = defineDouyinEndpoint({
 		method: "GET",
 		url: douyinApiUrls$1.getWorkDetail(p)
 	}),
-	sign: "a-bogus",
+	sign: require_steps.douyinBogus(184),
 	retryOn: ["ANTIBOT_PAGE"],
 	retryFresh: true,
 	response: type()
@@ -8399,15 +5986,14 @@ const search = defineDouyinEndpoint({
 			"video"
 		]).default("general").optional().describe("搜索类型，默认综合搜索"),
 		number: zod.default.coerce.number().int().min(1).optional().describe("目标条数，默认 15"),
-		search_id: zod.default.string().optional().describe("翻页游标，一般不用传"),
-		offset: zod.default.coerce.number().int().min(0).optional().describe("翻页偏移，一般不用传")
+		search_id: internalParam(zod.default.string().optional().describe("翻页游标，一般不用传")),
+		offset: internalParam(zod.default.coerce.number().int().min(0).optional().describe("翻页偏移，一般不用传"))
 	}),
 	build: (p, ctx) => {
 		const searchType = p.type ?? "general";
 		return {
 			method: "GET",
 			url: douyinApiUrls$1.search({
-				keyword: p.query,
 				query: p.query,
 				type: searchType,
 				number: p.number,
@@ -8421,7 +6007,7 @@ const search = defineDouyinEndpoint({
 			})
 		};
 	},
-	sign: false,
+	sign: [require_steps.msToken(184)],
 	decode: (raw) => {
 		if (typeof raw !== "string") return raw;
 		const chunks = parseDouyinMultiJson(raw);
@@ -8503,7 +6089,7 @@ const slidesWork = defineDouyinEndpoint({
 		method: "GET",
 		url: douyinApiUrls$1.getWorkDetail(p)
 	}),
-	sign: "a-bogus",
+	sign: require_steps.douyinBogus(184),
 	retryOn: ["ANTIBOT_PAGE"],
 	retryFresh: true,
 	response: type()
@@ -8532,7 +6118,7 @@ const suggestWords = defineDouyinEndpoint({
 			query: p.query
 		})
 	}),
-	sign: "a-bogus",
+	sign: require_steps.douyinBogus(184),
 	retryOn: ["ANTIBOT_PAGE"],
 	retryFresh: true,
 	response: type()
@@ -8556,7 +6142,7 @@ const textWork = defineDouyinEndpoint({
 		method: "GET",
 		url: douyinApiUrls$1.getWorkDetail(p)
 	}),
-	sign: "a-bogus",
+	sign: require_steps.douyinBogus(184),
 	retryOn: ["ANTIBOT_PAGE"],
 	retryFresh: true,
 	response: type()
@@ -8579,7 +6165,7 @@ const userFavoriteList = defineDouyinEndpoint({
 	params: zod.default.object({
 		sec_uid: zod.default.string().min(1, { error: "用户ID不能为空" }).describe("用户 sec_uid，主页链接里那段"),
 		number: zod.default.coerce.number().int().min(1).optional().describe("目标条数，默认 18"),
-		max_cursor: zod.default.string().optional().describe("翻页游标，一般不用传")
+		max_cursor: internalParam(zod.default.string().optional().describe("翻页游标，一般不用传"))
 	}),
 	build: (p, ctx) => ({
 		method: "GET",
@@ -8589,7 +6175,7 @@ const userFavoriteList = defineDouyinEndpoint({
 			secUid: p.sec_uid
 		})
 	}),
-	sign: "a-bogus",
+	sign: require_steps.douyinBogus(184),
 	retryOn: ["ANTIBOT_PAGE"],
 	retryFresh: true,
 	paginate: {
@@ -8631,7 +6217,7 @@ const userProfile$3 = defineDouyinEndpoint({
 			secUid: p.sec_uid
 		})
 	}),
-	sign: "a-bogus",
+	sign: require_steps.douyinBogus(184),
 	retryOn: ["ANTIBOT_PAGE"],
 	retryFresh: true,
 	response: type()
@@ -8655,7 +6241,7 @@ const userRecommendList = defineDouyinEndpoint({
 	params: zod.default.object({
 		sec_uid: zod.default.string().min(1, { error: "用户ID不能为空" }).describe("用户 sec_uid，主页链接里那段"),
 		number: zod.default.coerce.number().int().min(1).optional().describe("目标条数，默认 18"),
-		max_cursor: zod.default.string().optional().describe("翻页游标，一般不用传")
+		max_cursor: internalParam(zod.default.string().optional().describe("翻页游标，一般不用传"))
 	}),
 	build: (p, ctx) => ({
 		method: "GET",
@@ -8665,7 +6251,7 @@ const userRecommendList = defineDouyinEndpoint({
 			secUid: p.sec_uid
 		})
 	}),
-	sign: "a-bogus",
+	sign: require_steps.douyinBogus(184),
 	retryOn: ["ANTIBOT_PAGE"],
 	retryFresh: true,
 	paginate: {
@@ -8702,7 +6288,7 @@ const userVideoList = defineDouyinEndpoint({
 	params: zod.default.object({
 		sec_uid: zod.default.string().min(1, { error: "用户ID不能为空" }).describe("用户 sec_uid，主页链接里那段"),
 		number: zod.default.coerce.number().int().min(1).optional().describe("目标条数，默认 18"),
-		max_cursor: zod.default.string().optional().describe("翻页游标，一般不用传")
+		max_cursor: internalParam(zod.default.string().optional().describe("翻页游标，一般不用传"))
 	}),
 	build: (p, ctx) => ({
 		method: "GET",
@@ -8712,7 +6298,7 @@ const userVideoList = defineDouyinEndpoint({
 			secUid: p.sec_uid
 		})
 	}),
-	sign: "a-bogus",
+	sign: require_steps.douyinBogus(184),
 	retryOn: ["ANTIBOT_PAGE"],
 	retryFresh: true,
 	paginate: {
@@ -8755,7 +6341,7 @@ const douyinRegistry = {
 			method: "GET",
 			url: douyinApiUrls$1.getWorkDetail(p)
 		}),
-		sign: "a-bogus",
+		sign: require_steps.douyinBogus(184),
 		retryOn: ["ANTIBOT_PAGE"],
 		retryFresh: true,
 		response: type(),
@@ -10195,7 +7781,7 @@ var douyinSign = class {
 	* @returns 对此地址签名后的URL查询参数
 	*/
 	static XB(url, userAgent) {
-		return new XBogus().getXBogus(url, userAgent ?? defaultUserAgent).xbogus;
+		return new require_steps.XBogus().getXBogus(url, userAgent ?? defaultUserAgent).xbogus;
 	}
 	/**
 	* `x-secsdk-web-signature` 签名算法
@@ -10209,7 +7795,7 @@ var douyinSign = class {
 	* @returns 需要加签时返回带签名的完整 URL，否则原样返回
 	*/
 	static SecSdk(url, options = {}) {
-		return applySecsdkWebSign(url, options);
+		return require_steps.applySecsdkWebSign(url, options);
 	}
 	/** 生成一个唯一的验证字符串 */
 	static VerifyFpManager() {
@@ -11033,7 +8619,7 @@ const comments = defineKuaishouEndpoint({
 		photoId: zod.default.string().min(1, { error: "photoId 不能为空" }).describe("作品 ID"),
 		number: zod.default.coerce.number().int().min(1).max(500).optional().describe("目标条数，默认一页")
 	}),
-	sign: "hxfalcon",
+	sign: [require_steps.hxfalcon()],
 	prepare: kuaishouDidPrepare,
 	build: (p) => {
 		const req = kuaishouApiUrls$1.comments(p);
@@ -11086,9 +8672,10 @@ const DANMAKU_SCAN_STEP_MS = 6e4;
 /**
 * 扫描范围上限（毫秒，1 小时）。
 *
-* 多窗口是 `Promise.all` 并发发出的，范围直接决定并发请求数
-* （`ceil(范围 / 60000)`）。不设上限时一个手输的 `duration` 就能让一次调用打出上千个
-* 请求，所以在参数层挡住：1 小时 → 最多 60 个窗口，与 `userProfile` 的 12 个同量级。
+* 多窗口经执行器的限额并发池发出（见 execute 的 `SEGMENT_CONCURRENCY`），范围决定
+* 的是**总**请求数（`ceil(范围 / 60000)`）。不设上限时一个手输的 `duration` 就能让
+* 一次调用打出上千个请求，所以在参数层挡住：1 小时 → 最多 60 个窗口，与
+* `userProfile` 的 12 个同量级。
 */
 const DANMAKU_MAX_RANGE_MS = 36e5;
 /**
@@ -11289,7 +8876,7 @@ const liveRoomInfo = defineKuaishouEndpoint({
 		description: "取直播间聚合信息（直播流、主播、公告等）；只看直播间时比 `userProfile` 轻。"
 	},
 	params: zod.default.object({ principalId: zod.default.string().min(1, { error: "principalId 不能为空" }).describe("用户 ID") }),
-	sign: "hxfalcon",
+	sign: [require_steps.hxfalcon()],
 	build: (p) => {
 		return {
 			method: "POST",
@@ -11539,7 +9126,7 @@ const userProfile$2 = defineKuaishouEndpoint({
 		description: "取用户主页聚合信息（资料、作品列表、直播间等）。部分数据取不到时留空，不整体失败。"
 	},
 	params: zod.default.object({ principalId: zod.default.string().min(1, { error: "principalId 不能为空" }).describe("用户 ID") }),
-	sign: "hxfalcon",
+	sign: [require_steps.hxfalcon()],
 	build: (p) => {
 		const principalId = p.principalId;
 		const refererPath = `profile/${encodeURIComponent(principalId)}`;
@@ -11642,7 +9229,7 @@ const userWorkList = defineKuaishouEndpoint({
 		principalId: zod.default.string().min(1, { error: "principalId 不能为空" }).describe("用户 ID"),
 		number: zod.default.coerce.number().int().min(1).max(500).optional().describe("目标条数，默认 12")
 	}),
-	sign: "hxfalcon",
+	sign: [require_steps.hxfalcon()],
 	build: (p) => {
 		return {
 			method: "POST",
@@ -11722,7 +9309,7 @@ const kuaishouRegistry = {
 			description: "日常取作品信息请用 `videoWork`；这条是唯一可能返回图集预渲染地址与同类推荐的通道。"
 		},
 		params: zod.default.object({ photoId: zod.default.string().min(1, { error: "photoId 不能为空" }).describe("作品 ID") }),
-		sign: "hxfalcon",
+		sign: [require_steps.hxfalcon()],
 		prepare: kuaishouDidPrepare,
 		build: (p) => {
 			const req = kuaishouApiUrls$1.videoWorkFull(p);
@@ -11968,7 +9555,7 @@ var kuaishouSign = class {
 		const secs = deriveKuaishouSecsState(count);
 		const scriptCount = globalThis.document?.scripts?.length ?? 0;
 		const catVersion = runtimeState.catVersion;
-		const signResult = deriveKuaishouPureSignature({
+		const signResult = require_steps.deriveKuaishouPureSignature({
 			count,
 			randomValue: Math.random(),
 			scriptCount,
@@ -12253,7 +9840,7 @@ const emojiList = defineXiaohongshuEndpoint({
 			signPath: apiPath
 		};
 	},
-	sign: "xhs-get",
+	sign: [require_steps.xs("get", "xys")],
 	response: type()
 });
 //#endregion
@@ -12284,8 +9871,8 @@ const homeFeed = defineXiaohongshuEndpoint({
 		search_key: zod.default.string().optional().describe("搜索关键词，默认空字符串")
 	}),
 	prepare: async (ctx) => {
-		if (getCookieValue(ctx.cookie, "a1")) return {};
-		return { cookie: await createXiaohongshuGuestCookie$1(ctx.send, ctx.requestConfig) };
+		if (require_steps.getCookieValue(ctx.cookie, "a1")) return {};
+		return { cookie: await require_steps.createXiaohongshuGuestCookie(ctx.send, ctx.requestConfig) };
 	},
 	build: (p) => {
 		const { Url, Body, apiPath } = homeFeed$1(p);
@@ -12296,7 +9883,7 @@ const homeFeed = defineXiaohongshuEndpoint({
 			signPath: apiPath
 		};
 	},
-	sign: "xhs-post-rap",
+	sign: [require_steps.xs("post", "xys"), require_steps.rap()],
 	response: type()
 });
 //#endregion
@@ -12319,6 +9906,7 @@ const noteComments = defineXiaohongshuEndpoint({
 		description: "取笔记评论列表。`number` 指定目标条数，翻页由端点自动完成。"
 	},
 	params: zod.default.object({
+		cursor: internalParam(zod.default.string().optional().describe("分页游标，由端点接管，不用传")),
 		note_id: zod.default.string().min(1, { error: "note_id 不能为空" }).describe("笔记 ID；从笔记分享链接里取"),
 		xsec_token: zod.default.string().min(1, { error: "xsec_token 不能为空" }).describe("反爬令牌，随笔记分享链接下发"),
 		number: zod.default.coerce.number().int().min(1).max(500).optional().describe("目标条数，默认一页")
@@ -12332,7 +9920,7 @@ const noteComments = defineXiaohongshuEndpoint({
 			extra: { signParams }
 		};
 	},
-	sign: "xhs-get-trace",
+	sign: [require_steps.xs("get", "xys"), require_steps.traceId()],
 	paginate: {
 		maxPageSize: 50,
 		items: (page) => page.data?.comments ?? [],
@@ -12378,7 +9966,7 @@ const noteDetail = defineXiaohongshuEndpoint({
 			signPath: apiPath
 		};
 	},
-	sign: "xhs-post-rap",
+	sign: [require_steps.xs("post", "xys"), require_steps.rap()],
 	response: type()
 });
 //#endregion
@@ -12402,7 +9990,7 @@ const searchNotes = defineXiaohongshuEndpoint({
 		page_size: zod.default.coerce.number().int().min(1).max(100).optional().describe("每页条数，默认 20")
 	}),
 	build: (p) => {
-		const { Url, Body, apiPath } = searchNotes$1(p, getSearchId());
+		const { Url, Body, apiPath } = searchNotes$1(p, require_steps.getSearchId());
 		return {
 			method: "POST",
 			url: Url,
@@ -12410,7 +9998,7 @@ const searchNotes = defineXiaohongshuEndpoint({
 			signPath: apiPath
 		};
 	},
-	sign: "xhs-post-rap",
+	sign: [require_steps.xs("post", "xys"), require_steps.rap()],
 	response: type()
 });
 //#endregion
@@ -12444,7 +10032,7 @@ const userNoteList = defineXiaohongshuEndpoint({
 			extra: { signParams }
 		};
 	},
-	sign: "xhs-get-xyw-trace",
+	sign: [require_steps.xs("get", "xyw"), require_steps.traceId()],
 	response: type()
 });
 //#endregion
@@ -12478,7 +10066,7 @@ const xiaohongshuRegistry = {
 				responseType: "text"
 			};
 		},
-		sign: "xhs-get",
+		sign: [require_steps.xs("get", "xys")],
 		decode: (raw) => {
 			if (typeof raw !== "string") return raw;
 			const match = raw.match(/<script>window\.__INITIAL_STATE__=(.+)<\/script>/m);
@@ -12596,7 +10184,7 @@ const unwrapScriptingResponse = (data) => {
 * scripting、webprofile 与 activate 三个会话请求，并返回最终 Cookie 字符串。
 */
 const createXiaohongshuGuestCookie = async (requestConfig) => {
-	const cryptoConfig = createXiaohongshuCryptoConfig();
+	const cryptoConfig = require_steps.createXiaohongshuCryptoConfig();
 	const signer = new _ikenxuan_xhshow_ts.Xhshow(cryptoConfig);
 	const cookies = {
 		...generateA1AndWebId(),
@@ -12650,7 +10238,7 @@ const createXiaohongshuGuestCookie = async (requestConfig) => {
 * 小红书签名算法类
 */
 var xiaohongshuSign = class {
-	static client = new _ikenxuan_xhshow_ts.Xhshow(createXiaohongshuCryptoConfig());
+	static client = new _ikenxuan_xhshow_ts.Xhshow(require_steps.createXiaohongshuCryptoConfig());
 	/**
 	* 创建包含 web_session 的小红书 Web 端游客 Cookie。
 	*
@@ -12713,7 +10301,7 @@ var xiaohongshuSign = class {
 	* @returns a1 cookie值
 	*/
 	static extractA1FromCookie(cookieString) {
-		return getCookieValue(cookieString, "a1") ?? "";
+		return require_steps.getCookieValue(cookieString, "a1") ?? "";
 	}
 	/**
 	* 生成搜索ID
@@ -53731,7 +51319,8 @@ const parametersOf = (def) => {
 		unrepresentable: "any"
 	});
 	const required = new Set(json.required ?? []);
-	return Object.entries(json.properties ?? {}).map(([name, schema]) => {
+	const internalKeys = internalParamKeysOf(def.params);
+	return Object.entries(json.properties ?? {}).filter(([name]) => !internalKeys.has(name)).map(([name, schema]) => {
 		const { description, ...rest } = schema;
 		return {
 			name,
@@ -54040,7 +51629,7 @@ const buildOpenApiSpec = (options = {}) => {
 		openapi: "3.1.0",
 		info: {
 			title: "amagi HTTP API",
-			version: options.version ?? "7.0.0-beta.5",
+			version: options.version ?? "7.0.0-beta.7",
 			description: [
 				"由端点注册表派生的规范 —— 手写的那份已经漂移，这份不会（`gen-openapi --check` 进 CI）。",
 				"",
@@ -54096,38 +51685,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,
@@ -54261,10 +51824,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 方法（小红书按它推默认签名器）
@@ -54273,16 +51841,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.default.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 }
@@ -54619,21 +52182,11 @@ const createStaticFetcher = (platform, registry) => {
 * ```typescript
 * import { bilibiliFetcher } from '@ikenxuan/amagi'
 *
+* const cookie = 'SESSDATA=xxx; bili_jct=yyy'
 * const result = await bilibiliFetcher.fetchVideoInfo({ bvid: 'BV1xx411c7mD' }, cookie)
 * ```
 */
 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
@@ -54839,6 +52392,7 @@ async function validatePassportVerifyCode(options, cookie, requestConfig) {
 * ```typescript
 * import { douyinFetcher } from '@ikenxuan/amagi'
 *
+* const cookie = 'ttwid=xxx'
 * const result = await douyinFetcher.fetchVideoWork({ aweme_id: '7123456789' }, cookie)
 * ```
 */
@@ -54856,6 +52410,8 @@ const douyinFetcher = {
 * @returns 绑定了 Cookie 的 Fetcher 对象，调用时无需传递 cookie
 * @example
 * ```typescript
+* import { createBoundDouyinFetcher } from '@ikenxuan/amagi'
+*
 * const fetcher = createBoundDouyinFetcher('your_cookie')
 * const result = await fetcher.fetchVideoWork({ aweme_id: '7123456789' })
 * ```
@@ -54877,21 +52433,11 @@ const createBoundDouyinFetcher = (cookie, requestConfig) => createFetcherFromReg
 * ```typescript
 * import { kuaishouFetcher } from '@ikenxuan/amagi'
 *
+* const cookie = 'did=xxx'
 * const result = await kuaishouFetcher.fetchVideoWork({ photoId: '3x123456789' }, cookie)
 * ```
 */
 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
@@ -54910,21 +52456,11 @@ const createBoundKuaishouFetcher = (cookie, requestConfig) => createFetcherFromR
 * ```typescript
 * import { xiaohongshuFetcher } from '@ikenxuan/amagi'
 *
+* const cookie = 'a1=xxx; web_session=xxx'
 * const result = await xiaohongshuFetcher.fetchNoteDetail({ note_id: 'n1', xsec_token: 'tk' }, cookie)
 * ```
 */
 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
@@ -55315,7 +52851,7 @@ const DouyinValidationSchemas = {
 		aweme_id: zod.default.string({ error: "视频ID必须是字符串" }).min(1, { error: "视频ID不能为空" }),
 		start_time: zod.default.coerce.number({ error: "开始时间必须是数字" }).int({ error: "开始时间必须是整数" }).min(0, { error: "开始时间不能小于0" }).optional(),
 		end_time: zod.default.coerce.number({ error: "结束时间必须是数字" }).int({ error: "结束时间必须是整数" }).min(0, { error: "结束时间不能小于0" }).optional(),
-		duration: zod.default.coerce.number({ error: "视频时长必须是数字" }).int({ error: "视频时长必须是整数" }).min(0, { error: "视频时长不能小于0" })
+		duration: zod.default.coerce.number({ error: "视频时长必须是数字" }).int({ error: "视频时长必须是整数" }).min(0, { error: "视频时长不能小于0" }).max(DANMAKU_MAX_DURATION_MS, { error: "作品总时长不能超过 7 天" })
 	}).refine((data) => {
 		if (data.end_time !== void 0) return data.end_time <= data.duration;
 		return true;
@@ -56863,7 +54399,7 @@ let DynamicType = /* @__PURE__ */ function(DynamicType) {
 * 构建后使用 __VERSION__，开发环境从 package.json 读取
 */
 const getVersion = () => {
-	return "7.0.0-beta.5";
+	return "7.0.0-beta.7";
 };
 const VERSION = getVersion();
 /**