@oj-module/cli 0.2.18 → 0.2.23

package/templates/{api/tests → tests}/auth-throttle.spec.ts

@@ -5,7 +5,7 @@
 /* eslint-disable test/prefer-lowercase-title -- AC 编号是验收锚点，保留大写 */
 import { afterEach, beforeAll, describe, expect, it } from "vitest";
 
-import { loginBlocked, loginFailed, loginSucceeded, resetLoginThrottle } from "../src/_platform/_shared/service/infra/rate";
+import { loginBlocked, loginFailed, loginSucceeded, resetLoginThrottle } from "../src/_platform/api/_shared/service/infra/rate";
 import { installDb } from "./fixture";
 
 let dbo: ReturnType<typeof installDb>;

package/templates/tests/fixture.ts

@@ -0,0 +1,434 @@
+// 后端 BDD 夹具：node:sqlite 内存库 + **真实迁移文件**建表，装到 globalThis.db——
+// 与 oj 运行时注入的全局同名同面，service 代码不改一行即可被测。
+// 夹具直接读 src/<模块>/api/migrations/*.sql，与迁移不可能漂移（沿用 oj-wiki 先例）。
+//
+// **构造器垫片（db.table / listTables）**：oj 的构造器是二进制内的 Rust 实现，Node 侧无可复用
+// 模块，故这里按手册契约（oj-api-dev api-manual「查询构造器」）写一层**最小 JS 渲染层**——
+// 只覆盖模板后端真正用到的面：select（含聚合 / distinct / lit）/ as / join（列对列 + 列对值）/
+// where / whereIf / groupBy / orderBy / limit / offset / union / insert（含 orIgnore、returning）/ update /
+// delete / truncate / all / run / listTables。子集外的调用**直接报「未实现」**，不静默返回空结果
+// （静默空值会把「垫片缺能力」伪装成「业务没数据」，是最难查的一类假绿）。
+//
+// 已知边界（模板当前用不到，不模拟）：租户/归属守卫（`tenant_id` 注入、`owner_of`）——模板是单租户，
+// 开启多租户后本夹具必先补这两条，否则守卫失效也会绿。
+//
+// 分工不变：
+//   · L2（本目录 *.spec.ts）：构造器渲染出**语义等价**的 SQL 后在真 sqlite 上跑——服务层行为、
+//     参数化、AND 串联、IN/LIKE 转义、聚合分组、limit/offset 都在这一层钉。
+//   · L1（同目录 *.test.ts，`oj test` 收集）：真 v8 + 真构造器，守 oj 的方言渲染（样板见
+//     tests/l1-builder.test.ts；方法论见 devkit oj-test-guide.md）。
+import { createRequire } from "node:module";
+
+const req = createRequire(import.meta.url);
+const { DatabaseSync } = req("node:sqlite");
+const { readdirSync, readFileSync, existsSync } = req("node:fs");
+const { join, dirname } = req("node:path");
+const { fileURLToPath } = req("node:url");
+
+const SRC = join(dirname(fileURLToPath(import.meta.url)), "..", "src");
+
+export const ADMIN = 1;
+
+/** 标识符加引号（保留字列名如 `order` / `group` / `count` 全按字面量处理；`表.列` 逐段加） */
+function quoteIdent(name: string): string {
+	return name.split(".").map(p => `"${p.replace(/"/g, "\"\"")}"`).join(".");
+}
+
+/** LIKE 转义符：与 oj 同口径（`!`），`contains`/`startswith`/`endswith` 自动转义 `%` `_` `!` */
+const LIKE_ESCAPE = "!";
+
+function escapeLike(value: string): string {
+	return value.replace(/[!%_]/g, c => `${LIKE_ESCAPE}${c}`);
+}
+
+const COMPARE_OPS: Record<string, string> = { eq: "=", ne: "<>", gt: ">", gte: ">=", lt: "<", lte: "<=" };
+
+interface Compiled { sql: string, params: unknown[] }
+
+/** 条件树 → SQL 片段（叶子 {field, op, value}；组 {and}/{or}/{not}） */
+function compileWhere(cond: any): Compiled {
+	if (cond && typeof cond === "object" && "field" in cond) {
+		const field = quoteIdent(String(cond.field));
+		const op = String(cond.op ?? "eq").toLowerCase();
+		const value = cond.value;
+		if (op === "isnull")
+			return { sql: `${field} IS NULL`, params: [] };
+		if (op === "in") {
+			const list = Array.isArray(value) ? value : [value];
+			// 与 oj 同口径：空数组早抛（`IN ()` 是永久假谓词，静默 0 行与「无匹配」不可区分；
+			// 动态过滤请走 whereIf，它会跳过空数组）
+			if (list.length === 0)
+				throw new Error("[fixture] in needs non-empty array");
+			return { sql: `${field} IN (${list.map(() => "?").join(", ")})`, params: list };
+		}
+		if (op === "contains" || op === "startswith" || op === "endswith") {
+			const escaped = escapeLike(String(value));
+			const pattern = op === "contains" ? `%${escaped}%` : op === "startswith" ? `${escaped}%` : `%${escaped}`;
+			return { sql: `${field} LIKE ? ESCAPE '${LIKE_ESCAPE}'`, params: [pattern] };
+		}
+		if (op === "like") {
+			// `like` 的模式由调用方负责成形；`escape` 逃生舱（白名单 ! / | ~ # @）原样渲染
+			const esc = cond.escape as string | undefined;
+			return esc
+				? { sql: `${field} LIKE ? ESCAPE '${esc}'`, params: [value] }
+				: { sql: `${field} LIKE ?`, params: [value] };
+		}
+		const sqlOp = COMPARE_OPS[op];
+		if (!sqlOp)
+			throw new Error(`[fixture] db.table 的 where op 未实现：${op}`);
+		return { sql: `${field} ${sqlOp} ?`, params: [value] };
+	}
+	if (cond && typeof cond === "object" && Array.isArray(cond.and)) {
+		const parts = cond.and.map(compileWhere);
+		return { sql: parts.map(p => `(${p.sql})`).join(" AND "), params: parts.flatMap(p => p.params) };
+	}
+	if (cond && typeof cond === "object" && Array.isArray(cond.or)) {
+		const parts = cond.or.map(compileWhere);
+		return { sql: parts.map(p => `(${p.sql})`).join(" OR "), params: parts.flatMap(p => p.params) };
+	}
+	if (cond && typeof cond === "object" && cond.not) {
+		const part = compileWhere(cond.not);
+		return { sql: `NOT (${part.sql})`, params: part.params };
+	}
+	throw new Error(`[fixture] db.table 的 where 条件形状未实现：${JSON.stringify(cond)}`);
+}
+
+interface SelectItem { fn?: string, field?: string, as?: string, distinct?: boolean, lit?: unknown }
+type Col = string | SelectItem;
+
+interface QueryState {
+	table: string
+	alias: string | null
+	cols: Col[] | null
+	distinct: boolean
+	joins: Array<{ table: string, on: any[], kind: "inner" | "left", alias: string | null }>
+	wheres: any[]
+	having: any[]
+	groups: string[]
+	orders: Array<{ field: string, dir?: string | null }>
+	limit: number | null
+	offset: number | null
+	verb: "select" | "insert" | "update" | "delete" | "truncate"
+	values: unknown
+	sets: unknown
+	orIgnore: boolean
+	returning: string[] | null
+	union: { other: FakeQuery, kind: "all" | "distinct" } | null
+}
+
+/**
+ * 最小构造器：命令式链式调用（每个方法返回自身，与 oj 的 builder 一致——业务代码里
+ * `const q = db.table(...).where(...)` 后接 `q.union(...)` 的写法依赖这个语义）。
+ */
+class FakeQuery {
+	private readonly s: QueryState;
+
+	constructor(private readonly dbo: any, table: string, seed?: Partial<QueryState>) {
+		this.s = {
+			table,
+			alias: null,
+			cols: null,
+			distinct: false,
+			joins: [],
+			wheres: [],
+			having: [],
+			groups: [],
+			orders: [],
+			limit: null,
+			offset: null,
+			verb: "select",
+			values: null,
+			sets: null,
+			orIgnore: false,
+			returning: null,
+			union: null,
+			...seed,
+		};
+	}
+
+	/** 基表别名（列限定写 `b.col`；只影响 select/join 渲染） */
+	as(alias: string): this {
+		this.s.alias = alias;
+		return this;
+	}
+
+	select(cols: Col[]): this {
+		this.s.cols = cols;
+		return this;
+	}
+
+	distinct(): this {
+		this.s.distinct = true;
+		return this;
+	}
+
+	join(table: string, on: any[], kind: "inner" | "left" = "inner", alias?: string): this {
+		this.s.joins.push({ table, on, kind, alias: alias ?? null });
+		return this;
+	}
+
+	where(cond: any): this {
+		this.s.wheres.push(cond);
+		return this;
+	}
+
+	/** 条件化 where：`undefined`/`null`/`false`/空数组整条跳过（`0` 与 `""` 是合法值，保留） */
+	whereIf(test: unknown, cond: any): this {
+		const skip = test === undefined || test === null || test === false || (Array.isArray(test) && test.length === 0);
+		if (!skip)
+			this.s.wheres.push(cond);
+		return this;
+	}
+
+	having(cond: any): this {
+		this.s.having.push(cond);
+		return this;
+	}
+
+	groupBy(cols: string[]): this {
+		this.s.groups.push(...cols);
+		return this;
+	}
+
+	orderBy(items: Array<{ field: string, dir?: string | null }>): this {
+		this.s.orders.push(...items);
+		return this;
+	}
+
+	limit(n: number): this {
+		this.s.limit = n;
+		return this;
+	}
+
+	offset(n: number): this {
+		this.s.offset = n;
+		return this;
+	}
+
+	/** 合并两条 select（UNION [ALL]）；外层 orderBy/limit/offset 作用于合并结果 */
+	union(other: FakeQuery, kind: "all" | "distinct" = "distinct"): this {
+		this.s.union = { other, kind };
+		return this;
+	}
+
+	insert(values: unknown): this {
+		this.s.verb = "insert";
+		this.s.values = values;
+		return this;
+	}
+
+	update(sets: unknown): this {
+		this.s.verb = "update";
+		this.s.sets = sets;
+		return this;
+	}
+
+	delete(): this {
+		this.s.verb = "delete";
+		return this;
+	}
+
+	truncate(): this {
+		this.s.verb = "truncate";
+		return this;
+	}
+
+	orIgnore(): this {
+		this.s.orIgnore = true;
+		return this;
+	}
+
+	/** insert 取回列（`run()` 改返回行数组，不返回行数）；select/update/delete 不接受 */
+	returning(cols: string[]): this {
+		if (this.s.verb !== "insert")
+			throw new Error(`[fixture] ${this.s.verb} does not accept returning`);
+		this.s.returning = cols;
+		return this;
+	}
+
+	async all(): Promise<Array<Record<string, unknown>>> {
+		const { sql, params } = this.compile();
+		return this.dbo.prepare(sql).all(...params);
+	}
+
+	async run(): Promise<number | Array<Record<string, unknown>>> {
+		const { sql, params } = this.compile();
+		const stmt = this.dbo.prepare(sql);
+		if (this.s.returning)
+			return stmt.all(...params);
+		return Number(stmt.run(...params).changes);
+	}
+
+	/** 编译成 {sql, params}（供 union 复用内层 select） */
+	compile(inner = false): Compiled {
+		const s = this.s;
+		if (s.verb === "insert")
+			return this.compileInsert();
+		if (s.verb === "update")
+			return this.compileUpdate();
+		if (s.verb === "delete")
+			return this.compileDelete();
+		if (s.verb === "truncate")
+			return { sql: `DELETE FROM ${quoteIdent(s.table)}`, params: [] };
+		return this.compileSelect(inner);
+	}
+
+	private compileInsert(): Compiled {
+		const rows = (Array.isArray(this.s.values) ? this.s.values : [this.s.values]) as Array<Record<string, unknown>>;
+		if (rows.length === 0)
+			throw new Error("[fixture] insert 至少需要一行");
+		const cols = Object.keys(rows[0]!);
+		for (const r of rows) {
+			if (Object.keys(r).length !== cols.length)
+				throw new Error("[fixture] insert 多行的键集必须一致");
+		}
+		const params: unknown[] = [];
+		const tuple = `(${cols.map(() => "?").join(", ")})`;
+		for (const r of rows)
+			params.push(...cols.map(c => r[c]));
+		const tail = this.s.returning ? ` RETURNING ${this.s.returning.map(quoteIdent).join(", ")}` : "";
+		return {
+			sql: `INSERT${this.s.orIgnore ? " OR IGNORE" : ""} INTO ${quoteIdent(this.s.table)} (${cols.map(quoteIdent).join(", ")}) VALUES ${rows.map(() => tuple).join(", ")}${tail}`,
+			params,
+		};
+	}
+
+	private compileUpdate(): Compiled {
+		const sets = this.s.sets as Record<string, unknown>;
+		const cols = Object.keys(sets);
+		const params = cols.map(c => sets[c]);
+		const where = this.compileWhereClause(params);
+		return {
+			sql: `UPDATE ${quoteIdent(this.s.table)} SET ${cols.map(c => `${quoteIdent(c)} = ?`).join(", ")}${where.sql}`,
+			params: where.params,
+		};
+	}
+
+	private compileDelete(): Compiled {
+		const where = this.compileWhereClause([]);
+		return { sql: `DELETE FROM ${quoteIdent(this.s.table)}${where.sql}`, params: where.params };
+	}
+
+	/** where 子句（追加进既有 params，返回拼接后的片段） */
+	private compileWhereClause(params: unknown[]): Compiled {
+		if (this.s.wheres.length === 0)
+			return { sql: "", params };
+		const parts = this.s.wheres.map(compileWhere);
+		return {
+			sql: ` WHERE ${parts.map(p => `(${p.sql})`).join(" AND ")}`,
+			params: [...params, ...parts.flatMap(p => p.params)],
+		};
+	}
+
+	private compileSelect(inner: boolean): Compiled {
+		const s = this.s;
+		const cols = this.compileCols();
+		const params: unknown[] = cols.params;
+		const from = `${quoteIdent(s.table)}${s.alias ? ` AS ${quoteIdent(s.alias)}` : ""}`;
+		const joins = s.joins.map((j) => {
+			const on = j.on.map((c) => {
+				if (c && c.right !== undefined)
+					return { sql: `${quoteIdent(String(c.left))} = ${quoteIdent(String(c.right))}`, params: [] };
+				const sqlOp = COMPARE_OPS[String(c.op ?? "eq").toLowerCase()];
+				if (!sqlOp)
+					throw new Error(`[fixture] join ON 只支持比较类 op，收到：${c.op}`);
+				return { sql: `${quoteIdent(String(c.left))} ${sqlOp} ?`, params: [c.value] };
+			});
+			params.push(...on.flatMap(o => o.params));
+			return `${j.kind === "left" ? "LEFT JOIN" : "JOIN"} ${quoteIdent(j.table)}${j.alias ? ` AS ${quoteIdent(j.alias)}` : ""} ON ${on.map(o => o.sql).join(" AND ")}`;
+		});
+		const where = this.compileWhereClause(params);
+		let sql = `SELECT ${s.distinct ? "DISTINCT " : ""}${cols.sql} FROM ${from}${joins.length ? ` ${joins.join(" ")}` : ""}${where.sql}`;
+		let allParams = where.params;
+		if (s.groups.length) {
+			sql += ` GROUP BY ${s.groups.map(quoteIdent).join(", ")}`;
+			if (s.having.length) {
+				const hv = this.s.having.map(compileWhere);
+				sql += ` HAVING ${hv.map(h => `(${h.sql})`).join(" AND ")}`;
+				allParams = [...allParams, ...hv.flatMap(h => h.params)];
+			}
+		}
+		if (s.union) {
+			const left = s.union.kind === "all" ? " UNION ALL " : " UNION ";
+			const right = s.union.other.compile(true);
+			sql = `(${sql})${left}(${right.sql})`;
+			allParams = [...allParams, ...right.params];
+		}
+		if (!inner) {
+			if (s.orders.length)
+				sql += ` ORDER BY ${s.orders.map(o => `${quoteIdent(o.field)}${o.dir === "desc" ? " DESC" : o.dir === "asc" ? " ASC" : ""}`).join(", ")}`;
+			if (s.limit !== null)
+				sql += ` LIMIT ${Number(s.limit)}`;
+			if (s.offset !== null)
+				sql += ` OFFSET ${Number(s.offset)}`;
+		}
+		return { sql, params: allParams };
+	}
+
+	private compileCols(): Compiled {
+		const cols = this.s.cols;
+		if (!cols || cols.length === 0)
+			return { sql: "*", params: [] };
+		const params: unknown[] = [];
+		const parts = cols.map((c) => {
+			if (typeof c === "string")
+				return c === "*" ? "*" : quoteIdent(c);
+			if (c.lit !== undefined) {
+				params.push(c.lit);
+				return c.as ? `? AS ${quoteIdent(c.as)}` : "?";
+			}
+			if (!c.fn)
+				throw new Error(`[fixture] select 列形状未实现：${JSON.stringify(c)}`);
+			const inner = `${c.distinct && c.fn === "count" ? "DISTINCT " : ""}${c.field ? quoteIdent(c.field) : "*"}`;
+			return `${c.fn.toUpperCase()}(${inner})${c.as ? ` AS ${quoteIdent(c.as)}` : ""}`;
+		});
+		return { sql: parts.join(", "), params };
+	}
+}
+
+/** listTables：sqlite_master 自省（排除 `sqlite_*` 内部表，前缀按字面量匹配） */
+const SQL_LIST_TABLES = "SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite\\_%' ESCAPE '\\'";
+
+function listTables(dbo: any, prefix?: string): string[] {
+	const sql = `${SQL_LIST_TABLES}${prefix ? ` AND name LIKE ? ESCAPE '${LIKE_ESCAPE}'` : ""} ORDER BY name`;
+	const stmt = dbo.prepare(sql);
+	const rows = (prefix ? stmt.all(`${escapeLike(prefix)}%`) : stmt.all()) as Array<{ name: string }>;
+	return rows.map(r => r.name);
+}
+
+/** 建内存库 + 注入全局；返回 DatabaseSync 供用例直插数据/断言。 */
+export function installDb(): any {
+	const dbo = new DatabaseSync(":memory:");
+	// 重放 src 下全部模块的迁移（方言专属文件除外）
+	for (const mod of readdirSync(SRC)) {
+		const dir = join(SRC, mod, "api", "migrations");
+		if (!existsSync(dir))
+			continue;
+		for (const f of readdirSync(dir).filter((f: string) => f.endsWith(".sql") && !/\.(?:mysql|pg)\.sql$/.test(f)).sort())
+			dbo.exec(readFileSync(join(dir, f), "utf8"));
+	}
+
+	dbo.prepare("INSERT INTO users (id, username, password_hash) VALUES (?, ?, 'x')").run(ADMIN, "admin");
+
+	const query = async (sql: string, params: unknown[] = []) => dbo.prepare(sql).all(...(params as never[]));
+	const exec = async (sql: string, params: unknown[] = []) => Number(dbo.prepare(sql).run(...(params as never[])).changes);
+	const table = (name: string) => new FakeQuery(dbo, name);
+	const txInstance = { query, exec, table, listTables: (prefix?: string) => listTables(dbo, prefix), isTx: true };
+	// db.tx 镜像运行时面：BEGIN/COMMIT/ROLLBACK 包裹回调（versions.ts 注释同语义）
+	const tx = async (fn: (t: typeof txInstance) => unknown) => {
+		dbo.exec("BEGIN");
+		try {
+			const r = await fn(txInstance);
+			dbo.exec("COMMIT");
+			return r;
+		}
+		catch (e) {
+			dbo.exec("ROLLBACK");
+			throw e;
+		}
+	};
+
+	const g = globalThis as any;
+	g.db = { query, exec, tx, table, listTables: (prefix?: string) => listTables(dbo, prefix), dialect: () => "sqlite" };
+	return dbo;
+}

package/templates/{api/tests → tests}/guard.spec.ts

@@ -3,7 +3,7 @@
 // （真实迁移建表 / 运行时全局 db 同面 / 事务往返）——S0 spike 的「一条真实判权 AC + 形态证明」。
 import { beforeAll, describe, expect, it } from "vitest";
 
-import { decideAccess, moduleOf } from "../src/_platform/_shared/service/infra/guard";
+import { decideAccess, moduleOf } from "../src/_platform/api/_shared/service/infra/guard";
 import { ADMIN, installDb } from "./fixture";
 
 const as = (roles: string[], bindings: Record<string, string[]> = {}) => ({ roles, bindings });

package/templates/{api/tests → tests}/l1-builder.test.ts

@@ -11,8 +11,8 @@
 //   ③ notification：join ON 值条件 + UNION ALL + 字面量列 {lit,as} 的真渲染（场景 41 同款）。
 //
 // 登录账号：fixtures 的 l1tester（src/_platform/fixtures/l1-test-user.sql，仅 oj test 灌入）。
-// 不用 seed 的 admin：其 must_change=1（判权端点恒 403）且初始口令 123456 会随用户
-// 首登改密漂移——L1 绑 admin 曾实测 401。l1tester 为 additive 专用账号（must_change=0）。
+// 不用 seed 的 admin 等开发账号：初始口令 123456 会随用户在 dev 库改密漂移——
+// L1 绑 seed 账号曾实测 401。l1tester 为 additive 专用账号（must_change=0）。
 //
 // 运行：cd packages/cli/templates/api && ~/.local/share/oj/oj test -c config.yaml -d src -t tests
 

package/templates/{api/tests → tests}/lifecycle/atomic-state.spec.ts

@@ -4,14 +4,14 @@
 // 只保证读回自己写出的内容；任何不符格式的字节一律视为损坏 → 空状态，损坏上下文并入
 // 读结果（corruptNote 出口，禁 console——release isolate console 抛 BadResource，Finding A）。
 // fs 依赖经 globalThis.fs 注入（平台 isolate 注入 FsApi；测试注入 node:fs/promises 适配）。
-import type { FsFace } from "../../src/_platform/_lifecycle/atomic";
+import type { FsFace } from "../../src/_platform/api/_lifecycle/atomic";
 import * as fsp from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { atomicWriteText } from "../../src/_platform/_lifecycle/atomic";
-import { createStateStore } from "../../src/_platform/_lifecycle/state";
+import { atomicWriteText } from "../../src/_platform/api/_lifecycle/atomic";
+import { createStateStore } from "../../src/_platform/api/_lifecycle/state";
 
 const g = globalThis as any;
 

package/templates/{api/tests → tests}/lifecycle/bootstrap.spec.ts

@@ -5,14 +5,14 @@
 //    与 PEM 私钥块实体（header 后跟 ≥100 字符 base64 体；tasks.ts redact 正则与测试假体
 //    体长 <100 不误伤）双口径扫描。
 // ③ 集成（market-api.spec）：信任库为空 + bootstrapKey 注入 → cdn 安装直达 done 不落 needs_trust。
-import type { FsFace } from "../../src/_platform/_lifecycle/atomic";
+import type { FsFace } from "../../src/_platform/api/_lifecycle/atomic";
 import * as fsp from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { createTrustStore } from "../../src/_platform/_lifecycle/trust";
-import { BOOTSTRAP_KEY, seedBootstrapKey } from "../../src/_platform/market/bootstrap";
+import { createTrustStore } from "../../src/_platform/api/_lifecycle/trust";
+import { BOOTSTRAP_KEY, seedBootstrapKey } from "../../src/_platform/api/market/bootstrap";
 
 const g = globalThis as any;
 
@@ -77,7 +77,11 @@ describe("私钥红线钉测（P2-12：packages/cli 全树零私钥材料）", (
 
 	async function* walk(root: string): AsyncGenerator<string> {
 		for (const name of await fsp.readdir(root)) {
-			if (name === "node_modules" || name === "dist" || name.startsWith(".")) {
+			// 跳过 node_modules / dist / 点目录（依赖与构建产物）；`config` 是 `ojm dev` 缺证时
+			// **现场签发**的开发证书目录（模板 .gitignore 的 `config/*.pem` 已挡住、进不了
+			// tarball）。本测试钉的是「源码树里没有私钥材料」，不是本地运行时产物——不跳
+			// config 会让模板自身跑过一次 dev 就永久变红（连带 `pnpm pack` 也不会带上它们）。
+			if (name === "node_modules" || name === "dist" || name === "config" || name.startsWith(".")) {
 				continue;
 			}
 			const p = join(root, name);

package/templates/{api/tests → tests}/lifecycle/deploy-smoke.spec.ts

@@ -8,19 +8,19 @@
 // 快照逐数组 ⊇ 声明，少 = 注册丢失判失败）collect-all 全败齐报。
 // entry 浏览器加载不在安装器验（Node import 必假绿——设计 §4.1），注释钉口径。
 // fetch/sha384/query/reload 面经 ctx 注入 stub（同 steps-fs 范式），fs 为 globalThis.fs 面。
-import type { FsFace } from "../../src/_platform/_lifecycle/atomic";
-import type { StateStore } from "../../src/_platform/_lifecycle/state";
-import type { DeployWebContext, ModuleEntry } from "../../src/_platform/_lifecycle/steps/deploy-web";
-import type { ReloadContext, ReloadFace, ReloadResult } from "../../src/_platform/_lifecycle/steps/reload";
-import type { SmokeContext } from "../../src/_platform/_lifecycle/steps/smoke";
+import type { FsFace } from "../../src/_platform/api/_lifecycle/atomic";
+import type { StateStore } from "../../src/_platform/api/_lifecycle/state";
+import type { DeployWebContext, ModuleEntry } from "../../src/_platform/api/_lifecycle/steps/deploy-web";
+import type { ReloadContext, ReloadFace, ReloadResult } from "../../src/_platform/api/_lifecycle/steps/reload";
+import type { SmokeContext } from "../../src/_platform/api/_lifecycle/steps/smoke";
 import { createHash } from "node:crypto";
 import * as fsp from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { deployWeb, posixPath, upsertModulesJson } from "../../src/_platform/_lifecycle/steps/deploy-web";
-import { reloadAndAssert } from "../../src/_platform/_lifecycle/steps/reload";
-import { probeUrlOf, smoke } from "../../src/_platform/_lifecycle/steps/smoke";
+import { deployWeb, posixPath, upsertModulesJson } from "../../src/_platform/api/_lifecycle/steps/deploy-web";
+import { reloadAndAssert } from "../../src/_platform/api/_lifecycle/steps/reload";
+import { probeUrlOf, smoke } from "../../src/_platform/api/_lifecycle/steps/smoke";
 
 const g = globalThis as any;
 
@@ -326,6 +326,29 @@ describe("smoke 探活（D14/Q-A：health 不强制）", () => {
 		expect(r.ok).toBe(true);
 	});
 
+	it("health 401 且路径属本次新增 anonymous（restart_pending）→ 判通过 + 落待重启提示", async () => {
+		await seedDeployed();
+		const r = await smoke(smCtx({
+			manifest: solManifest({ health: "/demo-solution/ping" }),
+			fetch: async () => ({ ok: false, status: 401 }),
+			deferredAnonymous: ["/demo-solution/ping"],
+		}));
+		expect(r.ok).toBe(true);
+		expect(r.message).toContain("restart_pending");
+		expect(r.message).toContain("重启宿主后生效");
+	});
+
+	it("health 401 但路径不是本次新增（已在配置里）→ 仍判失败（不放宽真失败）", async () => {
+		await seedDeployed();
+		const r = await smoke(smCtx({
+			manifest: solManifest({ health: "/demo-solution/ping" }),
+			fetch: async () => ({ ok: false, status: 401 }),
+			deferredAnonymous: ["/demo-solution/other"],
+		}));
+		expect(r.ok).toBe(false);
+		expect(r.message).toContain("401");
+	});
+
 	it("health 非 2xx → 探活失败", async () => {
 		await seedDeployed();
 		const r = await smoke(smCtx({

package/templates/{api/tests → tests}/lifecycle/installer.spec.ts

@@ -12,22 +12,22 @@
 // 过期（30min）可接管。setEnabled 四处同写（D12/AC-P1-6）：锁摘除/恢复 + sidecar + route + modules。
 // 步骤面全 stub 注入（DIP）：fetch/exec/tar/reload 不真跑；register/smoke/audit 走真实内存库夹具。
 /* eslint-disable test/prefer-lowercase-title -- 任务/AC 编号是验收锚点，保留大写（register.spec 同约定） */
-import type { FsFace } from "../../src/_platform/_lifecycle/atomic";
-import type { InstallRequest } from "../../src/_platform/_lifecycle/installer";
-import type { StateStore } from "../../src/_platform/_lifecycle/state";
-import type { ExecFace } from "../../src/_platform/_lifecycle/steps/extract";
+import type { FsFace } from "../../src/_platform/api/_lifecycle/atomic";
+import type { InstallRequest } from "../../src/_platform/api/_lifecycle/installer";
+import type { StateStore } from "../../src/_platform/api/_lifecycle/state";
+import type { ExecFace } from "../../src/_platform/api/_lifecycle/steps/extract";
 import { createHash } from "node:crypto";
 import * as fsp from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { defaultTestKey, nodeVerifyEd25519, signedArchiveFor } from "../../../../src/lifecycle/__tests__/helpers";
-import { atomicWriteText } from "../../src/_platform/_lifecycle/atomic";
-import { gcVersions, reconcile, runInstall, setEnabled, STAGES } from "../../src/_platform/_lifecycle/installer";
-import { acquireTaskLock, commitLockEntry, parseLock, readLock, serializeLock, writeLock } from "../../src/_platform/_lifecycle/lock";
-import { createStateStore } from "../../src/_platform/_lifecycle/state";
-import { getTask, readTasks, redact, sweepTimedOut, writeTask } from "../../src/_platform/_lifecycle/tasks";
-import { createTrustStore } from "../../src/_platform/_lifecycle/trust";
+import { defaultTestKey, nodeVerifyEd25519, signedArchiveFor } from "../../../src/lifecycle/__tests__/helpers";
+import { atomicWriteText } from "../../src/_platform/api/_lifecycle/atomic";
+import { gcVersions, reconcile, runInstall, setEnabled, STAGES } from "../../src/_platform/api/_lifecycle/installer";
+import { acquireTaskLock, commitLockEntry, parseLock, readLock, serializeLock, writeLock } from "../../src/_platform/api/_lifecycle/lock";
+import { createStateStore } from "../../src/_platform/api/_lifecycle/state";
+import { getTask, readTasks, redact, sweepTimedOut, writeTask } from "../../src/_platform/api/_lifecycle/tasks";
+import { createTrustStore } from "../../src/_platform/api/_lifecycle/trust";
 import { installDb } from "../fixture";
 
 const g = globalThis as any;
@@ -532,8 +532,8 @@ describe("U5 取消安装（P3-8）：cancel token → h.kill + staging 清场 +
 
 describe("第五终态 needs_trust（P2-3，G3 TOFU：未知 key_id 待确认，staging 不清场）", () => {
 	it("未知 key 装 → needs_trust + trust 三元组 + unknown_key 指引；锁/库表/sidecar/审计零改动，staging 留存", async () => {
-		const { generateKeyPair } = await import("../../../../src/lifecycle/keygen");
-		const { signedArchiveFor: signFor } = await import("../../../../src/lifecycle/__tests__/helpers");
+		const { generateKeyPair } = await import("../../../src/lifecycle/keygen");
+		const { signedArchiveFor: signFor } = await import("../../../src/lifecycle/__tests__/helpers");
 		const stranger = signFor(ARCHIVE, "demo-solution", "0.1.0", { keyPair: generateKeyPair(), keyId: "stranger.pub" });
 		const m = manifestFixture("0.1.0");
 		m.archive = { ...m.archive, signature: stranger.sig };
@@ -562,8 +562,8 @@ describe("第五终态 needs_trust（P2-3，G3 TOFU：未知 key_id 待确认，
 	});
 
 	it("TOFU 全链：确认入信任库（端点同路径 store.add）后原样重试 → done", async () => {
-		const { generateKeyPair } = await import("../../../../src/lifecycle/keygen");
-		const { signedArchiveFor: signFor } = await import("../../../../src/lifecycle/__tests__/helpers");
+		const { generateKeyPair } = await import("../../../src/lifecycle/keygen");
+		const { signedArchiveFor: signFor } = await import("../../../src/lifecycle/__tests__/helpers");
 		const stranger = signFor(ARCHIVE, "demo-solution", "0.1.0", { keyPair: generateKeyPair(), keyId: "stranger.pub" });
 		const m = manifestFixture("0.1.0");
 		m.archive = { ...m.archive, signature: stranger.sig };