@tacet-ink/journal-core 0.3.3 → 0.3.5

package/dist/client/vault.js

@@ -1,5 +1,5 @@
 /**
- * vault.ts — 高階 Vault API：createVault／unlockVault／recoverVault → VaultHandle。
+ * vault.ts — 高階 Vault API：createVault／unlockVault／recoverVault → VaultHandle＋零設定前綴推導 resolver。
  *
  * 定位：低階原語（note-crypto.ts／argon2.ts）的**呼叫端**——additive-only，零改動原語語意。
  * 一個 vault＝一把隨機 256-bit noteKey（generateNoteKey）＋伺服器存的包裹欄（wrapped＋salt）
@@ -20,15 +20,86 @@
  *   tag：0x73 's'＝字串（body＝UTF-8）／0x6a 'j'＝JSON（body＝UTF-8(JSON.stringify)）／0x62 'b'＝位元組（body＝原樣）。
  */
 import { generateNoteKey, generateRecToken, recTokenHash, wrapNoteKeyWithRecToken, unwrapNoteKeyWithRecToken, unwrapNoteKey, unwrapNoteKeyDual, normalizePin, b64, unb64, IV_LEN, } from './note-crypto.js';
-import { wrapNoteKey4, unwrapNoteKey4, wrapNoteKeyDual4, unwrapNoteKeyDual4, unwrapNoteKey3, unwrapNoteKeyDual3, } from './argon2.js';
+import { wrapNoteKey4, unwrapNoteKey4, wrapNoteKeyDual4, unwrapNoteKeyDual4, unwrapNoteKey3, unwrapNoteKeyDual3, derivePh1ArgonV3, } from './argon2.js';
+import { recTokenToWords, wordsToRecToken, normalizeWordInput } from './bip39.js';
 import { VaultError, isVaultError } from './vault-error.js';
 import { ensureArgonCarrier, argonCarrierFailures } from './argon-auto.js';
 export { VaultError, isVaultError };
 export { ensureArgonCarrier, currentArgonCarrier, resetArgonCarrier, DEFAULT_ARGON_CHAIN, } from './argon-auto.js';
 export { argonWorkerSource, createBlobArgonWorker } from './argon-worker.js';
+/**
+ * resolveVaultConfig(input)：零設定前綴推導（resolver）。
+ * 輸入 `{ app, ...任意顯式欄位 }`，輸出完整 VaultConfig＋defaulted 旗標：
+ * `defaulted`＝真時 cipher/argon/legacy/recovery 四組**整組**由 app 決定性推導（10 欄，recovery opt-in 時含）——
+ * 命名自定（語意＝resolveVaultConfig：`{app}`＋零設定前綴推導）：前綴零手填、家族尾碼恆固定（契約三要素 app＋尾碼＋佈局；
+ * 帶內版本化：尾碼代即版本代，升級＝新尾碼；家族佈局不隨字面——README 前綴契約節同源）。
+ * `defaulted`＝假時輸入即顯式全配置（回歸 diff 恆 0——validateConfig 逐對檢查照守）。
+ *
+ * 推導表（app 契約 `^[A-Za-z0-9_-]+$`——前綴字面＝線上 ASCII 契約；**契約閘＝零設定（推導）路徑專載**：
+ * 零設定路徑上 app 在場但含契約外字元＝ERR_VAULT_CONFIG fail-closed 不猜；顯式全配置路徑
+ * app 字面照 0.3.3 既有契約零驗形（非 ASCII／帶點 app 走顯式全配置照舊）——契約閘不跨路徑加寬）：
+ *   cipher='foo1v.'／wrap4='foo4w.'／wrapDual4='foo4d.'／pinSalt3Prefix='foo3s:'（鹽域 ':' 同 tacet 形）
+ *   wrap3='foo3w.'／wrapDual3='foo3d.'／legacy wrap='foo1w.'／wrapDual='foo2w.'／pinSaltPrefix='foo1s.'
+ *   recovery（`recovery: true` 時）wrapRec='foo1r.'／recKekHkdf='fookek1'（KEK info 域帶 k 代——刻意
+ *   異於 wrapRec 字面：HKDF info 域與前綴域恆非前綴關係，鹽外置 payload 邊界不重疊）；
+ *   wrap3／wrapDual3 舊世代讀面同由 app 推導（`app + '3w.'`／`app + '3d.'`——app 族半顯式 legacy 槽的推導殘部）。
+ *   `foo`＝示例形；任兩推導值互不為前綴（startsWith 唯一性前提）；尾碼代＝家族表 README 行。
+ *
+ * 顯式路徑判別：`argon` 或 `cipher` 任一在場＝顯式全配置路徑（resolver 不再推導任何欄位——
+ * 顯式欄位優先、缺欄照 validateConfig 拒＝opt-in 母型；app 契約閘不跨路徑加寬——**契約閘＝
+ * 零設定路徑專載**（顯式全配置路徑 app 字面照 0.3.3 契約零驗；`resolveVaultConfig(opts)`
+ * 三入口單點接線共用）。
+ * recovery 物件形同判（呼叫端自管面）。半顯式態（argon 組推導＋legacy 物件槽顯式欄位共存）：
+ * 推導值與顯式值同進前綴互斥檢查（validateConfig——例 `legacy: { wrap: 'foo4w.bait' }` 與推導
+ * wrap4 'foo4w.' 互為前綴＝CONFIG 拒；歧義配置不猜。
+ */
+export function resolveVaultConfig(input) {
+    if (!input || typeof input !== 'object')
+        throw new VaultError('ERR_VAULT_CONFIG', 'input missing');
+    const appIn = input.app;
+    const opts = input;
+    const explicit = opts.argon !== undefined || opts.cipher !== undefined
+        || (opts.recovery !== undefined && typeof opts.recovery === 'object');
+    if (explicit)
+        return { config: input, defaulted: false };
+    // app 契約閘＝零設定（推導）路徑專載——契約閘不跨路徑加寬（顯式全配置路徑 app 字面照 0.3.3
+    // 既有契約零驗；非契約 app 誤入零設定＝推導值帶契約外字元入前綴域＝fail-closed 不猜）。
+    if (typeof appIn !== 'string' || !APP_RE.test(appIn)) {
+        throw new VaultError('ERR_VAULT_CONFIG', 'app contract (^[A-Za-z0-9_-]+$)');
+    }
+    const app = appIn;
+    let legacy;
+    if (opts.legacy === true) {
+        legacy = { wrap: app + '1w.', wrapDual: app + '2w.', pinSaltPrefix: app + '1s.' };
+    }
+    else if (opts.legacy === undefined || opts.legacy === false) {
+        legacy = { wrap: false };
+    }
+    else {
+        const l = opts.legacy;
+        legacy = {
+            wrap: l.wrap === undefined ? app + '1w.' : l.wrap,
+            wrapDual: l.wrapDual ?? app + '2w.',
+            pinSaltPrefix: l.pinSaltPrefix ?? app + '1s.',
+        };
+    }
+    const recovery = opts.recovery === true ? { wrapRec: app + '1r.', recKekHkdf: app + 'kek1' } : undefined;
+    return {
+        config: {
+            app,
+            cipher: app + '1v.',
+            argon: { wrap4: app + '4w.', wrapDual4: app + '4d.', pinSalt3Prefix: app + '3s:', wrap3: app + '3w.', wrapDual3: app + '3d.' },
+            legacy,
+            recovery,
+        },
+        defaulted: true,
+    };
+}
 // ── 配置驗證 ────────────────────────────────────────────────────────────────
 const HEX32_RE = /^[0-9a-f]{32}$/;
 const HEX64_RE = /^[0-9a-f]{64}$/;
+/** app 契約（前綴字面＝線上 ASCII 契約）：字母／數字／底線／減號。 */
+const APP_RE = /^[A-Za-z0-9_-]+$/;
 const nonEmpty = (v) => typeof v === 'string' && v.length > 0;
 /** 讀面次序（新→舊）：jr4 家族優先，舊世代依序。 */
 const FAMILIES = [
@@ -36,8 +107,8 @@ const FAMILIES = [
     { family: 'wrapDual4', dual: true, current: true, argon: true, prefix: (c) => (c.argon.pinSalt3Prefix ? c.argon.wrapDual4 : undefined) },
     { family: 'wrap3', dual: false, current: false, argon: true, prefix: (c) => c.argon.wrap3 },
     { family: 'wrapDual3', dual: true, current: false, argon: true, prefix: (c) => (c.argon.pinSalt3Prefix ? c.argon.wrapDual3 : undefined) },
-    { family: 'wrap', dual: false, current: false, argon: false, prefix: (c) => c.legacy?.wrap },
-    { family: 'wrapDual', dual: true, current: false, argon: false, prefix: (c) => (c.legacy?.pinSaltPrefix ? c.legacy?.wrapDual : undefined) },
+    { family: 'wrap', dual: false, current: false, argon: false, prefix: (c) => (c.legacy?.wrap === false ? undefined : c.legacy?.wrap) },
+    { family: 'wrapDual', dual: true, current: false, argon: false, prefix: (c) => (c.legacy?.wrap === false ? undefined : (c.legacy?.pinSaltPrefix ? c.legacy?.wrapDual : undefined)) },
 ];
 function specOf(family) {
     return FAMILIES.find((f) => f.family === family);
@@ -51,6 +122,17 @@ function validateConfig(c) {
         throw new VaultError('ERR_VAULT_CONFIG', 'cipher');
     if (!c.argon || !nonEmpty(c.argon.wrap4))
         throw new VaultError('ERR_VAULT_CONFIG', 'argon.wrap4');
+    if (c.legacy !== undefined) {
+        if (typeof c.legacy !== 'object' || Array.isArray(c.legacy))
+            throw new VaultError('ERR_VAULT_CONFIG', 'legacy');
+        const lv = c.legacy;
+        if (lv.wrap !== undefined && lv.wrap !== false && !nonEmpty(lv.wrap))
+            throw new VaultError('ERR_VAULT_CONFIG', 'legacy.wrap');
+        if (lv.wrapDual !== undefined && !nonEmpty(lv.wrapDual))
+            throw new VaultError('ERR_VAULT_CONFIG', 'legacy.wrapDual');
+        if (lv.pinSaltPrefix !== undefined && !nonEmpty(lv.pinSaltPrefix))
+            throw new VaultError('ERR_VAULT_CONFIG', 'legacy.pinSaltPrefix');
+    }
     const prefixes = [c.cipher];
     for (const f of FAMILIES) {
         const p = f.prefix(c);
@@ -58,6 +140,11 @@ function validateConfig(c) {
             prefixes.push(p);
     }
     if (c.recovery !== undefined) {
+        // 物件形契約（resolver `recovery: true` opt-in 推導前的原始形＝boolean 進位——顯式路徑直通時 true/false 恆拒：
+        // true＝推導語意非顯式規格；false＝「無復原」語意不入 validateConfig 面）。
+        if (c.recovery === true || c.recovery === false || typeof c.recovery !== 'object' || Array.isArray(c.recovery)) {
+            throw new VaultError('ERR_VAULT_CONFIG', 'recovery');
+        }
         const r = c.recovery;
         // 兩欄一體（ERR_REC_CFG_PARTIAL 母型）：部分配置拒——禁寫出跨契約 blob。
         if (!r || !nonEmpty(r.wrapRec) || !nonEmpty(r.recKekHkdf))
@@ -91,17 +178,19 @@ function checkDualWritable(c) {
  *  store 面不被觸及（vault 無儲存），以惰性空殼滿足型別。 */
 const NO_STORE = { get: () => null, set: () => { }, remove: () => { }, noteKeyWrap: (k) => k };
 function legacyCfg(c) {
+    const lw = c.legacy?.wrap === false ? '' : c.legacy?.wrap ?? '';
     return {
         guestKdfPrefix: '',
         recSaltPrefix: '',
         cipherBound: c.cipher,
-        wrap: c.legacy?.wrap ?? '',
+        wrap: lw,
         wrapDual: c.legacy?.wrapDual,
         pinSaltPrefix: c.legacy?.pinSaltPrefix,
         store: NO_STORE,
     };
 }
-/** 復原面專用 cfg：wrap='' ＝舊契約回落腿關閉（identity 綁域的 jr1w. 復原套件不屬本 API）。 */
+/** 復原面專用 cfg：wrap='' ＝舊契約回落腿關閉（identity 綁域的 jr1w. 復原套件不屬本 API）。
+ *  呼叫端先收口：boolean 形 recovery 已由 validateConfig 拒（createVault）／recoverVault 入口拒——本函式唯物件形。 */
 function recoveryCfg(c) {
     const r = c.recovery;
     return {
@@ -325,42 +414,67 @@ function makeHandle(c, noteKey, st, carrierOpts) {
     };
 }
 // ── 入口 ────────────────────────────────────────────────────────────────────
-/** 新 vault：隨機 noteKey＋最新家族包裹（pin＝jr4d.，否則 jr4w.）＋選配復原套件（jr1r.）。 */
+/**
+ * deriveVaultPh1(passphrase, ph1Salt)：高階 Vault API 的 PH1 登入憑證派生（hex64）。
+ * 本體委派 `derivePh1ArgonV3(pass, ph1Salt)`（PH1 v3：Argon2id(normalizePassphrase(pass), 鹽, m=64MiB, t=3, p=1)→hex64）
+ * ——語意單一真相同在 argon2.ts，本函式只是 vault 子路徑的入口收口位（呼叫端免跨 import argon2）。
+ *
+ * ⚠️ 契約三行（README PH1 節同款）：
+ * 1. 鹽一經選定恆固定（per-product）——PH2 UNIQUE 約束：同一密語必須恆生同一 PH2；
+ *    per-user 鹽會摧毀它。改鹽＝帶內版本化換鹽尾碼重遷移，禁原地改語意。
+ * 2. `PH1_V3_SALT`（'tacet-ph1-v2'）禁當 saltArg 餵 v2 派生面 `derivePh1Argon`——
+ *    反之亦然：同鹽域值跨面餵入＝NFKC-effective 密語與 v2 raw 密語同值撞 PH2（鹽撞位警告）。
+ * 3. 其他產品用自有鹽域——禁硬編 tacet 鹽當預設；必須顯式帶入 `ph1Salt`。
+ */
+export async function deriveVaultPh1(passphrase, ph1Salt) {
+    return derivePh1ArgonV3(passphrase, ph1Salt);
+}
+/** 新 vault：隨機 noteKey＋最新家族包裹（pin＝<app>4d.，否則 <app>4w.）＋選配復原套件（<app>1r.）。
+ *  前綴零手填態（resolver）：`{ app }` 最小設定——全前綴由 app 決定性推導（resolveVaultConfig；
+ *  `recovery: true` opt-in、PIN 帶值＝同族尾碼推導 <app>4d. 不拒）；顯式 `argon`／`cipher` 在場
+ *  ＝顯式全配置路徑（零設定語意退出——缺欄照 validateConfig 拒）。輸入形 VaultOptions | VaultConfigInput。 */
 export function createVault(passphrase, opts) {
     return translate(async () => {
-        validateConfig(opts);
+        const o = resolveVaultConfig(opts);
+        const cfg = o.config;
+        validateConfig(cfg);
         checkPassphrase(passphrase);
         const pin = opts.pin === undefined ? null : opts.pin;
         if (pin !== null) {
             checkPin(pin);
-            checkDualWritable(opts);
+            checkDualWritable(cfg);
         }
         const carrier = await ensureArgonCarrier(opts.carrier);
         const noteKey = await generateNoteKey();
-        const w = await wrapCurrent(opts, noteKey, passphrase, pin);
+        const w = await wrapCurrent(cfg, noteKey, passphrase, pin);
         let recovery = null;
         if (opts.recovery) {
             const recToken = generateRecToken();
+            const words = (await recTokenToWords(recToken)); // generateRecToken 恆 hex64——null 不可能
             // identity 不入 HKDF 世代 KEK（identity-free by design）——空字串僅滿足簽名。
-            const wrappedRec = await wrapNoteKeyWithRecToken(recoveryCfg(opts), noteKey, recToken, '');
-            recovery = { recToken, wrappedRec, recTokenHash: await recTokenHash(recToken) };
+            const wrappedRec = await wrapNoteKeyWithRecToken(recoveryCfg(cfg), noteKey, recToken, '');
+            recovery = { recToken, words, wrappedRec, recTokenHash: await recTokenHash(recToken) };
         }
-        const vault = makeHandle(opts, noteKey, { rec: w.rec, family: w.family, carrier }, opts.carrier);
+        const vault = makeHandle(cfg, noteKey, { rec: w.rec, family: w.family, carrier }, opts.carrier);
         return { vault, serverRecord: { ...w.rec }, recovery };
     });
 }
 /** 解鎖：serverRecord（wrapped＋salt 成對）按前綴辨識家族（新→舊次序），舊世代照解；
- *  needsUpgrade() 為真時呼叫端可於同一動線 upgrade(passphrase) 靜默重包（Argon 遷移契約同構）。 */
+ *  前綴零手填態（resolver）：整組前綴缺省＝全前綴由 app 推導（resolveVaultConfig）；顯式欄位
+ *  在場＝顯式全配置路徑（零推導）。needsUpgrade() 為真時呼叫端可於同一動線
+ *  upgrade(passphrase) 靜默重包（Argon 遷移契約同構）。輸入形 VaultOptions | VaultConfigInput。 */
 export function unlockVault(passphrase, serverRecord, opts) {
     return translate(async () => {
-        validateConfig(opts);
+        const o = resolveVaultConfig(opts);
+        const cfg = o.config;
+        validateConfig(cfg);
         const r = serverRecord;
         if (!r || typeof r !== 'object' || !nonEmpty(r.wrapped) || typeof r.salt !== 'string' || !HEX32_RE.test(r.salt)) {
             throw new VaultError('ERR_VAULT_BAD_RECORD');
         }
         checkPassphrase(passphrase);
         const rec = { wrapped: r.wrapped, salt: r.salt };
-        const f = detectFamily(opts, rec.wrapped);
+        const f = detectFamily(cfg, rec.wrapped);
         if (!f)
             throw new VaultError('ERR_VAULT_WRAP_UNKNOWN');
         if (f.dual) {
@@ -369,23 +483,37 @@ export function unlockVault(passphrase, serverRecord, opts) {
             checkPin(opts.pin);
         }
         const carrier = f.argon ? await ensureArgonCarrier(opts.carrier) : null;
-        const noteKey = await unwrapOrThrow(f, opts, rec, passphrase, opts.pin ?? '');
-        return makeHandle(opts, noteKey, { rec, family: f.family, carrier }, opts.carrier);
+        const noteKey = await unwrapOrThrow(f, cfg, rec, passphrase, opts.pin ?? '');
+        return makeHandle(cfg, noteKey, { rec, family: f.family, carrier }, opts.carrier);
     });
 }
-/** 復原：recToken（hex64）＋wrappedRec（jr1r.）→ handle（無包裹欄——呼叫端隨即 changePassphrase 設新密語）。 */
+/** 復原：recToken（hex64）＋wrappedRec（<app>1r.）→ handle（無包裹欄——呼叫端隨即 changePassphrase 設新密語）。
+ *  前綴零手填態同上：recovery 未配置＝ERR_VAULT_CONFIG（零鹽選擇不可靜默——opt-in 鐵律；resolver 對
+ *  `recovery: true` 推導零鹽契約、物件形＝顯式零動）。輸入形 VaultOptions | VaultConfigInput。 */
 export function recoverVault(recToken, wrappedRec, opts) {
     return translate(async () => {
-        validateConfig(opts);
-        if (!opts.recovery)
-            throw new VaultError('ERR_VAULT_CONFIG', 'recovery');
-        if (typeof recToken !== 'string' || !HEX64_RE.test(recToken))
-            throw new VaultError('ERR_VAULT_RECOVERY', 'recToken');
-        if (typeof wrappedRec !== 'string' || !wrappedRec.startsWith(opts.recovery.wrapRec))
+        const o = resolveVaultConfig(opts);
+        const cfg = o.config;
+        validateConfig(cfg);
+        if (!cfg.recovery || cfg.recovery === true)
+            throw new VaultError('ERR_VAULT_CONFIG', 'recovery'); // true＝resolver opt-in 形——顯式路徑（argon/cipher 在場）未推導＝與未配置同拒
+        let token;
+        if (typeof recToken === 'string' && HEX64_RE.test(recToken)) {
+            token = recToken; // hex64 既有契約原樣
+        }
+        else {
+            // 詞形入參（24 詞空格單字串／24 詞陣列）：正規化→轉回 hex64→後續恆走原驗證路；
+            // 任何不符（錯詞 checksum／錯數／詞表外）＝ERR_VAULT_RECOVERY 照舊（不洩漏哪類錯）。
+            const hex = await wordsToRecToken(normalizeWordInput(recToken));
+            if (hex === null || !HEX64_RE.test(hex))
+                throw new VaultError('ERR_VAULT_RECOVERY', 'recToken');
+            token = hex;
+        }
+        if (typeof wrappedRec !== 'string' || !wrappedRec.startsWith(cfg.recovery.wrapRec))
             throw new VaultError('ERR_VAULT_RECOVERY', 'wrappedRec prefix');
-        const noteKey = await unwrapNoteKeyWithRecToken(recoveryCfg(opts), wrappedRec, recToken, '');
+        const noteKey = await unwrapNoteKeyWithRecToken(recoveryCfg(cfg), wrappedRec, token, '');
         if (!noteKey)
             throw new VaultError('ERR_VAULT_RECOVERY');
-        return makeHandle(opts, noteKey, { rec: null, family: null, carrier: null }, opts.carrier);
+        return makeHandle(cfg, noteKey, { rec: null, family: null, carrier: null }, opts.carrier);
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tacet-ink/journal-core",
-  "version": "0.3.3",
+  "version": "0.3.5",
   "description": "Zero-knowledge journal core — e2e crypto, passphrase-only auth, transport, ratelimit. The server never sees plaintext.",
   "homepage": "https://tacet.ink",
   "repository": {
@@ -89,11 +89,6 @@
   "files": [
     "dist",
     "docs",
-    "src",
-    "scripts",
-    "!scripts/generate-vectors.ts",
-    "!scripts/vendor-hash-wasm.cjs",
-    "!scripts/dts-fixture.cjs",
     "migrations",
     "README.md",
     "LICENSE"

package/scripts/prepare-core-pkg.cjs

@@ -1,74 +0,0 @@
-// t_c18a95ce 修復 A：prepare-core-pkg.cjs 斷鏈防線——@scure/bip39 鏡相依閉包 vendor 進 .core-pkg
-// 方案 (a) 真 vendor（裁定）：以 REF_DEPS 為根、聲明面 dependencies 遞迴窮舉閉包 → .core-pkg/node_modules
-const fs = require('fs');
-const path = require('path');
-
-const ROOT = path.join(__dirname, '..');
-const SRC_DIR = path.join(ROOT, 'node_modules', '@tacet-ink', 'journal-core');
-const VENDOR_DIR = path.join(ROOT, '.core-pkg');
-const LINK_TARGET = '../../.core-pkg';
-
-// 斷鏈封閉集：閘 scripts 參照的 devDeps @scure 與其宣告 runtime deps（@noble/hashes——
-// bip39 的 sha256/pbkdf2 面，npm 平坦安裝在根 node_modules，無嵌套副本）→ 遞迴鏡相依
-// 閉包全 vendor：只 vendor @scure 本體時，vendored bip39 內部 import '@noble/hashes/*'
-// 走父層查不到＝[19] 面在消費者手術環境恆紅（鏡相依閉包非單件）。
-// — prepare 時閉包全 vendor，realpath 與 SRC_DIR 同構逃出 node_modules 禁區。
-const REF_DEPS = ['@scure/bip39'];
-
-try {
-  const st = fs.lstatSync(SRC_DIR);
-  if (st.isSymbolicLink()) {
-    const cur = fs.readlinkSync(SRC_DIR);
-    if (cur.replace(/\/+$/, '') === LINK_TARGET) {
-      if (!fs.existsSync(VENDOR_DIR)) {
-        console.error('ABORT: symlink 已在場但 .core-pkg 缺席：rm node_modules 後重跑 npm ci（plain）');
-        process.exit(1);
-      }
-      console.log('CORE-PKG-PREPARE-OK (idempotent)');
-      process.exit(0);
-    }
-    console.error('ABORT: node_modules 條目是指向他人的 symlink： ' + cur);
-    process.exit(1);
-  }
-} catch (e) {
-  if (e && e.code !== 'ENOENT') { console.error('ABORT: ' + e.message); process.exit(1); }
-  console.error('ABORT: node_modules/@tacet-ink/journal-core 缺席：先跑 npm ci（plain，非 --ignore-scripts）');
-  process.exit(1);
-}
-
-// 真樹還原 → 複製 → symlink 手術
-fs.rmSync(VENDOR_DIR, { recursive: true, force: true });
-fs.cpSync(SRC_DIR, VENDOR_DIR, { recursive: true });
-// 參照依賴 vendor：.core-pkg/node_modules/<ref>（realpath 在 .core-pkg 樹內＝
-// strip-types 判準 realpath 之外；斷鏈防線——tarball 環境（.core-pkg/node_modules 自帶）
-// 與本樹手術環境（外部 vendor 直拷）同構＝閘 [16] pristine 全綠）。
-const vendoredRefs = [];
-const vendoredSet = new Set();
-const vendorQueue = [...REF_DEPS];
-while (vendorQueue.length) {
-  const ref = vendorQueue.pop();
-  if (vendoredSet.has(ref)) continue;
-  vendoredSet.add(ref);
-  const refAbs = path.join(ROOT, 'node_modules', ...ref.split('/'));
-  if (!fs.existsSync(refAbs)) {
-    console.error('ABORT: 參照閉包缺席（' + ref + '）：npm ci 未裝齊參照組依賴？');
-    process.exit(1);
-  }
-  fs.cpSync(refAbs, path.join(VENDOR_DIR, 'node_modules', ...ref.split('/')), { recursive: true });
-  vendoredRefs.push(ref);
-  // runtime deps 閉包遞迴（聲明面為準；嵌套副本由 cpSync 遞迴一併帶入，root 派為同構直拷）
-  try {
-    const depPkg = JSON.parse(fs.readFileSync(path.join(refAbs, 'package.json'), 'utf8'));
-    const deps = depPkg.dependencies && typeof depPkg.dependencies === 'object' ? Object.keys(depPkg.dependencies) : [];
-    vendorQueue.push(...deps);
-  } catch { /* 無法讀 package.json 的 vendored 件仍依序入帳——封閉集以聲明面窮舉為準 */ }
-}
-
-const a = fs.readFileSync(path.join(SRC_DIR, 'package.json'), 'utf8');
-const b = fs.readFileSync(path.join(VENDOR_DIR, 'package.json'), 'utf8');
-if (a !== b) { console.error('ABORT: .core-pkg 複製不一致'); process.exit(1); }
-fs.rmSync(SRC_DIR, { recursive: true, force: true });
-fs.symlinkSync(LINK_TARGET, SRC_DIR, 'dir');
-
-const ver = b.match(/"version": "([^"]+)"/)[1];
-console.log('CORE-PKG-PREPARE-OK ' + ver + '（vendored: ' + vendoredRefs.join(' ') + '）');