@tbox.cn/app-toolkit 0.1.0

package/tests/file-cache.test.ts

@@ -0,0 +1,242 @@
+import { describe, it, expect } from 'vitest';
+import { readdirSync, readFileSync, statSync, writeFileSync, mkdirSync, rmSync, mkdtempSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { createFileCache } from '../src/core/file-cache.js';
+import { writeAtomic } from '../src/core/fskit.js';
+import { resolveContractsForApp, invalidateContractsResolver } from '../src/core/contracts-resolver.js';
+import { createTempApp, writeFakeContractsPackage, linkContracts, writeAppFile, bumpMtime, type TempApp } from './demo-app.js';
+import { walkManifests } from '../src/assembly/walk-manifests.js';
+import { createAppToolkit } from '../src/factory.js';
+
+/**
+ * 一致性矩阵 W1-W7 = **Freshness Contract 验收面**（技术方案 §2.5 单源）。
+ * C2 落 W1/W2/W4/W5/W6（file-cache/fskit/resolver 原语级）；
+ * W3（模块装卸枚举零缓存）/W7（agent 动线矩阵——工厂方法级）随 walkManifests（C3）与
+ * views 工厂（C4）落地补全——本文件即验收面挂载点，不另立文件。
+ */
+
+describe('file-cache / Freshness Contract', () => {
+  it('W1 read-your-writes：写 → 同实例读反映写入；同毫秒连写两次 → 读到第二次内容', () => {
+    const cache = createFileCache();
+    const file = join(mkdtempSync(join(tmpdir(), 'tbox-w1-')), 'data.json');
+    writeAtomic(file, '{"v":1}');
+    expect(cache.read(file, JSON.parse)).toEqual({ v: 1 });
+    // 同毫秒连写两次（mtime 粒度陷阱）——写后失效兜底，不依赖 mtime
+    writeAtomic(file, '{"v":2}');
+    cache.invalidate([file]);
+    writeAtomic(file, '{"v":3}');
+    cache.invalidate([file]);
+    expect(cache.read(file, JSON.parse)).toEqual({ v: 3 });
+  });
+
+  it('W2 外部写自愈：绕过 toolkit 直写文件 → 下一笔读 stat 指纹不命中 → 重读', () => {
+    const cache = createFileCache();
+    const file = join(mkdtempSync(join(tmpdir(), 'tbox-w2-')), 'data.json');
+    writeFileSync(file, '{"v":"old"}');
+    expect(cache.read(file, JSON.parse)).toEqual({ v: 'old' });
+    // 外部写（模拟 files API / CLI / agent）——mtimeMs+size 指纹变化；
+    // mtime 前移：粗粒度 fs（CI overlayfs）同 tick 同 size 重写指纹不变属边界②，显式模拟更晚写入
+    writeFileSync(file, '{"v":"new"}');
+    bumpMtime(file);
+    expect(cache.read(file, JSON.parse)).toEqual({ v: 'new' });
+  });
+
+  it('W5 写中读无撕裂：原子写并发读 → 恒完整 JSON（旧完整或新完整，永不半截）', () => {
+    const cache = createFileCache();
+    const dir = mkdtempSync(join(tmpdir(), 'tbox-w5-'));
+    const file = join(dir, 'data.json');
+    writeAtomic(file, JSON.stringify({ big: 'a'.repeat(4096) }));
+    const writer = setInterval(() => {
+      writeAtomic(file, JSON.stringify({ big: Math.random().toString(36).repeat(256) }));
+    }, 1);
+    try {
+      for (let i = 0; i < 200; i += 1) {
+        const parsed = cache.read(file, (raw) => JSON.parse(raw) as { big: string });
+        expect(typeof parsed?.big).toBe('string');
+      }
+    } finally {
+      clearInterval(writer);
+    }
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  it('W6 缓存命中不重 parse：二次读同文件 parse 调用不增（spy 计数）', () => {
+    const cache = createFileCache();
+    const file = join(mkdtempSync(join(tmpdir(), 'tbox-w6-')), 'data.json');
+    writeFileSync(file, '{"n":1}');
+    let parseCalls = 0;
+    const parse = (raw: string) => {
+      parseCalls += 1;
+      return JSON.parse(raw) as { n: number };
+    };
+    cache.read(file, parse);
+    expect(parseCalls).toBe(1);
+    cache.read(file, parse);
+    cache.read(file, parse);
+    expect(parseCalls).toBe(1); // 命中路径零 parse
+    expect(cache.parseCount).toBe(1);
+    // 同 stat 指纹外力覆写不可觉察是 Freshness Contract 边界②——此处不模拟
+  });
+
+  it('invalidate(paths) 定向失效；invalidate() 全失效；parse 失败不缓存（下一笔重试）', () => {
+    const cache = createFileCache();
+    const dir = mkdtempSync(join(tmpdir(), 'tbox-w6b-'));
+    const a = join(dir, 'a.json');
+    const b = join(dir, 'b.json');
+    writeFileSync(a, '{"f":"a"}');
+    writeFileSync(b, '{"f":"b"}');
+    cache.read(a, JSON.parse);
+    cache.read(b, JSON.parse);
+    expect(cache.parseCount).toBe(2);
+    cache.invalidate([a]);
+    cache.read(a, JSON.parse);
+    expect(cache.parseCount).toBe(3); // a 重 parse；b 仍命中
+    cache.read(b, JSON.parse);
+    expect(cache.parseCount).toBe(3);
+    // parse 失败不缓存
+    writeFileSync(a, '{broken');
+    expect(() => cache.read(a, JSON.parse)).toThrow();
+    writeFileSync(a, '{"f":"fixed"}');
+    expect(cache.read(a, JSON.parse)).toEqual({ f: 'fixed' });
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  it('W4 contracts 版本升级：换 fixture version → resolveContracts 重解析（新版本语义生效）', async () => {
+    const app: TempApp = createTempApp('tbox-w4-');
+    invalidateContractsResolver();
+    const store = join(app.appDir, 'store');
+    writeFakeContractsPackage(store, { version: '0.8.0', withStrict: false });
+    linkContracts(app.appDir, store, { subdir: 'apps/server' });
+    const before = await resolveContractsForApp(app.appDir);
+    expect(before.strictValidation).toBe(false);
+    // 升级：同 store 原地换 version + 补严格面（pnpm update 换 store 路径的等价模拟——候选路径 version 变化）；
+    // mtime 前移防粗粒度 fs 同 tick 指纹不变（边界②）
+    writeFakeContractsPackage(store, { version: '0.9.0', withStrict: true });
+    bumpMtime(join(store, 'package.json'));
+    const after = await resolveContractsForApp(app.appDir);
+    expect(after.version).toBe('0.9.0');
+    expect(after.strictValidation).toBe(true);
+    app.dispose();
+  });
+});
+
+// W3（模块装卸：packages/ 增删 → walkManifests 反映）与 W7（agent 动线矩阵：外部写 integrations /
+// packages 新增模块 / .tbox/app.json 增补 / contracts 升级 四用例）——FX-3 补全（D26 验收面挂载点）。
+
+describe('Freshness Contract W3/W7 — agent 动线矩阵（工厂方法级；FX-3）', () => {
+  it('W3 模块装卸：packages/ 增删目录 → walkManifests 反映（目录枚举零缓存）', () => {
+    const app = createTempApp('tbox-w3-');
+    expect(walkManifests(app.appDir).modules).toHaveLength(0);
+    // 新增模块目录（module add 语义——业务包磁盘足迹）
+    mkdirSync(join(app.appDir, 'packages', 'module-new'), { recursive: true });
+    writeFileSync(
+      join(app.appDir, 'packages', 'module-new', 'tbox.module.json'),
+      JSON.stringify({ schemaVersion: 1, name: 'module-new', contributes: { services: [{ service: 'new.slot' }] } }),
+    );
+    const walk = walkManifests(app.appDir);
+    expect(walk.modules.map((m) => m.id)).toContain('module-new');
+    expect(Object.keys(walk.catalog.services)).toContain('new.slot');
+    // 删除目录 → 下一笔消失
+    rmSync(join(app.appDir, 'packages', 'module-new'), { recursive: true, force: true });
+    const after = walkManifests(app.appDir);
+    expect(after.modules.map((m) => m.id)).not.toContain('module-new');
+    expect(Object.keys(after.catalog.services)).not.toContain('new.slot');
+    app.dispose();
+  });
+
+  it('W7 agent 动线矩阵四用例：外部写 integrations / packages 新增模块 / app.json 增补 / contracts 升级', async () => {
+    const app = createTempApp('tbox-w7-');
+    invalidateContractsResolver();
+    const store = join(app.appDir, 'contracts-store');
+    writeFakeContractsPackage(store, { version: '0.9.0' });
+    linkContracts(app.appDir, store, { subdir: 'apps/server' });
+    writeAppFile(app.appDir, 'config/integrations.json', JSON.stringify({ services: {} }));
+    const tk = createAppToolkit(app.appDir);
+
+    // a. 外部写 integrations.json（files API / CLI 动线）→ 下一笔读反映（stat 指纹自愈）
+    writeAppFile(
+      app.appDir,
+      'config/integrations.json',
+      JSON.stringify({ services: { 'parking.query': { provider: 'mock', instances: { 'mall-a': {} } } } }),
+    );
+    const batch1 = await tk.loadServiceResolutions();
+    expect(Object.keys(batch1.resolutions)).toContain('parking.query');
+    const detail = await tk.loadService('parking.query');
+    expect(detail.integration).toEqual({ provider: 'mock', instances: { 'mall-a': {} } });
+
+    // b. packages/ 新增模块目录（module add）→ 下一笔 loadModules/loadProviders 反映
+    mkdirSync(join(app.appDir, 'packages', 'provider-x'), { recursive: true });
+    writeFileSync(join(app.appDir, 'packages', 'provider-x', 'package.json'), JSON.stringify({ name: '@app/provider-x', version: '0.1.0' }));
+    writeFileSync(
+      join(app.appDir, 'packages', 'provider-x', 'tbox.module.json'),
+      JSON.stringify({
+        schemaVersion: 1,
+        name: 'provider-x',
+        contributes: {
+          providers: { slots: [{ service: 'parking.query', provider: 'joycity', implementation: 'joycity-parking@1', credentialType: 'joycity-c' }] },
+          services: [{ service: 'member.account' }],
+        },
+      }),
+    );
+    const modules = await tk.loadModules();
+    expect(modules.modules.map((m) => m.id)).toContain('provider-x');
+    const providers = await tk.loadProviders();
+    expect(providers.providers.map((p) => p.provider)).toContain('joycity');
+
+    // c. .tbox/app.json npmModules 增补 + node_modules 新包 → catalog 聚合反映（双通道）
+    mkdirSync(join(app.appDir, '.tbox'), { recursive: true });
+    writeFileSync(
+      join(app.appDir, '.tbox', 'app.json'),
+      JSON.stringify({ templateVersion: 't', npmModules: [{ id: 'module-sdk-y', package: '@sdk/module-sdk-y', version: '0.1.0', mode: 'sdk' }] }),
+    );
+    const sdkDir = join(app.appDir, 'node_modules', '@sdk', 'module-sdk-y');
+    mkdirSync(sdkDir, { recursive: true });
+    writeFileSync(
+      join(sdkDir, 'tbox.module.json'),
+      JSON.stringify({ schemaVersion: 1, name: 'module-sdk-y', contributes: { services: [{ service: 'sdk.slot-y', title: 'Sdk 槽' }] } }),
+    );
+    const modules2 = await tk.loadModules();
+    expect(modules2.modules.map((m) => m.id)).toContain('module-sdk-y');
+    const batch2 = await tk.loadServiceResolutions();
+    expect(Object.keys(batch2.resolutions)).toContain('sdk.slot-y');
+
+    // d. contracts 升级（原地 bump——version 轻探测）→ 重解析 + 新版本语义生效
+    const pkgPath = join(store, 'package.json');
+    writeFileSync(pkgPath, readFileSync(pkgPath, 'utf8').replace('0.9.0', '0.9.5'));
+    bumpMtime(pkgPath); // mtime 前移防粗粒度 fs 同 tick 指纹不变（边界②）
+    const contracts = await tk.resolveContracts();
+    expect(contracts.version).toBe('0.9.5');
+    app.dispose();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// 目录枚举零缓存约束（D26）的机制面 sanity：fskit/file-cache 均不缓存目录列表
+// ---------------------------------------------------------------------------
+describe('目录枚举零缓存约束（机制面）', () => {
+  it('file-cache 不提供目录枚举能力（约束由 API 形状承载——readdir 每次由 walkManifests 执行）', () => {
+    const cache = createFileCache();
+    const keys = Object.keys(cache);
+    expect(keys).not.toContain('readdir');
+    expect(keys).not.toContain('listDir');
+  });
+
+  it('readdirSync 直接反映目录增删（枚举零缓存的行为基线）', () => {
+    const dir = mkdtempSync(join(tmpdir(), 'tbox-enum-'));
+    expect(readdirSync(dir)).toEqual([]);
+    mkdirSync(join(dir, 'module-x'));
+    expect(readdirSync(dir)).toContain('module-x');
+    rmSync(join(dir, 'module-x'), { recursive: true });
+    expect(readdirSync(dir)).not.toContain('module-x');
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  it('writeAppFile（builder 外部写模拟）落盘即 stat 可见', () => {
+    const app = createTempApp('tbox-enum2-');
+    writeAppFile(app.appDir, 'config/integrations.json', '{"v":1}');
+    const st = statSync(join(app.appDir, 'config', 'integrations.json'));
+    expect(st.size).toBeGreaterThan(0);
+    app.dispose();
+  });
+});

package/tests/import-layers.test.ts

@@ -0,0 +1,111 @@
+import { describe, it, expect } from 'vitest';
+import { readFileSync, readdirSync, statSync } from 'node:fs';
+import { join, relative, sep } from 'node:path';
+
+/**
+ * import 前缀 guard（包内自测——随 pnpm -r test 进 verify 链，L2 前缀 guard）。
+ * 规则（技术方案 §2.6）：
+ *   core/**         禁 import assembly|integrations|views|app-sdk
+ *   assembly/**     禁 import integrations|views|app-sdk（C3 落地即生效）
+ *   integrations/** 禁 import views|app-sdk（C3 落地即生效）
+ *   views/**        禁 import app-sdk（C4 落地即生效）
+ *   全包            禁 import @tbox.cn/app-sdk（值或类型——叶包铁律）
+ *   contracts       仅 core/contracts-expected.ts 与 tests 允许（且限 import type）
+ */
+
+const SRC_ROOT = join(import.meta.dirname ?? new URL('.', import.meta.url).pathname, '..', 'src');
+
+interface Violation {
+  file: string;
+  line: number;
+  text: string;
+  rule: string;
+}
+
+function listSourceFiles(dir: string, out: string[] = []): string[] {
+  for (const entry of readdirSync(dir)) {
+    const abs = join(dir, entry);
+    if (statSync(abs).isDirectory()) listSourceFiles(abs, out);
+    else if (entry.endsWith('.ts')) out.push(abs);
+  }
+  return out;
+}
+
+function layerOf(relPath: string): string {
+  const normalized = relPath.split(sep).join('/');
+  if (normalized.startsWith('core/')) return 'core';
+  if (normalized.startsWith('assembly/')) return 'assembly';
+  if (normalized.startsWith('integrations/')) return 'integrations';
+  if (normalized.startsWith('views/')) return 'views';
+  return 'root';
+}
+
+/** 相对引用向上层时按目标文件实际所在层判定；包名引用按前缀判定 */
+function checkFile(relPath: string, content: string): Violation[] {
+  const violations: Violation[] = [];
+  const layer = layerOf(relPath);
+  const lines = content.split('\n');
+  lines.forEach((line, i) => {
+    const num = i + 1;
+    const importMatch = /(?:^|\s)import\s+(?:type\s+)?[^;]*?from\s+['"]([^'"]+)['"]|import\s*\(\s*['"]([^'"]+)['"]\s*\)|import\s+['"]([^'"]+)['"]/.exec(
+      line,
+    );
+    if (!importMatch) return;
+    const spec = importMatch[1] ?? importMatch[2] ?? importMatch[3] ?? '';
+    const isTypeImport = /import\s+type\s/.test(line);
+
+    if (spec.includes('@tbox.cn/app-sdk')) {
+      violations.push({ file: relPath, line: num, text: line.trim(), rule: '全包禁 import app-sdk（值或类型）——叶包铁律' });
+      return;
+    }
+    if (spec.includes('@tbox.cn/app-contracts')) {
+      const allowed = (layer === 'core' && relPath.replace(sep, '/').startsWith('core/contracts-expected')) || relPath.replace(sep, '/').startsWith('tests/');
+      if (!allowed) {
+        violations.push({ file: relPath, line: num, text: line.trim(), rule: 'contracts 仅 core/contracts-expected.ts 与 tests 允许' });
+      } else if (!isTypeImport) {
+        violations.push({ file: relPath, line: num, text: line.trim(), rule: 'contracts 仅限 import type（运行时全经 resolver）' });
+      }
+      return;
+    }
+    if (spec.startsWith('.')) {
+      // 共享叶白名单：dto.ts（纯类型）/ core/errors.ts（错误类）任意层可引（零领域依赖叶）
+      const targetNorm = relPath.replace(sep, '/').split('/').slice(0, -1).join('/');
+      const resolvedSpec = spec.replace('.js', '.ts');
+      if (resolvedSpec === '../dto.ts' || resolvedSpec === '../core/errors.ts' || resolvedSpec === '../../dto.ts' || resolvedSpec === '../../core/errors.ts') {
+        return;
+      }
+      // 相对引用：解析目标文件所在层
+      const targetAbs = join(SRC_ROOT, targetNorm, spec);
+      const targetRel = relative(SRC_ROOT, targetAbs).split(sep).join('/');
+      const targetLayer = layerOf(targetRel);
+      const order = ['core', 'assembly', 'integrations', 'views', 'root'];
+      // root(index.ts) 聚合导出恒最上层
+      const upward = (l: string): number => (l === 'root' ? order.length : order.indexOf(l));
+      if (upward(targetLayer) > upward(layer)) {
+        violations.push({
+          file: relPath,
+          line: num,
+          text: line.trim(),
+          rule: `${layer}/** 禁 import ${targetLayer}/**（import 只准向下）`,
+        });
+      }
+    }
+  });
+  return violations;
+}
+
+describe('import 前缀 guard（L2——包内自测）', () => {
+  const files = listSourceFiles(SRC_ROOT);
+
+  it('src 源文件非空（守卫自检阈值）', () => {
+    expect(files.length).toBeGreaterThanOrEqual(8);
+  });
+
+  it('分层线性链：core→assembly→integrations→views 只准向下；全包禁 app-sdk；contracts 限 import type', () => {
+    const violations = files.flatMap((abs) => {
+      const rel = relative(SRC_ROOT, abs);
+      return checkFile(rel, readFileSync(abs, 'utf8'));
+    });
+    expect(violations).toEqual([]);
+  });
+});

package/tests/module-schema.test.ts

@@ -0,0 +1,84 @@
+import { describe, expect, it } from 'vitest';
+import {
+  parseModuleDescriptor,
+  moduleDescriptorSchema,
+  SAFE_NAME_PATTERN,
+} from '../src/core/module-schema.js';
+
+/**
+ * module-schema（descriptor zod 单源）迁移改造验证（C2-5 + C1 P6 归位）：
+ * - demand meta additive（serviceNeedContribSchema 增 title?/description?——P6）
+ * - resource type 放宽（z.enum(RESOURCE_TYPE_IDS) → z.string()——词汇校验移谓词）
+ * - 安全钉子 H9b（provider 字符集 pattern）
+ * - 既有无 meta 素材全过（additive 等价）
+ */
+
+const BASE_MANIFEST = {
+  schemaVersion: 1,
+  name: 'module-sample',
+  version: '0.1.0',
+};
+
+describe('module-schema（descriptor zod 单源）', () => {
+  it('P6 demand meta additive：services 元素带 title/description 通过；缺席仍合法', () => {
+    const withMeta = parseModuleDescriptor({
+      ...BASE_MANIFEST,
+      contributes: {
+        services: [
+          { service: 'parking.query', optional: false, title: '车位查询', description: '查询车位状态' },
+        ],
+      },
+    });
+    expect(withMeta.ok).toBe(true);
+    if (withMeta.ok) {
+      expect(withMeta.value.contributes.services[0].title).toBe('车位查询');
+      expect(withMeta.value.contributes.services[0].description).toBe('查询车位状态');
+    }
+    // 既有无 meta 素材全过（additive 等价）
+    const withoutMeta = parseModuleDescriptor({
+      ...BASE_MANIFEST,
+      contributes: { services: [{ service: 'parking.query' }] },
+    });
+    expect(withoutMeta.ok).toBe(true);
+  });
+
+  it('resource type 放宽：任意 string 通过（词汇校验移谓词经 resolver 取词表）', () => {
+    const result = parseModuleDescriptor({
+      ...BASE_MANIFEST,
+      contributes: { resources: [{ id: 'kb-1', type: 'knowledge' }, { id: 'kb-2', type: 'future-type' }] },
+    });
+    expect(result.ok).toBe(true);
+  });
+
+  it('H9b 安全钉子：provider 名含路径敌对字符 → 拒绝；合法字符集通过', () => {
+    const evil = parseModuleDescriptor({
+      ...BASE_MANIFEST,
+      contributes: {
+        providers: { slots: [{ service: 'a.b', provider: '../etc', implementation: 'x@1', credentialType: '-' }] },
+      },
+    });
+    expect(evil.ok).toBe(false);
+    const good = parseModuleDescriptor({
+      ...BASE_MANIFEST,
+      contributes: {
+        providers: { slots: [{ service: 'a.b', provider: 'wanda', implementation: 'wanda-a@1', credentialType: '-' }] },
+      },
+    });
+    expect(good.ok).toBe(true);
+    // pattern 本体断言（stem 派生第一道防线）
+    expect(SAFE_NAME_PATTERN.test('wanda')).toBe(true);
+    expect(SAFE_NAME_PATTERN.test('my-custom-api')).toBe(true);
+    expect(SAFE_NAME_PATTERN.test('../etc')).toBe(false);
+    expect(SAFE_NAME_PATTERN.test('-lead')).toBe(false);
+  });
+
+  it('零贡献合法（provider-custom 空包形态）：contributes 全 default', () => {
+    const parsed = moduleDescriptorSchema.safeParse(BASE_MANIFEST);
+    expect(parsed.success).toBe(true);
+    if (parsed.success) {
+      expect(parsed.data.contributes.providers.slots).toEqual([]);
+      expect(parsed.data.contributes.services).toEqual([]);
+      expect(parsed.data.contributes.resources).toEqual([]);
+    }
+  });
+});

package/tests/naming-alignment.test.ts

@@ -0,0 +1,50 @@
+import { describe, it, expect } from 'vitest';
+
+/**
+ * URL↔方法映射表断言（L1 对齐律——一端点 ↔ 一方法 1:1，改名漂移即红）。
+ * C2 骨架：映射表常量 + 自检阈值；C4 工厂落地时补全 13 行并激活断言
+ * （方法名断言依赖 factory 导出——届时 import { createAppToolkit } 逐行断言 typeof）。
+ */
+
+/** 13 行映射表（api.md §8 单源；C4 补全为逐行断言） */
+export const URL_METHOD_MAP: ReadonlyArray<{ method: string; url: string }> = [
+  // ── 静态（7）──
+  { method: 'loadModules', url: 'GET /modules' },
+  { method: 'loadModule', url: 'GET /modules/:module' },
+  { method: 'loadApp', url: 'GET /app' },
+  { method: 'loadService', url: 'GET /services/:service' },
+  { method: 'loadProviders', url: 'GET /providers' },
+  { method: 'loadProvider', url: 'GET /providers/:provider' },
+  { method: 'loadProviderService', url: 'GET /providers/:provider/services/:service' },
+  // ── 求值（2）──
+  { method: 'loadServiceResolutions', url: 'GET /service-resolutions' },
+  { method: 'loadServiceResolution', url: 'GET /service-resolutions/:service' },
+  // ── 写（4）──
+  { method: 'writeAppIntegration', url: 'PUT /app/integration' },
+  { method: 'writeModuleIntegration', url: 'PUT /modules/:module/integration' },
+  { method: 'writeServiceIntegration', url: 'PUT /services/:service/integration' },
+  { method: 'deleteServiceIntegration', url: 'DELETE /services/:service/integration' },
+];
+
+describe('naming-alignment（L1 映射表——C2 骨架）', () => {
+  it('映射表骨架 = 13 行（静态 7 + 求值 2 + 写 4）——计数守卫', () => {
+    expect(URL_METHOD_MAP).toHaveLength(13);
+    expect(URL_METHOD_MAP.filter((r) => r.url.startsWith('GET '))).toHaveLength(9);
+    expect(URL_METHOD_MAP.filter((r) => r.url.startsWith('PUT '))).toHaveLength(3);
+    expect(URL_METHOD_MAP.filter((r) => r.url.startsWith('DELETE '))).toHaveLength(1);
+  });
+
+  it('命名镜像律（L3）：Read = load<View>；Write = write|delete<Layer>Integration', () => {
+    for (const row of URL_METHOD_MAP) {
+      if (row.url.startsWith('GET ')) {
+        expect(row.method.startsWith('load')).toBe(true);
+      } else if (row.url.startsWith('DELETE ')) {
+        expect(row.method.startsWith('delete')).toBe(true);
+        expect(row.method.endsWith('Integration')).toBe(true);
+      } else {
+        expect(row.method.startsWith('write')).toBe(true);
+        expect(row.method.endsWith('Integration')).toBe(true);
+      }
+    }
+  });
+});