@oj-module/cli 0.2.68 → 0.2.71

package/src/market/index-builder.ts

@@ -1,149 +0,0 @@
-/**
- * Form B 索引聚合（T4 + REG-CS5 三级化）：把「一批已扫出的包」变成分片索引的数据形状。
- *
- * 纯数据变换，不落 IO、不签名——IO 与签名归 `build-index.ts`（写入）与 `publish.ts`（补签）。
- * 形状严格对齐安装侧的消费口径（`market/api.ts resolveCdn`）：`archive.file` 必须逐字
- * `<name>-<version>.tgz`，否则安装侧 P2-11 会判索引投毒直接 502。
- *
- * REG-CS5：v2 起索引三级化——`catalog.yaml`（包名 → 分片号，无版本明细）+ `shards/<n>.yaml`
- * （每片 ≤1000 版本）+ 版本条目内嵌 Form B manifest（原 manifests.yaml 的聚合清单并入分片，
- * 装一个包只拉 1 catalog + 1 shard，不再有第三份全量清单）。版本条目即 Form B 条目：
- * `archive` 带 file/sha256/size/signature，与旧 manifests.yaml 逐字同构，故安装侧
- * 「取版本条目即取 manifest」，少一次全量拉取。
- */
-
-import type { YankEntry } from "./yank-ledger";
-
-/** 分片内的方案条目：版本数组 = Form B manifest 条目（升序） */
-export interface BuiltSolution {
-	name: string
-	latest: string
-	versions: Array<Record<string, unknown>>
-}
-
-export interface BuiltIndex {
-	solutions: BuiltSolution[]
-}
-
-/**
- * 聚合索引数据（分片形态）。
- *
- * `yanked?`：yank 账本（`name@version -> 条目`，REG-CS4）。非零时：
- * - 各版本条目带 `yanked: true` + `yanked_at`（epoch 秒），安装侧 resolveCdn 据此拒精确安装；
- * - 该方案的 `latest` 跳过已下线版本（全部下线则降级取最高版，保证索引不空）。
- */
-export function buildIndexData(packages: IndexedPackage[], yanked?: Map<string, YankEntry>): BuiltIndex {
-	const byName = new Map<string, IndexedPackage[]>();
-	for (const pkg of packages) {
-		const list = byName.get(pkg.name) ?? [];
-		list.push(pkg);
-		byName.set(pkg.name, list);
-	}
-
-	const solutions: BuiltSolution[] = [];
-	for (const name of [...byName.keys()].sort()) {
-		const list = [...byName.get(name)!].sort((a, b) => compareSemver(a.version, b.version));
-		// latest 跳过 yanked（REG-CS4）：已下线的版本绝不成为默认升级目标；全下线降级取最高版
-		const live = list.filter(v => !isYanked(yanked, name, v.version));
-		const latestSource = live.length > 0 ? live : list;
-		const versions = list.map((v) => {
-			const key = yanked !== undefined && isYanked(yanked, name, v.version)
-				? { yanked: true, yanked_at: yanked.get(`${name}@${v.version}`)!.at }
-				: {};
-			// 版本条目 = Form B manifest 条目：name/version/archive 与旧 manifests.yaml 逐字同构，
-			// 顶层再并进版本裁决字段（yanked）。安装侧「取条目即取 manifest」。
-			return {
-				...v.manifest,
-				name,
-				version: v.version,
-				archive: {
-					file: `${v.name}-${v.version}.tgz`,
-					sha256: v.sha256,
-					size: v.size,
-					...(v.signature === undefined ? {} : { signature: v.signature }),
-				},
-				...key,
-			};
-		});
-		solutions.push({ name, latest: latestSource[latestSource.length - 1]!.version, versions });
-	}
-	return { solutions };
-}
-
-/** 入索引的包（扫描产物；manifest 为包内 Form A，进分片时补成 Form B） */
-export interface IndexedPackage {
-	name: string
-	version: string
-	/** tgz 文件名（由 name+version 派生，逐字约束在此处一次成型） */
-	file: string
-	sha256: string
-	size: number
-	/** 包内 manifest（Form A） */
-	manifest: Record<string, unknown>
-	/** 包级 detached 签名（`<tgz>.sig` 五字段）；缺则 Form B 不带 signature，安装侧按 sig_missing 拒装 */
-	signature?: Record<string, unknown>
-}
-
-function isYanked(yanked: Map<string, YankEntry> | undefined, name: string, version: string): boolean {
-	return yanked !== undefined && yanked.has(`${name}@${version}`);
-}
-
-/**
- * semver 比较（与模板 `_lifecycle/semver.ts` 同源算法；prerelease 遵循 semver 2.0.0）：
- * 数字标识符按数值、字母按字典序、数字 < 字母、标识符列表前缀相等时多者大；无 prerelease > 有 prerelease。
- * 取代旧版纯数值比较（旧版对 `1.0.0-rc.1` 这类预发布版本按 `1.0.0.0` 处理，latest 计算失真——
- * S2-0 红队 F 相关预发布序修复）。返回 -1|0|1，可直接作 Array.sort 比较器。
- */
-export function compareSemver(a: string, b: string): -1 | 0 | 1 {
-	const va = splitVersion(a);
-	const vb = splitVersion(b);
-	const len = Math.max(va.core.length, vb.core.length);
-	for (let i = 0; i < len; i++) {
-		const diff = (va.core[i] ?? 0) - (vb.core[i] ?? 0);
-		if (diff !== 0)
-			return diff < 0 ? -1 : 1;
-	}
-	return comparePrerelease(va.pre, vb.pre);
-}
-
-/** 兼容旧名（过渡期别名；新调用请用 compareSemver） */
-export const compareVersion = compareSemver;
-
-function splitVersion(v: string): { core: number[], pre: string[] | null } {
-	const hyphen = v.indexOf("-");
-	const core = hyphen === -1 ? v : v.slice(0, hyphen);
-	const prePart = hyphen === -1 ? null : v.slice(hyphen + 1);
-	return {
-		core: core.split(".").map(seg => Number.parseInt(seg, 10) || 0),
-		pre: prePart == null ? null : prePart.split("."),
-	};
-}
-
-function comparePrerelease(a: string[] | null, b: string[] | null): -1 | 0 | 1 {
-	if (a === null || b === null) {
-		return a === b ? 0 : a === null ? 1 : -1;
-	}
-	const len = Math.max(a.length, b.length);
-	for (let i = 0; i < len; i++) {
-		const ia = a[i];
-		const ib = b[i];
-		if (ia === undefined)
-			return -1;
-		if (ib === undefined)
-			return 1;
-		const na = /^\d+$/.test(ia);
-		const nb = /^\d+$/.test(ib);
-		if (na && nb) {
-			const diff = Number.parseInt(ia, 10) - Number.parseInt(ib, 10);
-			if (diff !== 0)
-				return diff < 0 ? -1 : 1;
-		}
-		else if (na !== nb) {
-			return na ? -1 : 1;
-		}
-		else if (ia !== ib) {
-			return ia < ib ? -1 : 1;
-		}
-	}
-	return 0;
-}

package/src/market/sharding.ts

@@ -1,94 +0,0 @@
-/**
- * REG-CS5 装箱（D3）：把「一批方案」装进分片，每片 ≤ `SHARD_MAX_VERSIONS` 个版本。
- *
- * 纯数据变换，不落 IO、不签名——编号与落盘归 `build-index.ts`。
- *
- * 三条策略（计划 §S2-1 子任务 2，D3 已定）：
- * 1. **整包装箱**：一个方案不跨片，除非它自己的版本数就超限——那种极端包才按连续上限切片，
- *    且仍占连续片号（读方按片号倒序试取，最高片装最新版，`latest` 安装只拉 1 片）。
- * 2. **确定性**：输入方案顺序即输出顺序（调用方已按名称字典序排好），同样目录内容永远装出
- *    同样结果——「索引只取决于目录内容」这条性质靠它成立。
- * 3. **累加到上限开新片**：按版本数往当前片累加，放不下就开新片（计划原文「按版本数累加到
- *    上限开新片」，上限值经执行期实测校准，见下）。已有包因此天然不换片：只在它前面的内容变了才被挤动。
- *
- * 体积口径（需求 §7，2026-10-25 执行期实测校准）：需求原文按「单条 Form B ≈535–684B」
- * 估 2000 版本/片 ≈1.2MB；但本仓参考 manifest 形态（fixture.ts solutionManifest，945B YAML）
- * 实测单条 Form B 条目 ≈1.2KB——2000/片 = 2.4MB，超计划 §S2-1「单片 ≤1.5MB」验收闸。
- * 校准为 1000 版本/片：参考形态下 ≈1.2MB，正中需求目标；fat manifest 的最坏面也随砍半。
- */
-
-import type { BuiltSolution } from "./index-builder";
-
-/** 单片最大版本数（REG-CS5：1000 版本 ≈1.2MB，计划验收 ≤1.5MB；实测依据见文件头） */
-export const SHARD_MAX_VERSIONS = 1000;
-
-/** 一个分片槽位（编号由 build-index 按内容匹配分配，这里只带内容） */
-export interface ShardSlot {
-	/** 片内方案（顺序 = 装配顺序；版本在各方案内升序） */
-	solutions: BuiltSolution[]
-	/** 片内版本总数（≤SHARD_MAX_VERSIONS；超限包独占多片时每片恰为上限） */
-	versions: number
-}
-
-/** 包名 → 所占片号（升序；读方倒序试取） */
-export type ShardAssignment = Map<string, number[]>;
-
-export interface PackedShards {
-	/** 槽位序列（顺序即装配顺序；编号未分配，见 ShardSlot） */
-	slots: ShardSlot[]
-	/** 包名 → 片号（升序） */
-	assignment: ShardAssignment
-}
-
-/**
- * 装箱。调用方保证 `solutions` 已按名称字典序（buildIndexData 的产出即如此）。
- *
- * 超限包（版本数 > `SHARD_MAX_VERSIONS`）切片时每片都是完整方案条目（带 name/latest），`latest` 恒取
- * 包级真值——读方片号倒序，最高片必含最新版本，`latest` 只在最高片被消费；低片里的
- * `latest` 是自洽兜底（指向本片最高版），不会被安装路径读到。
- */
-export function packShards(solutions: BuiltSolution[]): PackedShards {
-	const slots: ShardSlot[] = [];
-	const assignment: ShardAssignment = new Map();
-	let current: ShardSlot = { solutions: [], versions: 0 };
-
-	for (const solution of solutions) {
-		if (solution.versions.length > SHARD_MAX_VERSIONS) {
-			// 超限包：先把当前片收尾，再按连续上限独占多片
-			if (current.solutions.length > 0) {
-				slots.push(current);
-				current = { solutions: [], versions: 0 };
-			}
-			const nos: number[] = [];
-			for (let at = 0; at < solution.versions.length; at += SHARD_MAX_VERSIONS) {
-				const chunk: BuiltSolution = {
-					name: solution.name,
-					latest: solution.latest,
-					versions: solution.versions.slice(at, at + SHARD_MAX_VERSIONS),
-				};
-				slots.push({ solutions: [chunk], versions: chunk.versions.length });
-				nos.push(slots.length); // 片号 = 槽位序号（1 起）
-			}
-			assignment.set(solution.name, nos);
-			continue;
-		}
-		if (current.versions + solution.versions.length > SHARD_MAX_VERSIONS) {
-			slots.push(current);
-			current = { solutions: [], versions: 0 };
-		}
-		current.solutions.push(solution);
-		current.versions += solution.versions.length;
-		const nos = assignment.get(solution.name) ?? [];
-		nos.push(slots.length + 1); // 当前片编号 = 已收尾片数 + 1
-		assignment.set(solution.name, nos);
-	}
-	if (current.solutions.length > 0)
-		slots.push(current);
-
-	// 空索引也要有一个空片——catalog 的 shards 映射不为空，读方「拉 catalog 即知天下」
-	// （无片可拉时装任何包都走 404 分支，与空索引时代同语义）
-	if (slots.length === 0)
-		slots.push({ solutions: [], versions: 0 });
-
-	return { slots, assignment };
-}

package/src/market/yank-ledger.ts

@@ -1,91 +0,0 @@
-/**
- * yank 账本（REG-CS4）：把「某版本已下线」这个事实从索引正文里抽出来，单独持久化。
- *
- * 为什么独立成账本：索引是**派生重建产物**（`build-index` 每次全量重扫 `cdn/*.tgz`），
- * tgz 文件本身不删除（yank ≠ delete）——所以「谁被下线」不能靠「文件不在」推断，必须有
- * 一份能跨重建存活的真源。账本就是这份真源：`cdn/yanked.json`（`name@version -> 条目`）。
- *
- * 重建索引时，`build-index` 读账本把对应版本标 `yanked: true` + `yanked_at`，并让 `latest`
- * 跳过已下线版本。`ojm market yank <name>@<version>` 写账本后顺手重建索引。
- */
-
-import fs from "node:fs";
-import path from "node:path";
-
-import { resolveCdnLayout } from "./cdn-layout";
-
-/** 单条 yank 记录（审计留痕：谁、何时、为何） */
-export interface YankEntry {
-	/** 方案名 */
-	name: string
-	/** 版本 */
-	version: string
-	/** 下线时刻（epoch 秒） */
-	at: number
-	/** 操作人（CLI 本地形态来自 --by；registry 上线后由会话身份注入） */
-	by: string
-	/** 下线原因（可选，审计用） */
-	reason?: string
-}
-
-/** 账本 key：`<name>@<version>`，与 install 侧 resolveCdn 的命中口径一致 */
-export function yankKey(name: string, version: string): string {
-	return `${name}@${version}`;
-}
-
-/** 账本磁盘路径：`cdn/yanked.json` */
-export function yankLedgerPath(projectRoot: string): string {
-	return path.join(resolveCdnLayout(projectRoot).dir, "yanked.json");
-}
-
-/**
- * 读账本。文件不存在 → 空表（视为「无下线记录」）；非法 JSON → 抛错（fail-closed，不静默当空）。
- * 返回以 `yankKey` 为键的条目表，供 build-index 快速查某版本是否被下线。
- */
-export function readYankLedger(projectRoot: string): Map<string, YankEntry> {
-	const file = yankLedgerPath(projectRoot);
-	if (!fs.existsSync(file))
-		return new Map();
-	const parsed = JSON.parse(fs.readFileSync(file, "utf-8")) as unknown;
-	if (!isObj(parsed))
-		throw new Error(`[ojm] yank 账本 ${file} 不是合法 JSON 对象（应为 name@version → 条目 的映射）`);
-	const out = new Map<string, YankEntry>();
-	for (const [key, raw] of Object.entries(parsed)) {
-		if (!isObj(raw))
-			continue;
-		const { name, version, at, by, reason } = raw as Record<string, unknown>;
-		if (typeof name !== "string" || typeof version !== "string" || typeof at !== "number" || typeof by !== "string")
-			continue;
-		out.set(key, { name, version, at, by, ...(typeof reason === "string" ? { reason } : {}) });
-	}
-	return out;
-}
-
-/**
- * 标记某版本已下线（写账本）。幂等：重复 yank 同一版本不重复写、返回 created=false。
- * 目标版本在 `cdn/*.tgz` 中不存在 → 抛明确错误（REG-CS4 验收：对不存在的版本报明确错误）。
- */
-export function markYanked(
-	projectRoot: string,
-	name: string,
-	version: string,
-	opts: { by: string, reason?: string, now?: number },
-): { created: boolean } {
-	const file = yankLedgerPath(projectRoot);
-	const dir = path.dirname(file);
-	// 目标版本必须真实存在于 cdn（文件名严格 <name>-<version>.tgz）——yank 的是「已发布版本」
-	if (!fs.existsSync(path.join(dir, `${name}-${version}.tgz`)))
-		throw new Error(`[ojm] 无法下线 ${name}@${version}：cdn 目录下不存在 ${name}-${version}.tgz（只可下线已发布的版本）`);
-	const ledger = readYankLedger(projectRoot);
-	const key = yankKey(name, version);
-	if (ledger.has(key))
-		return { created: false };
-	ledger.set(key, { name, version, at: opts.now ?? Math.floor(Date.now() / 1000), by: opts.by, ...(opts.reason !== undefined ? { reason: opts.reason } : {}) });
-	fs.mkdirSync(dir, { recursive: true });
-	fs.writeFileSync(file, `${JSON.stringify(Object.fromEntries(ledger), null, 2)}\n`);
-	return { created: true };
-}
-
-function isObj(v: unknown): v is Record<string, unknown> {
-	return v !== null && typeof v === "object" && !Array.isArray(v);
-}

package/templates/src/app/api/_platform/_lifecycle/source-seq.ts

@@ -1,88 +0,0 @@
-// REG-CS2 索引新鲜度（防回放/降级）：站点按源记住「见过的最大 seq」，回退即拒。
-//
-// 记在站点 DB（`reg_source_seq`，0014 迁移）而不记在 CLI：受害者是**站点**——镜像把旧索引
-// 回放给谁，谁就是被降级的一方（D1 已定，CLI/API 一致）。CLI 侧 `ojm market verify` 是
-// 离线单点校验，没有「上次见过的 seq」，故不做这项判定。
-//
-// fail-closed 口径（与 REG-CS1 同源）：
-// - 读不到 / 读到非正整数 / 写入失败 —— 一律按 `index_state_corrupt` 拒，不静默重置。
-//   静默重置等于把「防回放」降级成「每次都当第一次见」，攻击者先破坏状态再回放即穿。
-// - 表不存在同样算读不到：迁移由 _platform 自带，起不来就该响，不该悄悄放行。
-
-// db 为 oj isolate 注入全局（同模板 service 层惯例，history.ts 同款；测试由夹具装 globalThis.db）
-declare const db: { table: (name: string) => any };
-
-export const SOURCE_SEQ_TABLE = "reg_source_seq";
-
-/** 判定：ok = 放行并已记录；!ok = 拒，`code` 区分「回放/降级」与「状态损坏」 */
-export type SourceSeqVerdict = {
-	ok: true
-	prev: number | null
-} | {
-	ok: false
-	code: "index_stale" | "index_state_corrupt"
-	prev: number | null
-};
-
-/**
- * 比对并推进某个源的最大 seq。
- *
- * - 首次见（无行）→ 记录并放行；
- * - 同 seq 重复拉取 → 放行（幂等，不误伤正常重复请求），不重复写；
- * - seq 回退（< 记录值）→ `index_stale` 拒，且不覆盖记录（不能让回放把水位拉低）。
- */
-export async function guardAndRecordSourceSeq(source: string, seq: number): Promise<SourceSeqVerdict> {
-	const prev = await readSourceSeq(source);
-	if (prev === "corrupt")
-		return { ok: false, code: "index_state_corrupt", prev: null };
-	if (prev !== null && seq < prev)
-		return { ok: false, code: "index_stale", prev };
-	if (prev === seq)
-		return { ok: true, prev };
-	try {
-		await writeSourceSeq(source, seq);
-	}
-	catch {
-		// 写失败按 fail-closed 转「状态损坏」——不静默重置（否则防回放被降级成「每次都当第一次见」）
-		return { ok: false, code: "index_state_corrupt", prev: null };
-	}
-	return { ok: true, prev };
-}
-
-/** 读取记录：无行 → null；读不到或非正整数 → "corrupt"（bigint 是 pg/mysql 的整型口径，一并认） */
-export async function readSourceSeq(source: string): Promise<number | null | "corrupt"> {
-	let rows: Array<{ max_seq?: unknown }>;
-	try {
-		rows = await db.table(SOURCE_SEQ_TABLE)
-			.select(["max_seq"])
-			.where({ field: "source_url", op: "eq", value: source })
-			.limit(1)
-			.all() as Array<{ max_seq?: unknown }>;
-	}
-	catch {
-		return "corrupt";
-	}
-	if (!Array.isArray(rows) || rows.length === 0)
-		return null;
-	const raw = rows[0]?.max_seq;
-	if (typeof raw === "bigint")
-		return raw >= 1n ? Number(raw) : "corrupt";
-	if (typeof raw === "number" && Number.isInteger(raw) && raw >= 1)
-		return raw;
-	return "corrupt";
-}
-
-/**
- * 记录某源的最大 seq：先 insert（首见），撞唯一键（并发首见同源）则降级为 update。
- * 这样消除「SELECT 再 INSERT」的 TOCTOU——并发首装同源不再因唯一键冲突被误判成
- * index_state_corrupt；任何写失败仍向上抛，由 guard 按 fail-closed 转成 index_state_corrupt。
- */
-export async function writeSourceSeq(source: string, seq: number): Promise<void> {
-	const now = Math.floor(Date.now() / 1000);
-	try {
-		await db.table(SOURCE_SEQ_TABLE).insert({ source_url: source, max_seq: seq, updated_at: now }).run();
-	}
-	catch {
-		await db.table(SOURCE_SEQ_TABLE).update({ max_seq: seq, updated_at: now }).where({ field: "source_url", op: "eq", value: source }).run();
-	}
-}

package/templates/src/app/api/_platform/market/index-source.ts

@@ -1,112 +0,0 @@
-// REG-CS5 三级索引读取源（DIP，S2-1③）：把「索引字节从哪来」与「索引怎么校验」分开。
-// 本模块只负责取字节——HTTP（条件请求/304）与本地目录两实现；签名校验、同代钉值校验、
-// 新鲜度校验全部留在调用方 market/api.ts（fetchIndex），读写两侧不重复实现校验语义。
-//
-// 三级索引形态（与 ojm market build-index 落盘逐字一致）：
-//   catalog.yaml        总目录：{seq, issued_at, expires_at, shards: {<片号>: <代次钉值>},
-//                          solutions: [{name, shards: [<片号>...]}]}——无版本明细，提交点
-//   shards/<n>.yaml     分片：{solutions: [{name, latest, versions: [<Form B 条目>]}]}——
-//                          纯内容无 meta，代次由 .sig 与 catalog 钉值携带；版本条目即 manifest
-
-import type { FetchInitFace } from "../_shared/site-facade";
-import { fsFace } from "../_lifecycle/atomic";
-
-/** 索引文件种类（REG-CS1：签名覆盖 (kind, seq)；与 ojm publish 的 IndexKind 逐字同集合） */
-export type IndexKind = "catalog" | "shard";
-
-/** 索引文件（正文 + detached 签名）。sig 缺失 → null：调用方按 index_sig_missing 拒载，不猜 */
-export interface IndexFile {
-	body: string
-	sig: string | null
-}
-
-/**
- * 索引读取源（S2-1③ DIP）：`read` 返回 null = 拉不到（网络错 / 非 2xx / 文件不存在），
- * 拒载还是降级由调用方裁决——本模块不做任何校验决策、不抛业务错误。
- */
-export interface IndexSource {
-	read: (kind: IndexKind, no?: number) => Promise<IndexFile | null>
-}
-
-/** 索引相对路径（CDN 布局单点：catalog.yaml + shards/<n>.yaml；片号由调用方校验为正整数） */
-export function indexPathOf(kind: IndexKind, no?: number): string {
-	return kind === "catalog" ? "catalog.yaml" : `shards/${no}.yaml`;
-}
-
-/**
- * 条件请求缓存（进程/模块级，与 site-facade 的 canonicalOriginCache 同模式）：
- * url → {etag, body}。oj isolate 若按请求新建则退化为「请求内去重」，若被运行时复用则
- * 跨请求生效——两种生命周期下语义都正确：304 时服务端已确认字节未变，缓存正文即可信。
- */
-const etagCache = new Map<string, { etag: string, body: string }>();
-
-/**
- * HTTP 索引源（S2-1③/④）：ETag + If-None-Match 条件请求，304 走缓存正文不重传。
- *
- * **不再发 `cache-control: no-cache`**（旧口径）：读面新鲜度改由服务端缓存头
- * （`Cache-Control: max-age=60, stale-while-revalidate=60`，Q8：yank 最坏 120s 生效）
- * 与条件请求共同承载。索引自身仍带 expires_at（REG-CS2 硬过期即拒）与 seq 水位
- * （防回放），缓存层只决定「少传字节」，不决定「信不信」——§5.3 可用性通道的
- * 「窗口内用缓存副本」由 HTTP 缓存层（中间层 + 服务端 ETag/304）兑现，读取器不存第二份真相。
- */
-export function httpIndexSource(fetch: FetchInitFace, base: string): IndexSource {
-	const root = base.replace(/\/+$/, "");
-	const readOne = async (rel: string): Promise<string | null> => {
-		const url = `${root}/${rel}`;
-		const cached = etagCache.get(url);
-		let res: Awaited<ReturnType<FetchInitFace>>;
-		try {
-			res = await fetch(url, cached === undefined ? undefined : { headers: { "if-none-match": cached.etag } });
-		}
-		catch {
-			return null; // 网络层失败：拉不到，拒载/降级决策归调用方
-		}
-		// 304：服务端认了我们的 ETag——正文未变，用缓存副本，不重传（BDD：重复拉取走 304）
-		if (res.status === 304 && cached !== undefined)
-			return cached.body;
-		if (!res.ok)
-			return null;
-		const body = new TextDecoder().decode(await res.arrayBuffer());
-		// 无 ETag 的响应不进缓存：没有条件请求的锚点，缓存它毫无意义
-		const etag = res.headers?.get("etag") ?? res.headers?.get("ETag") ?? null;
-		if (etag !== null && etag !== "")
-			etagCache.set(url, { etag, body });
-		return body;
-	};
-	return {
-		read: async (kind, no) => {
-			const rel = indexPathOf(kind, no);
-			const [body, sig] = await Promise.all([readOne(rel), readOne(`${rel}.sig`)]);
-			return body === null ? null : { body, sig };
-		},
-	};
-}
-
-/**
- * 本地目录索引源（S2-1③ 第二实现）：索引就在本机目录（离线消费 / 自供直读 / 测试夹具），
- * 不经 HTTP。校验语义与 HTTP 实现完全同构——调用方看不出区别，这正是 DIP 的目的。
- */
-export function localIndexSource(dir: string): IndexSource {
-	const root = dir.replace(/\/+$/, "");
-	return {
-		read: async (kind, no) => {
-			const f = fsFace();
-			const rel = indexPathOf(kind, no);
-			let body: string;
-			try {
-				body = new TextDecoder().decode(await f.readFile(`${root}/${rel}`));
-			}
-			catch {
-				return null; // 目录里没有这个索引文件
-			}
-			let sig: string | null = null;
-			try {
-				sig = new TextDecoder().decode(await f.readFile(`${root}/${rel}.sig`));
-			}
-			catch {
-				sig = null; // 缺签名：调用方按 index_sig_missing 拒载（与 HTTP 实现同口径）
-			}
-			return { body, sig };
-		},
-	};
-}

package/templates/tests/lifecycle/source-seq.spec.ts

@@ -1,55 +0,0 @@
-// BDD：源代次水位（REG-CS2 防回放）——站点按源记住「见过的最大 seq」，回退即拒。
-//
-// 表 `reg_source_seq` 由 _platform 0014 迁移建；夹具直读真实迁移文件，与迁移零漂移。
-// 四条负向是 G7 的重点：水位写坏 / 表不存在 / 值非法都必须**拒**，不能静默当「第一次见」——
-// 静默重置等于把「防回放」降级成「每次都当第一次见」，攻击者先破坏状态再回放即可穿透。
-import { beforeEach, describe, expect, it } from "vitest";
-import { guardAndRecordSourceSeq, readSourceSeq, SOURCE_SEQ_TABLE } from "../../src/app/api/_platform/_lifecycle/source-seq";
-import { installDb } from "../fixture";
-
-const SRC = "https://cdn.example.com/solutions";
-
-let dbo: any;
-
-beforeEach(() => {
-	dbo = installDb();
-});
-
-describe("given 站点第一次见某个源 When 拉到它的索引", () => {
-	it("then 记录水位并放行（prev = null）", async () => {
-		expect(await readSourceSeq(SRC)).toBeNull();
-		expect(await guardAndRecordSourceSeq(SRC, 3)).toEqual({ ok: true, prev: null });
-		expect(await readSourceSeq(SRC)).toBe(3);
-	});
-});
-
-describe("given 同一代重复拉取 When 再判一次", () => {
-	it("then 幂等放行，且不改写水位（不误伤正常重复请求）", async () => {
-		await guardAndRecordSourceSeq(SRC, 5);
-		expect(await guardAndRecordSourceSeq(SRC, 5)).toEqual({ ok: true, prev: 5 });
-		expect(await readSourceSeq(SRC)).toBe(5);
-	});
-});
-
-describe("given 源返回更旧的代次 When 判水位", () => {
-	it("then 拒 index_stale，且不把水位拉低（回放改不了水位）", async () => {
-		await guardAndRecordSourceSeq(SRC, 7);
-		expect(await guardAndRecordSourceSeq(SRC, 3)).toEqual({ ok: false, code: "index_stale", prev: 7 });
-		expect(await readSourceSeq(SRC)).toBe(7);
-	});
-});
-
-describe("given 水位被写成非法值 When 判水位", () => {
-	it("then 按 index_state_corrupt 拒（不静默重置成「没见过」）", async () => {
-		dbo.prepare(`INSERT INTO ${SOURCE_SEQ_TABLE} (source_url, max_seq, updated_at) VALUES (?, ?, ?)`).run(SRC, 0, 1);
-		expect(await readSourceSeq(SRC)).toBe("corrupt");
-		expect(await guardAndRecordSourceSeq(SRC, 9)).toEqual({ ok: false, code: "index_state_corrupt", prev: null });
-	});
-});
-
-describe("given 水位表不存在（站点未 migrate）When 判水位", () => {
-	it("then 按 index_state_corrupt 拒（fail-closed，不悄悄放行）", async () => {
-		dbo.exec(`DROP TABLE ${SOURCE_SEQ_TABLE}`);
-		expect(await guardAndRecordSourceSeq(SRC, 1)).toEqual({ ok: false, code: "index_state_corrupt", prev: null });
-	});
-});