dsh-m 0.9.84 → 0.9.87

package/lib/core/packument.js

@@ -0,0 +1,362 @@
+/**
+ * packument 访问器（ADR-0019）：npm 全量 packument 取数的唯一属主模块（GLOSSARY 在案）。
+ * 一次取回按需派生视图（times/versions/distTags/readme/repo），按（pkg, 生效 registry）
+ * 记忆化共享给登记、预检与 B3 预热；latest 小端点探测与其缓存制度（ADR-0006）不在辖区。
+ *
+ * 取数双面：fetchDocThrowing（strict——两腿阶梯，npmjs 首腿 `min(timeoutMs,5s)` 收紧 →
+ * 生效源备腿，终末失败抛原始错误，供 readme 阶梯错误透传）；fetchPackumentDoc（lenient——
+ * 同阶梯 catch → null，times 的 fail-open 口径）。发布时戳是不可变历史事实，TTL 5min 只防
+ * 内存滞留过期内容，不作废旧时戳判定；失败与 regex-invalid 的确定性 null 同按 TTL 负缓存
+ * （故障窗口内预检/登记不二次打网）。
+ *
+ * 腿策略（ADR-0012 消费端）：times 走两腿（完整性敏感读，npmjs 权威优先）；warm 与 readme
+ * 兜底腿走「生效源单腿」（warm 暖的正是 B3 重试要打的 CDN，两腿会让镜像机先付 npmjs 5s
+ * 且暖错对象——评审 G1-3/G2-2 裁决）。onRouteSwitch 作废 + 缓存键含生效源双保险；本模块是
+ * 唯一注册点（release-age 旧注册已随其本地缓存退役）。
+ */
+import { fetchJsonLimited } from './httpx.js';
+import { DEFAULT_NPM_REGISTRY, NPM_MIRROR, activeNpmRegistry, onRouteSwitch, syncNpmmirrorPackage } from './npm-route.js';
+/** npm 包名形状（与既有四函数同一字符集，scoped 允许）。 */
+const PKG_RE = /^@?[A-Za-z0-9-._~]+(\/[A-Za-z0-9-._~]+)?$/;
+/** registry base 归一（去尾斜杠；空/缺省 → 官方 npmjs）。 */
+function registryBase(registry) {
+    const base = typeof registry === 'string' && registry.trim() !== '' ? registry.trim() : DEFAULT_NPM_REGISTRY;
+    return base.replace(/\/+$/, '');
+}
+/** 精确 semver：接受 prerelease/build metadata，拒绝 v 前缀、range、tag 与脏尾缀。 */
+const EXACT_VERSION_RE = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
+export function isExactVersion(version) {
+    return EXACT_VERSION_RE.test(version);
+}
+// ---------- 取数层（strict / lenient 双面） ----------
+/**
+ * strict 面：两腿阶梯取全量 packument，终末失败抛原始错误。
+ * L3 权威链（ADR-0012）：npmjs 首腿超时收紧 `Math.min(timeoutMs, 5_000)`；生效源即 npmjs
+ * 时失败直接抛（权威源无备腿可降）；两腿皆败抛终末腿错误（readme 阶梯的错误透传依赖此约定）。
+ */
+export async function fetchDocThrowing(pkg, timeoutMs = 20_000, signal, deps) {
+    if (!PKG_RE.test(pkg))
+        throw new Error(`无效 npm 包名: ${pkg}`);
+    const fetcher = deps?.fetchJsonLimited ?? fetchJsonLimited;
+    const firstLegMs = Math.min(timeoutMs, 5_000);
+    try {
+        return (await fetcher(`${registryBase(DEFAULT_NPM_REGISTRY)}/${encodeURIComponent(pkg)}`, {
+            timeoutMs: firstLegMs,
+            signal,
+            maxBytes: 8 * 1024 * 1024,
+        }));
+    }
+    catch (firstErr) {
+        const alt = await activeNpmRegistry();
+        if (alt === DEFAULT_NPM_REGISTRY)
+            throw firstErr;
+        return (await fetcher(`${registryBase(alt)}/${encodeURIComponent(pkg)}`, {
+            timeoutMs,
+            signal,
+            maxBytes: 8 * 1024 * 1024,
+        }));
+    }
+}
+/** lenient 面：同阶梯 catch → null（times 的 fail-open 口径；regex-invalid 亦 null）。 */
+export async function fetchPackumentDoc(pkg, timeoutMs = 20_000, signal, deps) {
+    try {
+        return await fetchDocThrowing(pkg, timeoutMs, signal, deps);
+    }
+    catch {
+        return null;
+    }
+}
+/** 生效源单腿 strict 取数（warm 与 readme 兜底腿的取数原语；失败抛原始错误）。返回 doc 与取数所用 base——调用方回填键必须用同一 base（评审 R1-1：一次生效源判定贯穿取数与回填，杜绝路由切换窗口的键错配）。 */
+async function fetchDocViaActiveThrowing(pkg, timeoutMs, signal, deps) {
+    if (!PKG_RE.test(pkg))
+        throw new Error(`无效 npm 包名: ${pkg}`);
+    const fetcher = deps?.fetchJsonLimited ?? fetchJsonLimited;
+    const base = await activeNpmRegistry();
+    const doc = (await fetcher(`${registryBase(base)}/${encodeURIComponent(pkg)}`, {
+        timeoutMs,
+        signal,
+        maxBytes: 8 * 1024 * 1024,
+    }));
+    return { doc, base };
+}
+// ---------- 视图层 ----------
+/** packument repository → "owner/repo"（仅 github.com；git+https / git@ / .git / #frag 归一；非 GitHub 返回空串）。 */
+export function extractGithubRepo(v) {
+    const url = v && typeof v === 'object' && !Array.isArray(v) && typeof v.url === 'string'
+        ? v.url
+        : typeof v === 'string'
+            ? v
+            : '';
+    if (!url)
+        return '';
+    const m = /github\.com[/:]([A-Za-z0-9._-]+)\/([A-Za-z0-9._-]+?)(?:\.git)?(?:[/?#]|$)/i.exec(url);
+    return m ? `${m[1]}/${m[2]}` : '';
+}
+/** 全量 packument → 派生视图包（纯函数；畸形字段一律回落默认值，不抛）。 */
+export function packumentViews(doc) {
+    const d = doc && typeof doc === 'object' && !Array.isArray(doc) ? doc : {};
+    const times = {};
+    const t = d.time;
+    if (t && typeof t === 'object' && !Array.isArray(t)) {
+        for (const [k, v] of Object.entries(t)) {
+            if (typeof v === 'string' && v !== '')
+                times[k] = v;
+        }
+    }
+    const versions = d.versions && typeof d.versions === 'object' && !Array.isArray(d.versions) ? Object.keys(d.versions) : [];
+    const distTags = d['dist-tags'] && typeof d['dist-tags'] === 'object' && !Array.isArray(d['dist-tags'])
+        ? d['dist-tags']
+        : {};
+    const readme = typeof d.readme === 'string' && d.readme.trim() !== '' ? d.readme : '';
+    return { times, versions, distTags, readme, repo: extractGithubRepo(d.repository) };
+}
+const packumentCache = new Map();
+const packumentInflight = new Map();
+const PACKUMENT_TTL_MS = 5 * 60_000;
+const PACKUMENT_CAP = 4;
+function packumentKey(pkg, registry) {
+    return `${pkg}\n${registry}`;
+}
+function backfill(key, views) {
+    if (packumentCache.has(key))
+        packumentCache.delete(key); // 重写移尾：淘汰语义 = 最旧写入
+    packumentCache.set(key, { at: Date.now(), views });
+    if (packumentCache.size > PACKUMENT_CAP) {
+        const oldest = packumentCache.keys().next().value;
+        if (oldest !== undefined)
+            packumentCache.delete(oldest);
+    }
+}
+/** 路由作废（ADR-0012 L1：生效源切换 → 缓存整体作废）；亦是测试隔离钩子。 */
+export function clearPackumentAccessorCache() {
+    packumentCache.clear();
+    packumentInflight.clear();
+}
+onRouteSwitch(() => clearPackumentAccessorCache());
+/** lenient 带缓存取数（times/全视图共用；single-flight；失败/非法 → null 负缓存）。 */
+async function entryLenient(pkg, timeoutMs, signal, deps) {
+    const key = packumentKey(pkg, await activeNpmRegistry());
+    const hit = packumentCache.get(key);
+    if (hit && Date.now() - hit.at < PACKUMENT_TTL_MS)
+        return hit.views;
+    const existing = packumentInflight.get(key);
+    if (existing)
+        return existing;
+    const p = (async () => {
+        let views = null;
+        try {
+            views = packumentViews(await fetchDocThrowing(pkg, timeoutMs, signal, deps));
+        }
+        catch {
+            views = null;
+        }
+        backfill(key, views);
+        return views;
+    })().finally(() => {
+        packumentInflight.delete(key);
+    });
+    packumentInflight.set(key, p);
+    return p;
+}
+/** 带缓存发布时戳表（预检/登记消费；语义 = 旧 cachedPackumentTimes：失败 null 不抛）。 */
+export async function packumentTimes(pkg, timeoutMs = 12_000, signal, deps) {
+    const views = await entryLenient(pkg, timeoutMs, signal, deps);
+    return views ? views.times : null;
+}
+/** 带缓存全视图（npmPackument 隐式 registry 路径消费）。 */
+export async function packumentDocViews(pkg, timeoutMs = 20_000, signal, deps) {
+    return entryLenient(pkg, timeoutMs, signal, deps);
+}
+/**
+ * 生效源单腿带缓存全视图（readme 隐式 registry 兜底腿专用，G2-2 方案 a）：命中（且非
+ * 负缓存）直回；miss/负缓存 → 单腿 strict 重取（失败抛原始错误）+ 回填。负缓存条目仅
+ * lenient 面消费——strict 面视 null 为 miss，保终末错误透传（≈现状无缓存每次尝试）。
+ */
+export async function packumentDocViewsActive(pkg, timeoutMs = 20_000, signal, deps) {
+    const key = packumentKey(pkg, await activeNpmRegistry());
+    const hit = packumentCache.get(key);
+    if (hit && Date.now() - hit.at < PACKUMENT_TTL_MS && hit.views !== null)
+        return hit.views;
+    const { doc, base } = await fetchDocViaActiveThrowing(pkg, timeoutMs, signal, deps);
+    const views = packumentViews(doc);
+    backfill(packumentKey(pkg, base), views);
+    return views;
+}
+/**
+ * B3 预热（G1-3 裁决）：bypass 缓存读 + 生效源单腿直取 + 成功回填——预热的目的就是真发
+ * 请求暖 CDN（B3 重试要打的正是生效源），缓存命中≠预热；失败/abort 异常向上传播（调用方
+ * makeNpmWarmPackument 按 R4c 消化：abort rethrow、其余吞错）。
+ */
+export async function warmPackumentFor(pkg, timeoutMs = 20_000, signal, deps) {
+    const { doc, base } = await fetchDocViaActiveThrowing(pkg, timeoutMs, signal, deps);
+    backfill(packumentKey(pkg, base), packumentViews(doc));
+}
+function sleepAbortable(ms, signal) {
+    return new Promise((resolve) => {
+        const done = () => {
+            clearTimeout(t);
+            signal?.removeEventListener('abort', done);
+            resolve();
+        };
+        const t = setTimeout(done, ms);
+        signal?.addEventListener('abort', done, { once: true });
+    });
+}
+/**
+ * 精确版本元数据（兼容预检/integrity 锚定）。L2① 履约阶梯（ADR-0012）：
+ * 显式 registry 参数 > 生效源 → 失败且生效源为镜像 → sync → 有界等待 10s → 同源重试一次
+ * → 仍败 → npmjs 兜底（sync+重试为尽力而为，npmjs 兜底是主安全网）；
+ * 主源即 npmjs 时失败直接抛（权威源无镜像滞后可言）。
+ */
+export async function npmVersion(pkg, version, timeoutMs = 20_000, signal, registry, deps) {
+    if (!PKG_RE.test(pkg))
+        throw new Error(`无效 npm 包名: ${pkg}`);
+    if (!isExactVersion(version))
+        throw new Error(`不是精确版本（拒绝 range/tag/前缀）: ${version}`);
+    const fetcher = deps?.fetchJsonLimited ?? fetchJsonLimited;
+    const sync = deps?.syncNpmmirror ?? syncNpmmirrorPackage;
+    const wait = deps?.wait ?? sleepAbortable;
+    const leg = async (base) => {
+        const data = await fetcher(`${registryBase(base)}/${encodeURIComponent(pkg)}/${version}`, { timeoutMs, signal });
+        const resolved = typeof data.version === 'string' ? data.version : '';
+        if (!resolved)
+            throw new Error(`npm 未返回版本: ${pkg}@${version}`);
+        const peers = {};
+        if (data.peerDependencies !== null && typeof data.peerDependencies === 'object') {
+            for (const [name, range] of Object.entries(data.peerDependencies)) {
+                if (typeof range === 'string')
+                    peers[name] = range;
+            }
+        }
+        return {
+            version: resolved,
+            integrity: typeof data.dist?.integrity === 'string' ? data.dist.integrity : undefined,
+            tarball: typeof data.dist?.tarball === 'string' ? data.dist.tarball : undefined,
+            peers,
+        };
+    };
+    const primary = registry?.trim() ? registry.trim() : await activeNpmRegistry();
+    try {
+        return await leg(primary);
+    }
+    catch (firstErr) {
+        // L2①（ADR-0012）：仅 sync 真正受理才重试镜像（kill switch / 同步失败不付 10s 等待）。
+        if (primary === NPM_MIRROR && (await sync(pkg))) {
+            await wait(10_000, signal);
+            try {
+                return await leg(primary);
+            }
+            catch {
+                // 同源重试仍败 → npmjs 兜底
+            }
+        }
+        if (primary !== DEFAULT_NPM_REGISTRY)
+            return leg(DEFAULT_NPM_REGISTRY);
+        throw firstErr;
+    }
+}
+/**
+ * 升级探测（检测读）。L3 权威链（ADR-0012）：新鲜度敏感——npmjs 权威源优先
+ * （首腿超时收紧 `Math.min(timeoutMs, 5_000)`），失败降级生效源（≠npmjs 时）；
+ * 不设 sync 腿。显式 registry 参数优先。
+ */
+export async function npmLatest(pkg, timeoutMs = 20_000, signal, registry, deps) {
+    if (!PKG_RE.test(pkg))
+        throw new Error(`无效 npm 包名: ${pkg}`);
+    const fetcher = deps?.fetchJsonLimited ?? fetchJsonLimited;
+    const leg = async (base, ms) => {
+        const data = await fetcher(`${registryBase(base)}/${encodeURIComponent(pkg)}/latest`, { timeoutMs: ms, signal });
+        const version = typeof data.version === 'string' ? data.version : '';
+        if (!version)
+            throw new Error(`npm 未返回版本: ${pkg}`);
+        return {
+            version,
+            integrity: typeof data.dist?.integrity === 'string' ? data.dist.integrity : undefined,
+            tarball: typeof data.dist?.tarball === 'string' ? data.dist.tarball : undefined,
+        };
+    };
+    const explicit = registry?.trim();
+    if (explicit)
+        return leg(explicit, timeoutMs);
+    const firstLegMs = Math.min(timeoutMs, 5_000);
+    try {
+        return await leg(DEFAULT_NPM_REGISTRY, firstLegMs);
+    }
+    catch (firstErr) {
+        const alt = await activeNpmRegistry();
+        if (alt === DEFAULT_NPM_REGISTRY)
+            throw firstErr;
+        return leg(alt, timeoutMs);
+    }
+}
+/**
+ * 拉取完整 packument（NO_MATCHING_VERSION 退避重试前的预热/校验原语）。
+ * 返回该包已知的全部版本号；解析不出 versions 时返回空列表（不抛）。
+ * 隐式 registry → 访问器缓存（lenient 两腿面；该路径在 B3 改用 warmPackumentFor 后已无
+ * 生产消费方，仅测试触达——G3-2 备案）；显式 registry 直取不走缓存。
+ */
+export async function npmPackument(pkg, timeoutMs = 20_000, signal, registry, deps) {
+    if (!PKG_RE.test(pkg))
+        throw new Error(`无效 npm 包名: ${pkg}`);
+    const explicit = registry?.trim();
+    if (!explicit) {
+        const views = await packumentDocViews(pkg, timeoutMs, signal, deps?.fetchJsonLimited ? { fetchJsonLimited: deps.fetchJsonLimited } : undefined);
+        if (!views)
+            throw new Error(`packument 不可用: ${pkg}`);
+        return { versions: views.versions };
+    }
+    const fetcher = deps?.fetchJsonLimited ?? fetchJsonLimited;
+    const data = await fetcher(`${registryBase(explicit)}/${encodeURIComponent(pkg)}`, {
+        timeoutMs,
+        signal,
+        maxBytes: 8 * 1024 * 1024,
+    });
+    const versions = data?.versions !== null && typeof data?.versions === 'object' ? Object.keys(data.versions) : [];
+    return { versions };
+}
+/**
+ * npm packument readme 兜底（0.9.45 U10b / 0.9.50 两腿阶梯）：腿1 `/latest` 小端点优先
+ * （KB 级载荷，超时收紧 `min(timeoutMs,5s)`），readme 命中即短路；空或腿失败落腿2
+ * packument。任一腿成功即成功——readme 空渲染「没有 README」（含 latest 空白 readme +
+ * packument 失败的降级，不抛）；两腿全败抛终末腿（packument）错误。两腿均在生效源。
+ * 0.9.86：腿2 隐式 registry 改走访问器「生效源单腿带缓存」面（G2-2 方案 a——腿策略与
+ * 现状单腿一致，不换两腿；共享缓存）；显式 registry 直取不走缓存。
+ */
+export async function npmPackumentReadme(pkg, timeoutMs = 20_000, signal, registry, deps) {
+    if (!PKG_RE.test(pkg))
+        throw new Error(`无效 npm 包名: ${pkg}`);
+    const fetcher = deps?.fetchJsonLimited ?? fetchJsonLimited;
+    const explicit = registry?.trim();
+    const base = explicit ? registryBase(explicit) : registryBase(await activeNpmRegistry());
+    const extractReadme = (data) => typeof data?.readme === 'string' && data.readme.trim() !== '' ? data.readme : '';
+    // 腿1：/latest 版本文档（小载荷；超时收紧同 npmLatest 首腿先例）
+    let latestOk = false;
+    let latestRepo = '';
+    try {
+        const latestDoc = await fetcher(`${base}/${encodeURIComponent(pkg)}/latest`, { timeoutMs: Math.min(timeoutMs, 5_000), signal, maxBytes: 8 * 1024 * 1024 });
+        latestOk = true;
+        latestRepo = extractGithubRepo(latestDoc?.repository);
+        const latestReadme = extractReadme(latestDoc);
+        if (latestReadme)
+            return { readme: latestReadme, repo: latestRepo };
+    }
+    catch {
+        // latest 腿失败 → 落 packument 腿（终末腿语义见下）
+    }
+    // 腿2：packument（终末腿）——隐式 registry 走访问器 Active 面（单腿带缓存 + 错误透传）
+    try {
+        if (explicit) {
+            const data = await fetcher(`${base}/${encodeURIComponent(pkg)}`, { timeoutMs, signal, maxBytes: 8 * 1024 * 1024 });
+            return { readme: extractReadme(data), repo: extractGithubRepo(data?.repository) };
+        }
+        const views = await packumentDocViewsActive(pkg, timeoutMs, signal, deps?.fetchJsonLimited ? { fetchJsonLimited: deps.fetchJsonLimited } : undefined);
+        return { readme: views.readme, repo: views.repo };
+    }
+    catch (packumentErr) {
+        if (latestOk) {
+            // latest 到达但 readme 空 + packument 失败 → 降级空 readme（0.9.50 语义，不抛）
+            return { readme: '', repo: latestRepo };
+        }
+        throw packumentErr;
+    }
+}

package/lib/core/profile-transaction.js

@@ -37,7 +37,7 @@ import { join } from 'node:path';
 import { webProfileDir } from './env.js';
 import { isSafePkgName, resolvePluginDir } from './installed.js';
 import { setLivePluginDisabled } from './live-plugin.js';
-import { npmPackument } from './versions.js';
+import { warmPackumentFor } from './packument.js';
 import { syncNpmmirrorPackage } from './npm-route.js';
 import { clearAllLatestCache } from './latest-cache.js';
 import { assertNpmIntegrity, atomicWriteFile, readPnpmLockIntegrity, readPnpmLockOverrides, restoreSnapshots, snapshotFiles, verifySnapshots, } from './npm-integrity.js';
@@ -65,7 +65,11 @@ export const TX_FAILURE_CODES = [
  * fetcher 参数仅测试注入；失败吞错。deps 未提供且调用方未绑定时，
  * 事务内 B3 跳过预热仅重试——绝不调用 undefined。
  */
-export function makeNpmWarmPackument(timeoutMs, fetcher = npmPackument) {
+export function makeNpmWarmPackument(timeoutMs, 
+// 0.9.86（ADR-0019）：缺省 fetcher 改 warmPackumentFor——bypass 缓存 + 生效源单腿真发请求
+// （预热的目的就是暖 CDN）+ 成功回填访问器缓存；abort 由本包装按 R4c 消化（rethrow）、
+// 其余失败吞错（预热尽力而为）不变。
+fetcher = warmPackumentFor) {
     return async (pkg, signal) => {
         try {
             await fetcher(pkg, timeoutMs, signal);

package/lib/core/release-age.js

@@ -26,8 +26,7 @@
 import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { isMap, isScalar, isSeq, parseDocument } from 'yaml';
-import { fetchJsonLimited } from './httpx.js';
-import { DEFAULT_NPM_REGISTRY, activeNpmRegistry, onRouteSwitch } from './npm-route.js';
+import { clearPackumentAccessorCache, fetchPackumentDoc, packumentTimes, packumentViews } from './packument.js';
 /** pnpm 11.7 实机测得的策略窗口：24h（operation-l5fXEd 的 cutoff = 检查时刻 − 1440min）。 */
 export const DEFAULT_MINIMUM_RELEASE_AGE_MIN = 1440;
 function scalarNumber(value) {
@@ -148,46 +147,13 @@ export function describeReleaseAgeFailure(input) {
     lines.push(`预计 ${fmtLocal(maxDeadline)} 后可重试；等待期内也可由操作员把 pnpm-workspace.yaml 中对应的独立精确排除条目改为包名级或复合条目以解除拦截`);
     return { message: lines.join('\n'), violations, targetViolating: targetViol !== undefined };
 }
-async function fetchPackumentTimes(base, pkg, timeoutMs, signal, fetcher) {
-    const data = await fetcher(`${base}/${encodeURIComponent(pkg)}`, {
-        timeoutMs,
-        signal,
-        maxBytes: 8 * 1024 * 1024,
-    });
-    if (!data || typeof data !== 'object' || data.time === null || typeof data.time !== 'object')
-        return null;
-    const out = {};
-    for (const [k, v] of Object.entries(data.time)) {
-        if (typeof v === 'string')
-            out[k] = v;
-    }
-    return out;
-}
 /**
- * registry packument 的 time 映射（与 npmPackument 同源；失败返回 null，不抛）。
- * L3 权威链（ADR-0012）：发布时刻是完整性敏感读——npmjs 权威源优先（首腿超时收紧
- * `Math.min(timeoutMs, 5_000)`），失败降级生效源；两腿皆败 → null（fail-open 口径不变）。
+ * registry packument 的 time 映射（0.9.86 起薄委托 packument 访问器，ADR-0019：两腿阶梯
+ * 单份活代码于 fetchDocThrowing）。失败返回 null，不抛；L3 权威链（ADR-0012）语义不变。
  */
 export async function npmPackumentTimes(pkg, timeoutMs = 20_000, signal, deps) {
-    if (!/^@?[A-Za-z0-9-._~]+(\/[A-Za-z0-9-._~]+)?$/.test(pkg))
-        return null;
-    const fetcher = deps?.fetchJsonLimited ?? fetchJsonLimited;
-    const firstLegMs = Math.min(timeoutMs, 5_000);
-    try {
-        return await fetchPackumentTimes(DEFAULT_NPM_REGISTRY, pkg, firstLegMs, signal, fetcher);
-    }
-    catch {
-        // 权威源不可达 → 生效源降级
-    }
-    const alt = await activeNpmRegistry();
-    if (alt === DEFAULT_NPM_REGISTRY)
-        return null;
-    try {
-        return await fetchPackumentTimes(alt, pkg, timeoutMs, signal, fetcher);
-    }
-    catch {
-        return null;
-    }
+    const doc = await fetchPackumentDoc(pkg, timeoutMs, signal, deps);
+    return doc ? packumentViews(doc).times : null;
 }
 /** 读 profile 的 pnpm-workspace.yaml 策略；缺席/不可读 → null（调用方 fail-open）。 */
 export async function readWorkspacePolicy(profileDir) {
@@ -200,28 +166,20 @@ export async function readWorkspacePolicy(profileDir) {
         return null;
     }
 }
-const packumentCache = new Map();
-const PACKUMENT_CACHE_TTL_MS = 5 * 60_000;
-/** L1（ADR-0012）：npm 生效源切换 → 作废 packument 缓存（镜像的答案不是官方源的答案）。 */
-export function clearPackumentCache() {
-    packumentCache.clear();
-}
-onRouteSwitch(() => clearPackumentCache());
 /**
- * 带进程内缓存的 packument time 探测（TTL 5min）：预检与登记（exclude-governance）
- * 共用——同一操作里预检刚拉过的 packument 不二次拉取（8MiB 级全量）。
+ * 0.9.86 薄委托（ADR-0019）：本地 Map/TTL/路由注册整体退役——缓存与作废语义由 packument
+ * 访问器属主承担（single-flight/TTL 5min/负缓存/cap=4/onRouteSwitch 唯一注册均在彼处）。
  */
+export function clearPackumentCache() {
+    clearPackumentAccessorCache();
+}
+/** 带缓存 packument time 探测（预检与登记共用）：薄委托访问器 times 视图，签名与语义不变。 */
 export async function cachedPackumentTimes(pkg, timeoutMs = 12_000, signal, deps) {
-    const hit = packumentCache.get(pkg);
-    if (hit && Date.now() - hit.at < PACKUMENT_CACHE_TTL_MS)
-        return hit.times;
-    const times = await npmPackumentTimes(pkg, timeoutMs, signal, deps);
-    packumentCache.set(pkg, { at: Date.now(), times });
-    return times;
+    return packumentTimes(pkg, timeoutMs, signal, deps);
 }
-/** 测试钩子：清空 packument 进程内缓存。 */
+/** 测试钩子：清空 packument 进程内缓存（现属访问器）。 */
 export function _resetReleaseAgeCachesForTests() {
-    packumentCache.clear();
+    clearPackumentAccessorCache();
 }
 /**
  * 委派前预检（ADR-0009 收敛语义）：仅当策略显式设置 age 或开启 strict 时，对窗口内