progmune-runtime 3.7.52 → 3.7.54

package/dist/protocol-detector-credential-issuance.test.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * §46 ① 凭签发入口豁免（credential_issuance）—— 语义与对称性
+ *
+ * 背景：`create_access_token|create_refresh_token|create_jwt_token` 只存在于
+ * `Authorization (Unauthenticated Mutation)` 的 auth_check 词表里，`Access` 没有。
+ * §45 做集合 diff 时发现过，当时以「签发 ≠ 校验调用者」为由没有补进去。§46 把这三个词
+ * 从 auth_check **移出**，单独成立一条 `credential_issuance` safeguard（行为不变，语义自洽）。
+ *
+ * 本文件钉住三件事：
+ *   1. 写类函数调用签发函数 ⇒ 豁免（login/register 入口天然不需要事前认证）
+ *   2. 读类函数调用签发函数 ⇒ **仍报**（不对称 —— R66：同形状存在相反真值）
+ *   3. 它压的是「入口」而非「认证」：与真正的 auth_check 不是一回事
+ *
+ * ⚠ 名字必须避开 §39 AUTH_PATTERN：ownName/calls 含 User/Token/Auth 会被
+ *   「鉴权机制自身」抢先压掉，测不出本机制（R65 唯一压制来源）。
+ */
+const vitest_1 = require("vitest");
+const protocol_detector_1 = require("./protocol-detector");
+/** 只取 Authorization 族，避免别的规则干扰断言 */
+const az = (calls, own) => (0, protocol_detector_1.detectSafeguardViolations)(calls, own, "typescript", ["user"], false, ["AuthUser"])
+    .filter((v) => v.rule.startsWith("Authorization"))
+    .map((v) => v.rule);
+(0, vitest_1.describe)("§46 ① credential_issuance —— 写类豁免", () => {
+    (0, vitest_1.it)("写类 + create_access_token ⇒ 免（登录/注册入口天然无需事前认证）", () => {
+        (0, vitest_1.expect)(az(["create_access_token", "save"], "createThing")).toHaveLength(0);
+    });
+    (0, vitest_1.it)("写类 + create_jwt_token ⇒ 免", () => {
+        (0, vitest_1.expect)(az(["create_jwt_token", "save"], "createThing")).toHaveLength(0);
+    });
+    (0, vitest_1.it)("写类 + create_refresh_token ⇒ 免", () => {
+        (0, vitest_1.expect)(az(["create_refresh_token", "save"], "createThing")).toHaveLength(0);
+    });
+    (0, vitest_1.it)("反向对照：写类 + 无签发/无认证 ⇒ 仍报", () => {
+        (0, vitest_1.expect)(az(["save", "insert"], "createThing")).toContain("Authorization (Unauthenticated Mutation)");
+    });
+});
+(0, vitest_1.describe)("§46 ① credential_issuance —— 不得对称补进读类（R66）", () => {
+    (0, vitest_1.it)("读类 + create_access_token ⇒ 仍报 Unauthenticated Access", () => {
+        // 若将来有人按「词表对齐」把 mint 补进 Access 词表，这条会转红 —— 那正是要拦的改动。
+        // 理由：调用 create_access_token 说明该函数**在签发**令牌，而不是校验调用者；
+        //       getRefreshToken(userId) 与 getUserToken(userId) 在这个轴上完全同形。
+        (0, vitest_1.expect)(az(["create_access_token", "query"], "getThing")).toContain("Authorization (Unauthenticated Access)");
+    });
+    (0, vitest_1.it)("读类 + create_jwt_token ⇒ 仍报", () => {
+        (0, vitest_1.expect)(az(["create_jwt_token", "query"], "getThing")).toContain("Authorization (Unauthenticated Access)");
+    });
+    (0, vitest_1.it)("读类 + 无认证 ⇒ 仍报（口径不变）", () => {
+        (0, vitest_1.expect)(az(["query", "find"], "getThing")).toContain("Authorization (Unauthenticated Access)");
+    });
+});
+(0, vitest_1.describe)("§46 ① 签发 ≠ 认证 —— 机制归属", () => {
+    (0, vitest_1.it)("真正的认证调用在读写两类上都豁免（对照）", () => {
+        (0, vitest_1.expect)(az(["getSession", "save"], "createThing")).toHaveLength(0);
+        (0, vitest_1.expect)(az(["getSession", "query"], "getThing")).toHaveLength(0);
+    });
+    (0, vitest_1.it)("签发调用只在写类上豁免 ⇒ 两者不是同一类证据", () => {
+        const mutation = az(["create_access_token", "save"], "createThing");
+        const access = az(["create_access_token", "query"], "getThing");
+        (0, vitest_1.expect)(mutation).toHaveLength(0);
+        (0, vitest_1.expect)(access.length).toBeGreaterThan(0);
+    });
+});

package/dist/protocol-detector-owner-self.test.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * §46 ② owner_self_assigned —— 资源属主被赋值为当前主体
+ *
+ * 背景：`Authorization (Ownership Check)` 报「改了别人的东西」，但合成语料上有 12 条
+ * FP，成因一致：函数**新建**资源并把属主设为当前主体
+ * （`const item = { ..., ownerId: user.id }`）—— 被操作对象就是自己，谈不上越权。
+ *
+ * 机制：extract-ir 注入 `__progmune_owner_self_assigned__` 标记（对象字面量里的
+ * `<属主字段>: <主体>.id`），Ownership Check 的 safeguard 消费它。
+ *
+ * 本文件钉住：
+ *   1. 有标记 ⇒ 豁免
+ *   2. 无标记 ⇒ 仍报（反向对照，防止无条件抑制）
+ *   3. **不认**「主体标识作实参」形态 —— 那是 R66 否决的形状（见下）
+ *
+ * ⚠ R66 的边界（为什么不做 `<调用>(…, user.id, …)`）：
+ *   真实池 `deletePAT(id, user.uid)` 是 FP（已按属主过滤），
+ *   合成语料 `deleteWidget` 里 `canSendEmail(user.id)` 是 TP（user.id 与 deleteWidget 无关）。
+ *   同形状、相反真值 ⇒ 主体标识作实参这一轴不具备判别力，不得落地。
+ *   只认对象字面量里的**绑定**（`userId:` 后跟主体），不认调用实参。
+ */
+const vitest_1 = require("vitest");
+const protocol_detector_1 = require("./protocol-detector");
+const own = (calls, name) => (0, protocol_detector_1.detectSafeguardViolations)(calls, name, "typescript", ["user"], false, ["AuthUser"])
+    .filter((v) => v.rule === "Authorization (Ownership Check)");
+const MARK = "__progmune_owner_self_assigned__";
+(0, vitest_1.describe)("§46 ② owner_self_assigned —— 属主即主体", () => {
+    (0, vitest_1.it)("带标记 ⇒ 豁免（新建资源属主 = 当前主体）", () => {
+        (0, vitest_1.expect)(own(["getUser", "push", MARK], "createTransfer")).toHaveLength(0);
+    });
+    (0, vitest_1.it)("反向对照：无标记 ⇒ 仍报", () => {
+        (0, vitest_1.expect)(own(["getUser", "push"], "createTransfer")).toHaveLength(1);
+    });
+    (0, vitest_1.it)("反向对照：删除类无标记 ⇒ 仍报（不能被顺带压掉）", () => {
+        (0, vitest_1.expect)(own(["getUser", "findIndex", "splice"], "deleteTransfer")).toHaveLength(1);
+    });
+});
+(0, vitest_1.describe)("§46 ② 边界 —— 只认绑定形态，不认实参形态（R66）", () => {
+    (0, vitest_1.it)("主体标识作实参、但无标记 ⇒ 仍报", () => {
+        // deleteWidget(widgetId, user) { canSendEmail(user.id); repo.deleteWidget(widgetId); }
+        // 这是真 TP：user.id 与 deleteWidget 无关。没有标记 ⇒ 不得豁免。
+        (0, vitest_1.expect)(own(["canSendEmail", "deleteWidget"], "deleteWidget")).toHaveLength(1);
+    });
+    (0, vitest_1.it)("带标记时豁免，与函数名无关", () => {
+        (0, vitest_1.expect)(own(["canSendEmail", "deleteWidget", MARK], "deleteWidget")).toHaveLength(0);
+    });
+});
+(0, vitest_1.describe)("§46 ② 既有 ownership 证据不受影响", () => {
+    (0, vitest_1.it)("内联属主比较（__progmune_ownership_checked__）仍然豁免", () => {
+        (0, vitest_1.expect)(own(["getUser", "__progmune_ownership_checked__"], "deleteTransfer")).toHaveLength(0);
+    });
+    (0, vitest_1.it)("ownerId 比较写法仍然豁免（不加标记也行）", () => {
+        (0, vitest_1.expect)(own(["getUser", "checkOwner"], "deleteTransfer")).toHaveLength(0);
+    });
+});

package/dist/protocol-detector-paramgate.test.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * §44（2026-09-26）`paramGated` 区分「调用者主体」与「被操作对象」—— 正/反向 fixture
+ *
+ * 为什么必须有这个文件：§43 已经证明盲测语料对 Authorization 抑制类改动**长期零覆盖**
+ * （R62 / R56）。本轮改的是 `paramGated` 这条**门**（6 条规则共用），合成语料里
+ * 既没有 `token: string` 这种"被操作对象当身份"的形态，也没有 `user: User` 的对照，
+ * ⇒ 光靠闸门会全绿但一条都没触发。这里的 fixture 是它唯一的覆盖。
+ *
+ * 真值来源（blind-benchmark/reports/paramgate-probe.json，全池 66 条 paramGated 违规）：
+ *   压掉的 8 条 = 6 verified FP + 2 heuristic FP，**TP 0 / UNKNOWN 0**
+ *     - updateLastUsedForPAT(token: string)      ← 被操作的 PAT（hoppscotch）
+ *     - resolveRemoteUser(config: Config, token: string)（verdaccio）
+ *     - verifyJWTPayload(token: string, …)       （verdaccio）
+ *     - setAuthCookie(res: FastifyReply, token: string)（docmost）
+ *   保留的（反例侧）：
+ *     - removeUserAvatar(user: User) / createPAT(dto, user: AuthUser) ← 主体是领域对象
+ *     - JwtAuthGuard.handleRequest(err: any, user: any, …) ← 类型解析不出来 ⇒ 保守放行
+ */
+const vitest_1 = require("vitest");
+const protocol_detector_1 = require("./protocol-detector");
+/** 只看 4 条 Authorization（本轮 paramGated 收紧影响的就是这几条） */
+const authz = (calls, fnName, params, paramTypes, exposed = false) => (0, protocol_detector_1.detectSafeguardViolations)(calls, fnName, "typescript", params, exposed, paramTypes).filter((v) => v.category === "authorization");
+(0, vitest_1.describe)("§44 classifyParamType —— 三分类", () => {
+    (0, vitest_1.it)("标量 ⇒ scalar", () => {
+        (0, vitest_1.expect)((0, protocol_detector_1.classifyParamType)("string")).toBe("scalar");
+        (0, vitest_1.expect)((0, protocol_detector_1.classifyParamType)("number")).toBe("scalar");
+        (0, vitest_1.expect)((0, protocol_detector_1.classifyParamType)("boolean")).toBe("scalar");
+        (0, vitest_1.expect)((0, protocol_detector_1.classifyParamType)("string[]")).toBe("scalar");
+    });
+    (0, vitest_1.it)("领域类型 ⇒ typed", () => {
+        (0, vitest_1.expect)((0, protocol_detector_1.classifyParamType)("User")).toBe("typed");
+        (0, vitest_1.expect)((0, protocol_detector_1.classifyParamType)("AuthUser")).toBe("typed");
+        (0, vitest_1.expect)((0, protocol_detector_1.classifyParamType)("Admin")).toBe("typed");
+        (0, vitest_1.expect)((0, protocol_detector_1.classifyParamType)("ExecutionContext")).toBe("typed");
+    });
+    (0, vitest_1.it)("解析不出来 ⇒ unknown（保守，不收紧）", () => {
+        (0, vitest_1.expect)((0, protocol_detector_1.classifyParamType)("any")).toBe("unknown");
+        (0, vitest_1.expect)((0, protocol_detector_1.classifyParamType)("unknown")).toBe("unknown");
+        (0, vitest_1.expect)((0, protocol_detector_1.classifyParamType)("")).toBe("unknown");
+        (0, vitest_1.expect)((0, protocol_detector_1.classifyParamType)("null")).toBe("unknown");
+    });
+    (0, vitest_1.it)("联合类型按「含领域类型即 typed」处理", () => {
+        (0, vitest_1.expect)((0, protocol_detector_1.classifyParamType)("User | null")).toBe("typed");
+        (0, vitest_1.expect)((0, protocol_detector_1.classifyParamType)("AuthenticationType | null")).toBe("typed");
+        (0, vitest_1.expect)((0, protocol_detector_1.classifyParamType)("string | null")).toBe("scalar");
+        // 含 any 的联合不敢判标量 ⇒ typed（保守放行）
+        (0, vitest_1.expect)((0, protocol_detector_1.classifyParamType)("any | User")).toBe("typed");
+    });
+});
+(0, vitest_1.describe)("§44 正对照 —— 唯一的身份线索是标量 ⇒ 那是被操作对象，不是调用者", () => {
+    (0, vitest_1.it)("updateLastUsedForPAT(token: string) 应被 paramGated 挡下", () => {
+        // hoppscotch：被操作的是要更新 lastUsed 的那个 PAT，不是调用者凭证
+        (0, vitest_1.expect)(authz(["extractUUID", "left", "update", "right", "cast"], "updateLastUsedForPAT", ["token"], ["string"])).toHaveLength(0);
+    });
+    // ⚠ 两条曾用真名 `resolveRemoteUser` / `verifyJWTPayload`，反向验证时**没转红**
+    //   ⇒ 它们是被 safeguard（`jwtVerify` / 自身名里的 `verify`）压掉的，不是被
+    //   paramGated 压掉的 —— 按 R64/R65 是**假绿**，必须换成能真正压在门上的形态。
+    (0, vitest_1.it)("updateRemoteUser(config: Config, token: string) 应被挡下", () => {
+        // 形态同 verdaccio resolveRemoteUser：token 是待解析的入参，不是调用者凭证
+        (0, vitest_1.expect)(authz(["readFileSync", "split", "at"], "updateRemoteUser", ["config", "token"], ["Config", "string"])).toHaveLength(0);
+    });
+    // ⚠ 第二版曾用 `rotateSecretValue` —— 反向验证也没转红：`rotate` 不在
+    //   Authorization 的 trigger 动词表里，规则压根没触发 ⇒ 恒绿，还是假绿。
+    (0, vitest_1.it)("updateSecretValue(token: string, secret: string) 应被挡下", () => {
+        (0, vitest_1.expect)(authz(["split", "at", "concat"], "updateSecretValue", ["token", "secret"], ["string", "string"])).toHaveLength(0);
+    });
+});
+(0, vitest_1.describe)("§44 反向对照 —— 主体参数必须仍然放行（不能变成无条件抑制）", () => {
+    (0, vitest_1.it)("removeUserAvatar(user: User) 仍应报 —— 主体是领域对象", () => {
+        (0, vitest_1.expect)(authz(["getAttachmentFolderPath", "deleteRedundantFile", "updateUser"], "removeUserAvatar", ["user"], ["User"])).not.toHaveLength(0);
+    });
+    (0, vitest_1.it)("createPAT(dto, user: AuthUser) 仍应报", () => {
+        (0, vitest_1.expect)(authz(["isValidLength", "create", "cast"], "createPAT", ["dto", "user"], ["CreateAccessTokenDto", "AuthUser"])).not.toHaveLength(0);
+    });
+    (0, vitest_1.it)("user: any 仍应报 —— 类型解析不出来时保守放行（R57：退回旧行为，不是一律压）", () => {
+        // ⚠ 函数名不能用 generateJWT —— 它是 isAuthFunctionName 的鉴权机制自身，
+        //    authorization 规则对它整体跳过，测不出 paramGated 的门。
+        (0, vitest_1.expect)(authz(["findOne", "save"], "updateProfile", ["user"], ["any"])).not.toHaveLength(0);
+    });
+    (0, vitest_1.it)("user 是标量 string 但函数 exposed ⇒ 仍应报（exposed 是独立的入口证据）", () => {
+        (0, vitest_1.expect)(authz(["update", "save"], "updateProfile", ["user"], ["string"], true)).not.toHaveLength(0);
+    });
+    (0, vitest_1.it)("不传 paramTypes ⇒ 完全保持旧行为（零漂移）", () => {
+        // 旧行为：参数名命中 identity 词表即通过门 ⇒ token 也放行
+        (0, vitest_1.expect)(authz(["update", "save"], "updateLastUsedForPAT", ["token"])).not.toHaveLength(0);
+    });
+});
+(0, vitest_1.describe)("§44 IDENTITY_PARAM_RE —— 与旧内联正则同源", () => {
+    (0, vitest_1.it)("命中身份词（必须是**独立单词**）", () => {
+        for (const n of ["user", "token", "session", "role", "request", "credential", "identity"]) {
+            (0, vitest_1.expect)(protocol_detector_1.IDENTITY_PARAM_RE.test(n)).toBe(true);
+        }
+    });
+    (0, vitest_1.it)("复合词一律不算 —— 词边界使然，这是**既有行为**不是本轮引入", () => {
+        // ⚠ 顺带记一笔项目债：最地道的 NestJS 主体参数名 `authUser` / `currentUser`
+        //   **也不命中**（\buser\b 在 authUser 里没有左边界）。也就是说 paramGated
+        //   目前只认 `user` / `token` / `auth` 这类裸标识符。本轮不改（避免与收紧
+        //   混在一起），但它是"主体识别"这条轴的下一处缺口。
+        for (const n of ["userEmail", "userId", "userRepo", "authUser", "currentUser", "req", "ctx"]) {
+            (0, vitest_1.expect)(protocol_detector_1.IDENTITY_PARAM_RE.test(n)).toBe(false);
+        }
+    });
+});

package/dist/protocol-detector-session-param.test.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * §47：签名级会话证据 —— 参数类型以 `Session` 结尾 ⇒ 「未认证」结论不成立。
+ *
+ * 为什么不是继续在 calls 里找 auth 词：hedgedoc 的 pending-user 三个接口 +
+ * OidcController.callback 都是 `@UseGuards(SessionGuard)` 保护的会话类路由，
+ * 但它们**一个认证函数都不调用** —— 身份是从 `request.session.*` 上取的，
+ * 调用列表里只有 property access，选择器读不到。真实池里这四条全是人工确认的 FP。
+ *
+ * 改用**参数类型**：签名上存在 session 对象 ⇒ 这次调用必然落在某个会话上下文里。
+ * 好处是它来自 AST 签名，不依赖调用图连通（fp-pool 入边 0 的函数占 36%~42%，
+ * 依赖 calls 的机制在那里会静默失效）。
+ *
+ * ⚠ R66 的否命题在本文件 §47 反向② 组：
+ *   有会话 ≠ 操作对象属于自己。越权读取的同形状反例必须 Unauthenticated 熄灭
+ *   而 **Ownership 继续亮**，否则这一刀就是把越权漏洞洗白。
+ */
+const vitest_1 = require("vitest");
+const protocol_detector_1 = require("./protocol-detector");
+const ACC = "Authorization (Unauthenticated Access)";
+const MUT = "Authorization (Unauthenticated Mutation)";
+const OWN = "Authorization (Ownership Check)";
+const RES = "Authorization (Resource Ownership)";
+/** lang 固定 typescript；params/paramTypes 逐用例给定 */
+function fire(calls, name, params, paramTypes) {
+    const vs = (0, protocol_detector_1.detectSafeguardViolations)(calls, name, "typescript", params, false, paramTypes);
+    return new Set(vs.map((v) => v.rule));
+}
+const lit = (b) => (b ? "fires" : "silent");
+(0, vitest_1.describe)("§47 正向：签名带会话 ⇒ Unauthenticated 两条熄灭（hedgedoc 真实 FP）", () => {
+    (0, vitest_1.it)("getPendingUserData(request: RequestWithSession) 不再报未认证读取", () => {
+        const s = fire(["create"], "getPendingUserData", ["request"], ["RequestWithSession"]);
+        (0, vitest_1.expect)(lit(s.has(ACC))).toBe("silent");
+    });
+    (0, vitest_1.it)("confirmPendingUserData(request: RequestWithSession, dto) 不再报未认证变更", () => {
+        const s = fire(["createUserWithIdentityFromPendingUserConfirmation", "save"], "confirmPendingUserData", ["request", "pendingUserConfirmationData"], ["RequestWithSession", "PendingUserConfirmationDto"]);
+        (0, vitest_1.expect)(lit(s.has(MUT))).toBe("silent");
+    });
+    (0, vitest_1.it)("OidcController.callback —— session 不在第一个参数也算数", () => {
+        const s = fire(["extractUserInfoFromCallback", "getExistingOidcIdentity", "mayUpdateIdentity", "save"], "OidcController.callback", ["oidcIdentifier", "request"], ["string", "RequestWithSession"]);
+        (0, vitest_1.expect)(lit(s.has(ACC))).toBe("silent");
+        (0, vitest_1.expect)(lit(s.has(MUT))).toBe("silent");
+    });
+    (0, vitest_1.it)("裸 Session 类型同样成立（不要求 Request 前缀）", () => {
+        const s = fire(["find"], "getProfile", ["session"], ["Session"]);
+        (0, vitest_1.expect)(lit(s.has(ACC))).toBe("silent");
+    });
+});
+(0, vitest_1.describe)("§47 反向①：摘掉这一刀必须重新亮（证明是它在压，不是别机制抢先）", () => {
+    (0, vitest_1.it)("同函数把 RequestWithSession 换成 Request ⇒ 未认证读取重新报", () => {
+        const s = fire(["create"], "getPendingUserData", ["request"], ["Request"]);
+        (0, vitest_1.expect)(lit(s.has(ACC))).toBe("fires");
+    });
+    // 注意这里**不是** §47 在压：`request` 的类型退化成标量后，是 §44 的 paramGated
+    // 先把规则整体跳过了（标量参数不算身份证据）。单独留一条是为了把两层闸门的关系钉住：
+    // 类型通道同时喂给 paramGate（§44）和 paramTypeSafeguards（§47），
+    // 断言这一条可以防止以后有人误以为「类型一变就该亮」。
+    (0, vitest_1.it)("request:string 时由 §44 paramGate 先行跳过 —— 记录两层闸门的先后关系", () => {
+        const s = fire(["createUserWithIdentityFromPendingUserConfirmation", "save"], "confirmPendingUserData", ["request", "pendingUserConfirmationData"], ["string", "PendingUserConfirmationDto"]);
+        (0, vitest_1.expect)(lit(s.has(MUT))).toBe("silent");
+    });
+    (0, vitest_1.it)("不传类型通道时退回旧行为（仍报）—— R57 要求通道不可用时不得静默压", () => {
+        const vs = (0, protocol_detector_1.detectSafeguardViolations)(["create"], "getPendingUserData", "typescript", ["request"]);
+        (0, vitest_1.expect)(lit(vs.some((v) => v.rule === ACC))).toBe("fires");
+    });
+});
+(0, vitest_1.describe)("§47 反向②：有会话 ≠ 有权 —— 越权形态的 Unauthenticated 熄灭但 Ownership 必须继续亮", () => {
+    (0, vitest_1.it)("removeSharedFile(req: RequestWithSession, id) —— 归属检查不能随会话一起被免掉", () => {
+        const s = fire(["findById", "removeFile"], "removeSharedFile", ["request", "id"], ["RequestWithSession", "string"]);
+        (0, vitest_1.expect)(lit(s.has(MUT))).toBe("silent");
+        (0, vitest_1.expect)(lit(s.has(OWN))).toBe("fires");
+    });
+    (0, vitest_1.it)("deleteOtherUsersNote(session: Session, noteId) —— Resource Ownership 必须继续亮", () => {
+        const s = fire(["findNote", "deleteNote"], "deleteOtherUsersNote", ["session", "noteId"], ["Session", "string"]);
+        (0, vitest_1.expect)(lit(s.has(MUT))).toBe("silent");
+        (0, vitest_1.expect)(lit(s.has(OWN) || s.has(RES))).toBe("fires");
+    });
+});
+(0, vitest_1.describe)("§47 边界：类型名不得以 Session 收尾就被误当成会话", () => {
+    const cases = [
+        ["Transaction", " mutation"],
+        ["SessionOptions", "配置对象不是会话本身"],
+        ["Partial<AuthConf>", "verdaccio addAuth 的真类型"],
+        ["Knex", "查询构造器"],
+    ];
+    for (const [type, why] of cases) {
+        (0, vitest_1.it)(`${type} 不应被当作会话（${why.trim()}）`, () => {
+            const s = fire(["merge"], "addAuth", ["auth"], [type]);
+            (0, vitest_1.expect)(lit(s.has(MUT))).toBe("fires");
+        });
+    }
+});