@oj-module/cli 0.2.8 → 0.2.15

package/templates/api/tests/lifecycle/uninstall.spec.ts

@@ -2,8 +2,8 @@
 // 端点（createMarketApi 的 uninstall-impact / uninstall）只做门禁 + 取参 + 调 runUninstall；
 // 编排器负责四处同删（锁/sidecar/sys_solution_route/modules.json）+ 权限级联 uninstallSolution
 // + 版本目录移除 + 审计 + 全用户失效 + market_history 留痕。本规格为验收锚点。
-// 夹具：本仓范式（node:sqlite 真实迁移建表 + 真实 fs 面 g.fs）；market_history 表真源随市场
-// 方案包（fixture.MARKET_HISTORY_DDL 同构建表），守卫语义（表不存在静默跳过）单列一例。
+// 夹具：本仓范式（node:sqlite 真实迁移建表 + 真实 fs 面 g.fs）；market_history 表由平台迁移
+// 0012（IF NOT EXISTS）随 installDb 重放建立，守卫语义（表不存在静默跳过）单列一例。
 /* eslint-disable test/prefer-lowercase-title -- 端点动词/路径是验收锚点，保留大写（market-api.spec 同约定） */
 import type { FsFace } from "../../src/_platform/_lifecycle/atomic";
 import type { MarketEnv } from "../../src/_platform/market/api";
@@ -13,10 +13,10 @@ import { dirname, join } from "node:path";
 import { afterEach, beforeEach, describe, expect, it } from "vitest";
 import { readLock, writeLock } from "../../src/_platform/_lifecycle/lock";
 import { createStateStore } from "../../src/_platform/_lifecycle/state";
-import { catalogSpec, collectRetainedTables, tablePrefixPattern } from "../../src/_platform/_lifecycle/uninstall";
+import { collectRetainedTables, moduleTablePrefix } from "../../src/_platform/_lifecycle/uninstall";
 import { invalidateAllUsers } from "../../src/_platform/_shared/service/infra/access";
 import { createMarketApi } from "../../src/_platform/market/api";
-import { installDb, MARKET_HISTORY_DDL } from "../fixture";
+import { installDb } from "../fixture";
 
 const g = globalThis as any;
 
@@ -67,7 +67,6 @@ async function seedInstalled(opts: { withOther?: boolean } = {}): Promise<void>
 		{ name: "demo-solution", enabled: true, src: "modules/demo-solution/" },
 		...(withOther ? [{ name: "other", enabled: true, src: "modules/other/" }] : []),
 	]));
-	dbo.exec(MARKET_HISTORY_DDL);
 	dbo.prepare("INSERT INTO sys_solution_route (path, module, category) VALUES (?, ?, ?)").run("/demo-solution", "demo-solution", "main");
 	dbo.prepare("INSERT INTO sys_role (name, module, title, builtin) VALUES (?, ?, ?, 0)").run("demo-solution.admin", "demo-solution", "管理员");
 	dbo.prepare("INSERT INTO sys_role (name, module, title, builtin) VALUES (?, ?, ?, 0)").run("demo-solution.viewer", "demo-solution", "访客");
@@ -295,92 +294,33 @@ describe("P3-4 业务表保留提示（Q4：不删业务数据，retained 回传
 	});
 });
 
-describe("P4-1 多方言卸载矩阵（P3-4#2）：catalogSpec 三方言 SQL 形态 + 前缀转义方言无关", () => {
-	it("catalogSpec 三方言 existing SQL 形态正确（sqlite=sqlite_master / mysql/pg=information_schema）", () => {
-		const sqlite = catalogSpec("sqlite");
-		const mysql = catalogSpec("mysql");
-		const pg = catalogSpec("pg");
-		expect(sqlite.existing).toBe("SELECT name FROM sqlite_master WHERE type='table'");
-		expect(mysql.existing).toContain("information_schema.tables");
-		expect(mysql.existing).toContain("DATABASE()");
-		expect(pg.existing).toContain("information_schema.tables");
-		expect(pg.existing).toContain("table_schema = 'public'");
+describe("P4-1 卸载业务表保留清单（P3-4#2）：moduleTablePrefix + db.listTables 方言无关", () => {
+	it("moduleTablePrefix 连字符→下划线作表前缀（listTables 内部按字面量前缀匹配，无需手拼 %）", () => {
+		expect(moduleTablePrefix("demo-solution")).toBe("demo_solution_");
+		expect(moduleTablePrefix("a!b%c_d")).toBe("a!b%c_d_");
 	});
 
-	it("catalogSpec.like 三方言均带 ESCAPE '!' + 正确 schema 表达式 + 参数化 pat", () => {
-		const pat = "demo_solution_%";
-		const sqlite = catalogSpec("sqlite").like(pat);
-		const mysql = catalogSpec("mysql").like(pat);
-		const pg = catalogSpec("pg").like(pat);
-		// sqlite
-		expect(sqlite[0]).toBe("SELECT name FROM sqlite_master WHERE type='table' AND name LIKE ? ESCAPE '!'");
-		expect(sqlite[1]).toEqual([pat]);
-		// mysql：information_schema + DATABASE() + ESCAPE + 参数化（值不拼字符串，SSRF/注入无关但口径统一）
-		expect(mysql[0]).toContain("information_schema.tables");
-		expect(mysql[0]).toContain("DATABASE()");
-		expect(mysql[0]).toContain("ESCAPE '!'");
-		expect(mysql[1]).toEqual([pat]);
-		// pg：information_schema + 'public' + ESCAPE + 参数化
-		expect(pg[0]).toContain("information_schema.tables");
-		expect(pg[0]).toContain("table_schema = 'public'");
-		expect(pg[0]).toContain("ESCAPE '!'");
-		expect(pg[1]).toEqual([pat]);
-	});
-
-	it("tablePrefixPattern 转义 !%_ 且连字符→下划线作表前缀", () => {
-		// 连字符→下划线后，该下划线亦被转义（!_）= 字面分隔符而非 LIKE 通配，避免前缀扫描越权命中
-		expect(tablePrefixPattern("demo-solution")).toBe("demo!_solution_%");
-		// 危险字符必须转义，避免 LIKE 通配语义被注入（防前缀扫描越权命中）
-		expect(tablePrefixPattern("a!b%c_d")).toBe("a!!b!%c!_d_%");
-	});
-});
-
-describe("P4-1 多方言卸载矩阵（续）：collectRetainedTables 经 db.dialect 走 mysql/pg 信息_schema 路径", () => {
-	/** 注入指定方言的 db.query 桩：existing 返回全表清单、like 返回前缀命中，模拟 information_schema 行为 */
-	function stubDialect(dialect: "mysql" | "pg", existingNames: string[], likeNames: string[]): void {
-		const spec = catalogSpec(dialect);
-		(g.db as { dialect: () => string, query: (sql: string, p?: unknown[]) => unknown }).dialect = () => dialect;
-		(g.db as { query: (sql: string, p?: unknown[]) => unknown }).query = (sql: string) => {
-			if (sql === spec.existing)
-				return existingNames.map(name => ({ name }));
-			if (sql.includes("AND table_name LIKE"))
-				return likeNames.map(name => ({ name }));
-			return [];
-		};
-	}
-
-	it("mysql 方言：manifest 声明 + 前缀兜底扫描均经 information_schema，返回实际存在的业务表", async () => {
+	it("manifest 声明 + 前缀兜底经 db.listTables 合并，仅回传实际存在的业务表", async () => {
 		await seedInstalledWithTables();
-		stubDialect("mysql", ["demo_solution_notes", "demo_solution_tags", "demo_solution_orphan"], ["demo_solution_orphan"]);
-		const retained = await collectRetainedTables("demo-solution", join(sharedRoot, "demo-solution-0.1.0", "manifest.yaml"));
-		expect(retained).toContain("demo_solution_notes");
-		expect(retained).toContain("demo_solution_tags");
-		expect(retained).toContain("demo_solution_orphan");
-	});
-
-	it("pg 方言：'public' schema 表达式路径一致，返回业务表（与 mysql 口径相同）", async () => {
-		await seedInstalledWithTables();
-		stubDialect("pg", ["demo_solution_notes", "demo_solution_tags", "demo_solution_orphan"], ["demo_solution_orphan"]);
-		const retained = await collectRetainedTables("demo-solution", join(sharedRoot, "demo-solution-0.1.0", "manifest.yaml"));
-		expect(retained).toContain("demo_solution_notes");
-		expect(retained).toContain("demo_solution_tags");
-		expect(retained).toContain("demo_solution_orphan");
-	});
-
-	it("db.dialect 缺省回落 sqlite（不抛、不误导），与既有 sqlite 全量路径一致", async () => {
-		await seedInstalledWithTables();
-		// 还原为缺省（不提供 dialect 函数）→ currentDialect 回落 "sqlite"
-		const spec = catalogSpec("sqlite");
-		(g.db as { dialect?: () => string }).dialect = undefined;
-		(g.db as { query: (sql: string, p?: unknown[]) => unknown }).query = (sql: string) => {
-			if (sql === spec.existing)
-				return [{ name: "demo_solution_notes" }, { name: "demo_solution_tags" }];
-			if (sql.includes("AND name LIKE"))
-				return [{ name: "demo_solution_notes" }];
-			return [];
+		// manifest 追加「声明了但没建表」的幽灵条目，验证存在性过滤
+		const manifestPath = join(sharedRoot, "demo-solution-0.1.0", "manifest.yaml");
+		await fsp.writeFile(manifestPath, `${await fsp.readFile(manifestPath, "utf-8")}  - demo_solution_ghost\n`);
+		// 真实 sqlite 目录：manifest 声明 notes/tags（seed 已建）+ 前缀扫描命中 orphan（未声明）
+		dbo.exec("CREATE TABLE demo_solution_orphan (id INTEGER)");
+		// L2：listTables 是 oj 运行时能力（纯 Rust 二进制内，vitest 无载体，见 devkit
+		// oj-test-guide.md）——桩回放**真实 sqlite 目录**（sqlite_master 实查）并记录
+		// 调用形态；被测的是合并/过滤编排，不是引擎的目录自省本身。
+		const seen: Array<string | undefined> = [];
+		g.db.listTables = async (prefix?: string) => {
+			seen.push(prefix);
+			const all = (dbo.prepare("SELECT name FROM sqlite_master WHERE type='table'").all() as Array<{ name: string }>).map(r => r.name);
+			return prefix === undefined ? all : all.filter(t => t.startsWith(prefix));
 		};
-		const retained = await collectRetainedTables("demo-solution", join(sharedRoot, "demo-solution-0.1.0", "manifest.yaml"));
-		expect(retained).toContain("demo_solution_notes");
-		expect(retained).toContain("demo_solution_tags");
+		const retained = await collectRetainedTables("demo-solution", manifestPath);
+		expect(seen).toEqual(["demo_solution_", undefined]); // 前缀扫描 + 全量存在性过滤各一次
+		expect(retained).toContain("demo_solution_notes"); // manifest 声明
+		expect(retained).toContain("demo_solution_tags"); // manifest 声明
+		expect(retained).toContain("demo_solution_orphan"); // 前缀兜底命中（未声明）
+		expect(retained).not.toContain("demo_solution_ghost"); // 声明但物理不存在 → 不回传
 	});
 });

package/templates/api/tests/query-utils.spec.ts

@@ -3,7 +3,7 @@
 /* eslint-disable test/prefer-lowercase-title -- AC 编号是验收锚点，保留大写 */
 import { beforeAll, describe, expect, it } from "vitest";
 
-import { likePattern, paged } from "../src/_platform/_shared/service/infra/query";
+import { likePattern, paged, pagedFactory } from "../src/_platform/_shared/service/infra/query";
 import { installDb } from "./fixture";
 
 let dbo: ReturnType<typeof installDb>;
@@ -66,3 +66,87 @@ describe("AC1-22：LIKE 模式与 keyword 长度红线", () => {
 		expect(likePattern("张三")).toBe("%张三%");
 	});
 });
+
+describe("AC1-24（构造器工厂）：pagedFactory 复用同一组条件", () => {
+	// L2 记录型假构造器：pagedFactory 是纯编排（count 聚合 + 条件分页 + 截断判定），
+	// SQL 渲染/执行在 oj 二进制内，vitest 无真 builder 载体（架构定论：builder 纯 Rust
+	// 实现，无 JS 模块可导；SQL 断言走 oj test / oj exec，见 devkit oj-test-guide.md）。
+	// 这里只断言编排契约：mk 各跑一次、count 走聚合 select、total=0 不跑 list。
+	function fakeBuilder(total: number, rows: any[]) {
+		const calls: string[] = [];
+		let countPath = false;
+		const b: any = {
+			select: (cols: any[]) => {
+				countPath = cols.some((c: any) => c && typeof c === "object" && c.fn === "count");
+				calls.push(`select:${JSON.stringify(cols)}`);
+				return b;
+			},
+			where: (cond: any) => {
+				calls.push(`where:${JSON.stringify(cond)}`);
+				return b;
+			},
+			orderBy: (items: any[]) => {
+				calls.push(`orderBy:${JSON.stringify(items)}`);
+				return b;
+			},
+			limit: (n: number) => {
+				calls.push(`limit:${n}`);
+				return b;
+			},
+			offset: (n: number) => {
+				calls.push(`offset:${n}`);
+				return b;
+			},
+			all: async () => (countPath ? [{ c: total }] : rows),
+		};
+		return { b, calls };
+	}
+
+	it("count + list 各跑一次：count 走聚合 select（不受 LIMIT 钳制），list 带 orderBy/limit/offset", async () => {
+		const built: Array<{ calls: string[] }> = [];
+		const mk = () => {
+			const f = fakeBuilder(301, Array.from({ length: 200 }, (_, i) => ({ id: 300 - i })));
+			built.push(f);
+			return f.b;
+		};
+		const r = await pagedFactory<any>(mk, { page: 1, size: 500 });
+		expect(built).toHaveLength(2);
+		expect(built[0].calls.some(c => c.startsWith("select:") && c.includes("\"count\""))).toBe(true);
+		expect(built[1].calls.includes("limit:200")).toBe(true); // 500 被钳 200
+		expect(built[1].calls.includes("offset:0")).toBe(true);
+		expect(r.total).toBe(301);
+		expect(r.size).toBe(200);
+		expect(r.list.length).toBe(200);
+		expect(r.truncated).toBe(true); // 301 > 1*200
+	});
+
+	it("条件经 mk 工厂收敛（contains 替代 LIKE ? ESCAPE '!'）：两次构造都带上 where", async () => {
+		const built: Array<{ calls: string[] }> = [];
+		const mk = () => {
+			const f = fakeBuilder(1, [{ id: 7, username: "contains_me" }]);
+			f.b.where({ field: "username", op: "contains", value: "contains" });
+			built.push(f);
+			return f.b;
+		};
+		const r = await pagedFactory<any>(mk, { size: 10 });
+		expect(built).toHaveLength(2);
+		for (const f of built)
+			expect(f.calls.some(c => c.startsWith("where:") && c.includes("contains"))).toBe(true);
+		expect(r.total).toBe(1);
+		expect(r.truncated).toBe(false);
+	});
+
+	it("total=0 → 不跑 list 查询（省一次往返），缺省 page=1/size=20", async () => {
+		const built: Array<{ calls: string[] }> = [];
+		const mk = () => {
+			const f = fakeBuilder(0, []);
+			built.push(f);
+			return f.b;
+		};
+		const r = await pagedFactory<any>(mk, {});
+		expect(built).toHaveLength(1); // 只跑了 count
+		expect(r.list).toEqual([]);
+		expect(r.truncated).toBe(false);
+		expect(r.size).toBe(20);
+	});
+});

package/templates/api/tests/rbac-settings.spec.ts

@@ -9,11 +9,6 @@ import { installDb } from "./fixture";
 let dbo: ReturnType<typeof installDb>;
 const g = globalThis as any;
 
-function mkOplog(username: string, action: string, module: string, level = 6) {
-	dbo.prepare("INSERT INTO sys_oplog (create_time, user_id, username, action, module, level) VALUES (?, 1, ?, ?, ?, ?)")
-		.run(1000, username, action, module, level);
-}
-
 beforeAll(() => {
 	dbo = installDb();
 });
@@ -25,22 +20,72 @@ afterEach(() => {
 });
 
 describe("AC1-29/D13：操作日志查询（admin 可查）", () => {
-	it("按 action/username/module 过滤 + 分页截断标记", async () => {
-		mkOplog("alice", "role.create", "framework");
-		mkOplog("alice", "user.create", "framework");
-		mkOplog("bob", "role.create", "framework");
-		const all = await searchOplog({});
-		expect(all.total).toBe(3);
-		const byAction = await searchOplog({ action: "user.create" });
-		expect(byAction.list.map(r => r.username)).toEqual(["alice"]);
-		const byUser = await searchOplog({ username: "bob" });
-		expect(byUser.total).toBe(1);
+	// L2：searchOplog 的本职是「过滤维度 → whereIf 条件」的映射 + 分页复用（pagedFactory）；
+	// 构造器执行（SQL 渲染 / 真过滤）在 oj 二进制内——vitest 无真 builder 载体（架构定论：
+	// builder 纯 Rust 实现、无 JS 模块可导；SQL 断言走 oj test / oj exec，见 devkit
+	// oj-test-guide.md）。这里用记录型假构造器断言条件发射；whereIf 的「假值/空数组跳过」
+	// 按 api-manual §1153 契约建模（引擎语义的忠实复刻，非新逻辑）。
+	function fakeTable() {
+		const conds: Array<{ test: unknown, cond: any }> = [];
+		const b: any = {
+			whereIf: (test: unknown, cond: any) => {
+				if (test !== undefined && test !== null && test !== false && !(Array.isArray(test) && test.length === 0))
+					conds.push({ test, cond });
+				return b;
+			},
+			select: () => b,
+			orderBy: () => b,
+			limit: () => b,
+			offset: () => b,
+			// 固定非零 total：保证 count/list 两条路径都构造（total=0 跳过 list 的行为
+			// 由 query-utils.spec 的 pagedFactory 用例覆盖，这里只关心条件发射）
+			all: async () => [{ c: 42 }],
+		};
+		return { b, conds };
+	}
+
+	/** 以假构造器跑 searchOplog，回传 count 构造发射的条件（并校验 count/list 同条件） */
+	async function captureConds(filter: Parameters<typeof searchOplog>[0]) {
+		const built: Array<ReturnType<typeof fakeTable>> = [];
+		const prevDb = g.db;
+		g.db = {
+			table: () => {
+				const t = fakeTable();
+				built.push(t);
+				return t.b;
+			},
+		};
+		try {
+			await searchOplog(filter);
+		}
+		finally {
+			g.db = prevDb;
+		}
+		expect(built).toHaveLength(2); // count + list 各构造一次
+		expect(built[1].conds).toEqual(built[0].conds); // mk 工厂：两组条件一致
+		return built[0].conds;
+	}
+
+	it("无过滤/空串过滤 → 不发射任何条件（归一化空串 → whereIf 跳过，等价旧 if (filter.x)）", async () => {
+		expect(await captureConds({})).toEqual([]);
+		expect(await captureConds({ action: "", username: "", module: "" })).toEqual([]);
+	});
+
+	it("action/module 精确 + username 包含：三维度各发射一条，字段与 op 对应", async () => {
+		const conds = await captureConds({ action: "user.create", module: "framework", username: "bo" });
+		expect(conds).toEqual([
+			{ test: "user.create", cond: { field: "action", op: "eq", value: "user.create" } },
+			{ test: "framework", cond: { field: "module", op: "eq", value: "framework" } },
+			{ test: "bo", cond: { field: "username", op: "contains", value: "bo" } },
+		]);
 	});
 
-	it("403 拒绝类（auth.deny）可在日志中检索", async () => {
-		mkOplog("mallory", "auth.deny", "wiki", 4);
-		const r = await searchOplog({ action: "auth.deny" });
-		expect(r.total).toBe(1);
+	it("403 拒绝类（auth.deny）可在日志中检索：按 action 精确命中，且从无 level 条件（读不过滤等级）", async () => {
+		const conds = await captureConds({ action: "auth.deny" });
+		expect(conds).toEqual([
+			{ test: "auth.deny", cond: { field: "action", op: "eq", value: "auth.deny" } },
+		]);
+		expect(conds.some(c => (c.cond as { field?: string }).field === "level")).toBe(false);
 	});
 });
 

package/templates/cdn/README.md

@@ -0,0 +1,48 @@
+# cdn/ —— 本地模拟市场源
+
+本目录是**本地模拟 CDN**：`ojm market publish` 把分发包落在这里，站点通过 `api/config.yaml` 里的挂载
+（`- prefix: /cdn` → `web: ../cdn`）把它直出成分发源，市场页按系统设置 `framework.market_cdn_url`
+指向的地址读取。
+
+> **目录缺失会让站点起不来**：`oj serve` 启动即校验挂载目录，缺失就报错退出。
+> 所以本 README 进模板、进发布包、进新工程——它的存在就是目录存在的理由，**不要删**。
+
+## 这是本地模拟源，不是生产 CDN
+
+- 服务于本地开发与演示：想看市场卡片、想走一遍安装链路，就用它。
+- 目录与挂载都随模板发布，`ojm init` 出的新工程自带可用。
+- 目录里没有包也没关系：空目录只意味着市场页暂时没有卡片。
+
+## 进仓边界
+
+| 类型 | 是否进仓 |
+|---|---|
+| 本 README | ✅ 唯一进仓的文件 |
+| `<name>-<version>.tgz` 及其 `.tgz.sig` | ❌ 产物 |
+| `bundles.yaml` / `manifests.yaml` 及其 `.sig` | ❌ 产物 |
+
+## 生产怎么切出去
+
+1. 删掉 `api/config.yaml` 的 `mounts` 里这条（它就是本地挂载的全部）：
+
+```yaml
+  - prefix: /cdn
+    web: ../cdn
+```
+
+2. 把真 CDN（对象存储 / nginx）的地址写进系统设置 `framework.market_cdn_url`；
+   命令行等价写法是 `ojm market setup --url <地址>`。
+3. 索引（`bundles.yaml` / `manifests.yaml`）由 CDN 侧维护：`ojm market build-index` 在本地产出后自行上传。
+
+## 签名与校验口径
+
+- **包级（信任锚）**：每个 `<name>-<version>.tgz` 配一份 detached `.tgz.sig`，Ed25519，由发布方私钥签署。
+  安装时逐字节校验，验不过即拒绝安装（fail-closed）。
+- **索引级（只做完整性）**：`bundles.yaml` / `manifests.yaml` 各自一份 `.sig`，用于发现目录或索引被篡改；
+  **它不是信任锚**——陌生发布方的取舍由信任库决定。
+- **时效性**：服务端响应不带缓存头（只有 ETag），因此拉取索引**必须**由请求侧带 `cache-control: no-cache`。
+
+## 陌生发布方（TOFU）
+
+首次遇到未登记的发布方 key，安装会停在待信任状态，由管理员确认后才写入信任库；
+信任库遵循**首次绑定不可改**（再次绑定同一个 key_id 会被拒绝）。

package/templates/global.d.ts

@@ -25,6 +25,15 @@ interface WhereCond {
 	not?: WhereCond
 }
 
+// db.table(...).join(table, on, ...) 的单个 ON 项（v0.1.81）：列=列（{left,right}）
+// 或列=值（{left,op,value}），可混合出现在同一 on 数组；op 限比较类。
+interface JoinOn {
+	left: string
+	right?: string
+	op?: string
+	value?: unknown
+}
+
 // db.table(...).orderBy(items) 的单个排序项。
 interface OrderByItem {
 	field: string
@@ -51,19 +60,37 @@ interface QueryBuilder {
 	insert: (rows: object | object[]) => QueryBuilder
 	update: (sets: object) => QueryBuilder
 	delete: () => QueryBuilder
+	// 整表清空（v0.1.82）：唯一的无 where 写动词，明示使用——渲染 `DELETE FROM t`。
+	// 租户守卫照常注入：租户表上只清**当前租户**的行（清整库用 db.asSystem）。
+	// 自带 where 报 `truncate does not accept where`；update 携带 truncate 报错。
+	truncate: () => QueryBuilder
 	returning: (cols?: string[]) => QueryBuilder
-	// JOIN：on = 左右列对；kind 缺省 "inner"（left/right/... 依服务端支持）。
+	// JOIN（v0.1.81 支持 ON 值条件与表别名）：on = 左右列对 / 列对值条件；kind 缺省 "inner"。
+	// 第 4 参数 alias 给被 join 的表起别名；基表别名用 .as(alias)（v0.1.81）。
 	join: (
 		table: string,
-		on: { left: string, right: string }[],
+		on: JoinOn[],
 		kind?: string,
+		alias?: string,
 	) => QueryBuilder
+	// 基表别名（v0.1.81）：仅作用于列限定与 SQL 渲染；归属/租户守卫按真名生效。
+	// 仅 select/join 支持；insert/update/delete 带别名直接报错。
+	as: (alias: string) => QueryBuilder
+	// 条件化 where（v0.1.81）：test 为 undefined/null/false/空数组时整条跳过；0 与 "" 保留。
+	whereIf: (test: unknown, cond: WhereCond) => QueryBuilder
 	// DISTINCT / GROUP BY / HAVING / UNION / CTE（WITH）。
 	distinct: () => QueryBuilder
 	groupBy: (cols?: string[]) => QueryBuilder
 	having: (cond: WhereCond) => QueryBuilder
 	union: (other: QueryBuilder, kind?: string) => QueryBuilder
 	with: (name: string, columns: string[], query: QueryBuilder) => QueryBuilder
+	// 幂等写入（v0.1.81）：撞主键/任意唯一键则跳过（sqlite/pg → ON CONFLICT DO NOTHING；
+	// mysql → ON DUPLICATE KEY UPDATE <pk>=<pk>，要求表有主键）。三方言 affected-rows 不一致，
+	// 勿用 if (n===1) 判幂等；与 returning 在 mysql 上互斥。
+	orIgnore: () => QueryBuilder
+	// INSERT ... SELECT（v0.1.81）：从另一构造器结果（或其 toJSON 快照）批量写入，
+	// cols 与源 select 列按位置对齐。
+	fromSelect: (sub: QueryBuilder | object, cols: string[]) => QueryBuilder
 	run: () => Promise<number | Row[]>
 	// 只构造不执行（与 .all()/.run() 完全相同的校验管线）。
 	toSQL: () => { sql: string, params: unknown[] }
@@ -584,6 +611,13 @@ declare global {
 		 * 连接引擎名（v0.1.61）：`"sqlite" | "mysql" | "postgres"`。供 `_shared` 共享模块与
 		 * 诊断分派方言 SQL；业务 handler 分支方言 = 放弃跨引擎可移植承诺，慎用。
 		 */
+		/**
+		 * 目录自省（v0.1.82）：当前库全部业务可见表名（**含未登记 registry 的表**——api-only
+		 * 方案 / 历史遗留表），按名称排序。可选前缀过滤（%/_ 按字面量匹配，引擎转义 + 绑定参数）。
+		 * sqlite 排除 `sqlite_*` 内部表；mysql/pg 经 information_schema 限当前库/schema。
+		 * 替代「按方言分支 information_schema / sqlite_master」的裸 db.query。
+		 */
+		listTables: (prefix?: string) => Promise<string[]>
 		dialect(): "sqlite" | "mysql" | "postgres"
 		asTenant(id: string): DBInstance
 		// 事务：回调 resolve 提交 / throw 回滚再抛；tx.query/exec/table 同签名走同一连接。

package/templates/init.include.yaml

@@ -26,6 +26,9 @@
 include:
   # —— 工程级文件 ——
   - README.md
+  # 本地模拟 CDN 目录：只带 README（它的存在让挂载目录不缺，站点才起得来）。
+  # 产物 *.tgz / *.sig / bundles.yaml / manifests.yaml 一律不拷、不进发布包。
+  - cdn/README.md
   - tsconfig.json
   - global.d.ts
   - env.d.ts
@@ -42,7 +45,6 @@ include:
   - api/src/_platform
   - api/src/auth
   - api/src/notification
-  - api/src/notifications
   - api/src/personal-center
   - api/src/system
   - api/src/web
@@ -57,7 +59,6 @@ include:
   - web/src/home/pages
   - web/src/login
   - web/src/notification
-  - web/src/notifications
   # 解决方案市场：默认第一方能力。逐子路径收录——__tests__ 不进脚手架
   # （用户工程无 web 侧 vitest 基建，拷了是死文件）
   - web/src/oj-market/entry.ts

package/templates/openapi.json

@@ -1390,17 +1390,65 @@
 				}
 			}
 		},
-		"/api/notifications": {
-			"get": {
-				"operationId": "notifications_get",
-				"summary": "GET api/notifications",
-				"x-oj-file": "notifications/api.ts",
+		"/api/personal-center/profile": {
+			"post": {
+				"operationId": "personal_center_profile_post",
+				"summary": "POST api/personal-center/profile",
+				"x-oj-file": "personal-center/profile/api.ts",
 				"tags": [
-					"notifications"
+					"personal-center"
 				],
+				"requestBody": {
+					"required": true,
+					"content": {
+						"application/json": {
+							"schema": {
+								"type": "object",
+								"properties": {
+									"username": {
+										"type": "string"
+									},
+									"email": {
+										"type": "string"
+									},
+									"phoneNumber": {
+										"type": "string"
+									},
+									"description": {
+										"type": "string"
+									}
+								}
+							}
+						}
+					}
+				},
 				"responses": {
 					"200": {
-						"description": "OK"
+						"description": "OK",
+						"x-oj-response-enforced": false,
+						"content": {
+							"application/json": {
+								"schema": {
+									"type": "object",
+									"required": [
+										"code",
+										"msg",
+										"data"
+									],
+									"properties": {
+										"code": {
+											"type": "integer"
+										},
+										"msg": {
+											"type": "string"
+										},
+										"data": {
+											"type": "null"
+										}
+									}
+								}
+							}
+						}
 					}
 				}
 			}
@@ -2523,9 +2571,6 @@
 		{
 			"name": "notification"
 		},
-		{
-			"name": "notifications"
-		},
 		{
 			"name": "personal-center"
 		},

package/templates/web/src/notification/entry.ts

@@ -1,23 +1,60 @@
-import type { NotificationsApiProvider } from "@oj-module/runtime";
+import type { AppRouteRecordRaw, NotificationsApiProvider } from "@oj-module/runtime";
 
+import { BellOutlined } from "@ant-design/icons";
 import { defineModule } from "@oj-module/runtime";
 
+import { createElement, lazy } from "react";
+
 import { createNotificationClient } from "./__client/api";
 
+const NotificationCenter = lazy(() => import("./pages/center"));
+
+/**
+ * 通知中心页（N3）：全量消息 + 类型 Tab，铃铛弹层「查看全部」跳转至此。
+ * hideInMenu——入口在铃铛，不占侧边导航。
+ * 布局挂父路由 handle（resolveRouteLayouts 只给「无 Component 有 children」的
+ * 父路由注入 layout，页面组件写父级上布局会被忽略、裸渲染无 chrome）。
+ */
+const routes: AppRouteRecordRaw[] = [
+	{
+		path: "/notification-center",
+		handle: {
+			layout: "container",
+			title: "notification:menu.notificationCenter",
+			icon: createElement(BellOutlined),
+			hideInMenu: true,
+		},
+		children: [
+			{
+				index: true,
+				Component: NotificationCenter,
+				handle: {
+					title: "notification:menu.notificationCenter",
+					icon: createElement(BellOutlined),
+				},
+			},
+		],
+	},
+];
+
 /**
- * notification 模块（G5 模板形态，对齐 apps/playground-oj/web/src/notification）。
+ * notification 模块（G5 模板形态）：通知聚合的唯一前端消费面。
  *
- * 无页面路由；仅通过 onInit 全量接管通知 API（D9 + G4）：把内置 root 级通知读/写
- * 收敛到本模块 `/notification` 前缀下的 oj 后端，通知铃的互动（单条已读/全部已读/
- * 清空）由此生效；发射端三方法（push/pushBroadcast/del）使本模块同时作为跨模块
- * 通知原语的接收端（前端 facade 委托至此）。
+ * onInit 全量接管通知 API（D9 + G4）：把通知读/写收敛到本模块 `/notification`
+ * 前缀下的 oj 后端，通知铃的互动（单条已读/全部已读/清空）由此生效；发射端
+ * 三方法（push/pushBroadcast/del）使本模块同时作为跨模块通知原语的接收端
+ * （前端 facade 委托至此）。
  */
 export default defineModule({
 	name: "notification",
-	description: "通知模块（D9/G4 注入通知读写）",
-	version: "0.0.2",
+	description: "通知模块（D9/G4 注入通知读写 + 通知中心页）",
+	version: "0.1.0",
 	peerRuntime: ">=0.0.0",
-	routes: [],
+	routes,
+	i18n: {
+		"zh-CN": () => import("./locales/zh-CN.json"),
+		"en-US": () => import("./locales/en-US.json"),
+	},
 	lifecycle: {
 		async onInit(ctx) {
 			// 构造即接线：createNotificationClient 登记契约前缀 /notification