@dimina-kit/compiler 0.0.1-dev.20260702182435 → 0.0.1-dev.20260703101348

package/README.md

@@ -73,7 +73,7 @@ pool.dispose()                                       // 用完终止 worker
 
 > **上面是最小接入代码,但浏览器环境有前置要求**(不满足会在别处报错,不像示例不完整):页面与 worker 开 COOP/COEP;`toolchainSetupURL` 能被 worker 运行时 import;esbuild browser ESM 与 `esbuild.wasm` 可作静态资源访问;npm 用户需显式装 `@oxc-parser/binding-wasm32-wasi`(`cpu:wasm32` 会被跳过);本包经 `file:`/link 引用时要配 Vite `server.fs.allow`。逐条见本节末尾的「故障排查」。
 
-`compile()` 内部：三个常驻 worker **各跑一个完整 stage**（logic / view / style），各自 seed 私有 memfs、各自 `setupCompile` + 编译该 stage，产物取并集回传；跨 `compile()` 复用同一批 worker（每次编译前自动 `resetCompilerState`）。多个 `compile()` 会自动串行（共享常驻 realm 不能并发）。
+`compile()` 内部分两阶段：**先由一个 worker 跑一次 `setupCompile`**（分配 scope-hash id、构建 miniprogram_npm / app-config scaffold），把可序列化的 `{ pages, storeInfo, … }` bundle **广播给三个常驻 stage worker**（logic / view / style），各自 seed 私有 memfs、只跑 `compileStage`；产物 = scaffold ∪ 各 stage partial 回传。setup 只跑一次是**正确性要求**，不是优化：scope-hash（`data-v-XXXXX`）在 setup 阶段随机分配，若每个 stage realm 各自 setup，CSS 选择器与 render 产物的 id 会各摇一套、WXSS 整体失效（回归由 `test:pool-scopehash` 守护）。跨 `compile()` 复用同一批 worker（每次编译前自动 `resetCompilerState`）。多个 `compile()` 会自动串行（共享常驻 realm 不能并发）。
 
 > **连续触发（watch / 保存即编）要自己收敛：** pool 只保证串行，**不合并**——编译进行中再调 N 次 `compile()` 就排队 N 个全量编译，一个不少地跑完（正确性没问题，但白烧算力、垫高最后一次的延迟）。源码快照在**轮到该次编译派发时**才结构化克隆，不是调用时。触发侧应收敛成"至多一个在跑 + 一个待跑"（dirty-flag / debounce）。另外**整个应用共用一个 pool 单例**：多实例之间 realm 全隔离、不会互相污染，但结果没有跨实例顺序保证（旧编译可能晚于新编译返回，按到达顺序应用产物会拿旧盖新），还多付一份工具链常驻内存。
 
@@ -206,22 +206,27 @@ initToolchain(): Promise<void>                                       // no-op,
 | `collectOutputs({ fs, targetPath })` | 遍历 fs，把 `targetPath` 前缀下的**所有**产物读成 `{ 相对路径: 内容 }`（无 stage 过滤；含 setup 写的公共产物如 `app-config.json`） |
 | `resetCompilerState()` | 清编译器模块级缓存；**常驻 realm/worker 复用前必调**，否则第二次编译被污染。它清缓存但**不**重新 seed fs |
 
-> **stage 并行的正确姿势**（pool 内部就是这么做）：每个 stage worker **各自** `setupCompile`——因为它会往 fs 写 dist scaffold、`main/app-config.json`、`miniprogram_npm` 构建产物，只把 `storeInfo`/`pages` 发给 worker 而不重跑 setup 会丢这些文件。各 worker 用**私有 fs**，`collectOutputs` 收到的 partial 会含公共 setup 产物（内容相同，`Object.assign` 合并时相互覆盖无害）+ 本 stage 产物。**同一 realm 内不要并发调用接缝**（它们改全局 fs shim 与 compiler env）——并行必须落在不同 worker/realm；`compileMiniApp` 已内部串行化，接缝由调用方自己串行。view stage 不要再按页/分包细拆，必须让单个 view stage 看完整 `pages`（app 级模块去重才成立）。
+> **stage 并行的正确姿势**（pool 内部就是这么做）：`setupCompile` **整个编译只跑一次**（一个 realm），把返回的 `{ pages, storeInfo }` 发给每个 stage worker 跑 `compileStage`——**绝不能每个 stage realm 各自 setup**：scope-hash（页面/组件的 `data-v-XXXXX` id）在 setup 阶段随机分配，各 realm 各摇一套会让 style 写进 CSS 的选择器与 view 写进 render 产物的 id 完全不相交，WXSS 全部落空（`test:pool-scopehash` 守护此契约）。setup 往它自己的 fs 写 dist scaffold、`main/app-config.json`、`miniprogram_npm` 构建产物——在 setup realm 用 `collectOutputs` 收走这份 scaffold 并入最终并集；各 stage worker 用**私有 fs**、不需要 scaffold（三 stage 只从 `workPath` 读源码，产物写方向才用 `targetPath`），其 partial 只含本 stage 产物。**同一 realm 内不要并发调用接缝**（它们改全局 fs shim 与 compiler env）——并行必须落在不同 worker/realm；`compileMiniApp` 已内部串行化，接缝由调用方自己串行。view stage 不要再按页/分包细拆，必须让单个 view stage 看完整 `pages`（app 级模块去重才成立）。
 
-**pool 的线程边界与编译流程**：主线程**只**派发 + 合并(不加载 wasm、不跑编译);`setupCompile → compileStage → collectOutputs` 整条流程都在**每个 stage worker(Web Worker 线程)内**跑。
+**pool 的线程边界与编译流程**：主线程**只**派发 + 合并(不加载 wasm、不跑编译);编译分两阶段全在 worker 内跑——Phase 1 一个 worker `setupCompile`(分配 scope-hash id + 写 scaffold,收走 scaffold 与可序列化 bundle);Phase 2 三个 stage worker 各拿**同一份** bundle 跑 `compileStage → collectOutputs`。
 
 ```mermaid
 flowchart TD
   DISP["主线程 · pool.compile(files)<br/>只派发 + 合并,不加载 wasm、不跑编译"]
-  DISP -->|"同一份 files 发给 3 个 worker"| WK
-  subgraph WK["每个常驻 stage worker(Web Worker 线程) · 各跑一个 stage · 编译全在这里"]
+  DISP -->|"Phase 1 · files 发给 1 个 worker"| SETUP
+  subgraph SETUP["setup worker(Web Worker 线程) · 整个编译只跑一次"]
     direction TB
-    SRC["seed 私有 memfs"] --> SU["setupCompile<br/>解析配置 + miniprogram_npm → storeInfo/pages,写 scaffold/app-config"]
-    SU --> ST["compileStage(本 worker 的 stage)<br/>logic→main/logic.js · view→main/*.js · style→真实 cssnano+autoprefixer→*.css"]
+    SSRC["seed 私有 memfs"] --> SU["setupCompile<br/>解析配置 + miniprogram_npm → 分配 scope-hash id,写 scaffold/app-config"]
+    SU --> SC["collectOutputs 收 scaffold<br/>+ 可序列化 bundle { pages, storeInfo, targetPath, appId, name }"]
+  end
+  SETUP -->|"Phase 2 · files + 同一份 bundle 广播给 3 个 worker"| WK
+  subgraph WK["每个常驻 stage worker(Web Worker 线程) · 各跑一个 stage"]
+    direction TB
+    SRC["seed 私有 memfs"] --> ST["compileStage(本 worker 的 stage,用 bundle 的 pages/storeInfo)<br/>logic→main/logic.js · view→main/*.js · style→真实 cssnano+autoprefixer→*.css"]
     ST --> CO["collectOutputs<br/>遍历 fs 收 targetPath 下产物 = 本 stage partial"]
-    RS["resetCompilerState 清模块级缓存"] -.->|"每次编译前"| SU
+    RS["resetCompilerState 清模块级缓存"] -.->|"每次编译前"| ST
   end
-  WK -->|"3 份 partial"| MERGE["主线程 · Object.assign 并集<br/>→ { appId, name, files }"]
+  WK -->|"3 份 partial"| MERGE["主线程 · scaffold ∪ 3 份 partial<br/>→ { appId, name, files }"]
 ```
 
 > 用 **core 的 `compileMiniApp`**(单线程)时,是同一条 `setupCompile → 三个 stage → collectOutputs`,只是在**一个 realm、你调用它的那个线程**里跑完——你在主线程调就阻塞主线程,放进自己的 worker 就在那个 worker 跑。
@@ -348,6 +353,7 @@ pnpm --filter @dimina-kit/compiler test:appid       # appId fallback 守卫
 pnpm --filter @dimina-kit/compiler test:decompose   # stage 接缝各自独立、产物互不相交
 pnpm --filter @dimina-kit/compiler test:realm-reuse # resetCompilerState 后复用 realm 与全新 realm 一致
 pnpm --filter @dimina-kit/compiler test:pool-node   # Node pool 与 dmcc 冷+热逐字节等价(含 sourcemap 与返回值)
+pnpm --filter @dimina-kit/compiler test:pool-scopehash # 浏览器 pool 跨 stage scope-hash 内容级一致(CSS data-v-* ⊆ render Module id;文件集校验看不见这层)
 ```
 
 `pool` 的浏览器端到端验证在 `dimina-web-client`（`npm run test:pool`，Playwright 驱动，产物与单线程逐结构一致）。`pool-node` 的宿主端验证在 `@dimina-kit/devkit` 测试套件（真实 fork + `openProject`）。

package/dist/compile-core.browser.js

@@ -32179,9 +32179,9 @@ var require_agents4 = __commonJS({
   }
 });
 
-// ../../dimina/fe/node_modules/.pnpm/electron-to-chromium@1.5.384/node_modules/electron-to-chromium/versions.js
+// ../../dimina/fe/node_modules/.pnpm/electron-to-chromium@1.5.385/node_modules/electron-to-chromium/versions.js
 var require_versions2 = __commonJS({
-  "../../dimina/fe/node_modules/.pnpm/electron-to-chromium@1.5.384/node_modules/electron-to-chromium/versions.js"(exports, module) {
+  "../../dimina/fe/node_modules/.pnpm/electron-to-chromium@1.5.385/node_modules/electron-to-chromium/versions.js"(exports, module) {
     module.exports = {
       "0.20": "39",
       "0.21": "41",
@@ -32438,7 +32438,8 @@ var require_versions2 = __commonJS({
       "42.3": "148",
       "42.4": "148",
       "42.5": "148",
-      "43.0": "150"
+      "43.0": "150",
+      "44.0": "151"
     };
   }
 });

package/dist/pool.browser.js

@@ -67,17 +67,19 @@ function createCompilerPool(options = {}) {
         throw new Error("[compiler] pool.compile expects { files: { relPath: content }, workPath? } (or a non-empty files map)");
       }
       const workPath = input.workPath || defaultWorkPath;
-      const parts = await Promise.all(workers.map((x) => x.send({ type: "compile-subset", files, workPath, stages: [x.stage] })));
-      const merged = {};
-      let appId, name;
+      const s = await workers[0].send({ type: "setup", files, workPath });
+      if (!s || s.type === "error") {
+        throw new Error(s && s.error ? s.error : `[compiler] setup phase failed in stage '${workers[0].stage}' worker`);
+      }
+      const { bundle, scaffold } = s;
+      const parts = await Promise.all(workers.map((x) => x.send({ type: "compile-subset", files, workPath, stages: [x.stage], bundle })));
+      const merged = { ...scaffold || {} };
       for (let i = 0; i < parts.length; i++) {
         const pr = parts[i];
         if (!pr || pr.type === "error") throw new Error(pr && pr.error ? pr.error : `[compiler] stage '${workers[i].stage}' worker error`);
-        appId = pr.result.appId;
-        name = pr.result.name;
         Object.assign(merged, pr.result.files);
       }
-      return { appId, name, files: merged };
+      return { appId: bundle.appId, name: bundle.name, files: merged };
     });
     chain = run.then(() => {
     }, () => {

package/dist/stage-worker.browser.js

@@ -46145,9 +46145,9 @@ var require_agents4 = __commonJS({
   }
 });
 
-// ../../dimina/fe/node_modules/.pnpm/electron-to-chromium@1.5.384/node_modules/electron-to-chromium/versions.js
+// ../../dimina/fe/node_modules/.pnpm/electron-to-chromium@1.5.385/node_modules/electron-to-chromium/versions.js
 var require_versions2 = __commonJS({
-  "../../dimina/fe/node_modules/.pnpm/electron-to-chromium@1.5.384/node_modules/electron-to-chromium/versions.js"(exports, module) {
+  "../../dimina/fe/node_modules/.pnpm/electron-to-chromium@1.5.385/node_modules/electron-to-chromium/versions.js"(exports, module) {
     module.exports = {
       "0.20": "39",
       "0.21": "41",
@@ -46404,7 +46404,8 @@ var require_versions2 = __commonJS({
       "42.3": "148",
       "42.4": "148",
       "42.5": "148",
-      "43.0": "150"
+      "43.0": "150",
+      "44.0": "151"
     };
   }
 });
@@ -290972,17 +290973,44 @@ function needsToolchain(stages) {
 function freshFs(files, workPath) {
   return (0, import_memfs.createFsFromVolume)(import_memfs.Volume.fromJSON(files, workPath));
 }
-async function compileSubset(files, workPath, stages) {
+async function runSetup(files, workPath) {
   const fs2 = freshFs(files, workPath);
   resetCompilerState();
   const ctx = await setupCompile({ fs: fs2, workPath });
-  for (const stage of stages) {
-    await compileStage({ stage, pages: ctx.pages, storeInfo: ctx.storeInfo, fs: fs2 });
-  }
   const map4 = collectOutputs({ fs: fs2, targetPath: ctx.targetPath });
+  const scaffold = {};
+  for (const k of Object.keys(map4)) if (map4[k] != null) scaffold[k] = map4[k];
+  const bundle = {
+    pages: ctx.pages,
+    storeInfo: ctx.storeInfo,
+    targetPath: ctx.targetPath,
+    appId: ctx.appId,
+    name: ctx.name
+  };
+  return { bundle, scaffold };
+}
+async function compileSubset(files, workPath, stages, bundle) {
+  const fs2 = freshFs(files, workPath);
+  resetCompilerState();
+  let appId, name, targetPath;
+  if (bundle) {
+    for (const stage of stages) {
+      await compileStage({ stage, pages: bundle.pages, storeInfo: bundle.storeInfo, fs: fs2 });
+    }
+    ;
+    ({ appId, name, targetPath } = bundle);
+  } else {
+    const ctx = await setupCompile({ fs: fs2, workPath });
+    for (const stage of stages) {
+      await compileStage({ stage, pages: ctx.pages, storeInfo: ctx.storeInfo, fs: fs2 });
+    }
+    ;
+    ({ appId, name, targetPath } = ctx);
+  }
+  const map4 = collectOutputs({ fs: fs2, targetPath });
   const out = {};
   for (const k of Object.keys(map4)) if (map4[k] != null) out[k] = map4[k];
-  return { appId: ctx.appId, name: ctx.name, files: out };
+  return { appId, name, files: out };
 }
 self.onmessage = async (e) => {
   const { type } = e.data || {};
@@ -290994,13 +291022,22 @@ self.onmessage = async (e) => {
       self.postMessage({ type: "ready", ms: Math.round(performance.now() - t0) });
       return;
     }
+    if (type === "setup") {
+      const { files, workPath = "/work", toolchainSetupURL } = e.data;
+      if (toolchainSetupURL) toolchainURL = toolchainSetupURL;
+      await ensureToolchain();
+      const t = performance.now();
+      const { bundle, scaffold } = await runSetup(files, workPath);
+      self.postMessage({ type: "setup-done", bundle, scaffold, ms: Math.round(performance.now() - t) });
+      return;
+    }
     if (type === "compile-subset") {
-      const { files, workPath = "/work", stages = ["logic", "view", "style"], toolchainSetupURL } = e.data;
+      const { files, workPath = "/work", stages = ["logic", "view", "style"], bundle, toolchainSetupURL } = e.data;
       if (toolchainSetupURL) toolchainURL = toolchainSetupURL;
       if (needsToolchain(stages)) await ensureToolchain();
       const warm = !!toolchainReady;
       const t = performance.now();
-      const result2 = await compileSubset(files, workPath, stages);
+      const result2 = await compileSubset(files, workPath, stages, bundle);
       self.postMessage({ type: "done", result: result2, ms: Math.round(performance.now() - t), warm });
       return;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dimina-kit/compiler",
-  "version": "0.0.1-dev.20260702182435",
+  "version": "0.0.1-dev.20260703101348",
   "description": "dmcc compiler bundles (browser + node) that drive @dimina/compiler against a caller-injected node:fs replacement (no bundled fs)",
   "license": "MIT",
   "type": "module",
@@ -81,6 +81,7 @@
     "test:decompose": "node scripts/build-compiler.js node && node --import ./scripts/register-kit.js scripts/test-decompose.js",
     "test:realm-reuse": "node scripts/build-compiler.js node && node --import ./scripts/register-kit.js scripts/test-realm-reuse.js",
     "test:pool-node": "node scripts/build-compiler.js node && node --import ./scripts/register-kit.js scripts/test-pool-node.js",
+    "test:pool-scopehash": "node scripts/build-compiler.js node && node --import ./scripts/register-kit.js scripts/test-pool-scopehash.js",
     "test:pool-hardening": "node scripts/build-compiler.js node && node scripts/test-pool-hardening.js",
     "test:npm-scan": "node scripts/build-compiler.js node && node --import ./scripts/register-kit.js scripts/test-npm-scan.js",
     "test:stage-toolchain": "node scripts/build-compiler.js browser && node scripts/test-stage-toolchain.js"

package/scripts/test-pool-scopehash.js

@@ -0,0 +1,239 @@
+// Content-level scope-hash consistency check for the stage-parallel pool.
+//
+// The pool's structural-equivalence tests (test:pool-node) only compare file
+// NAME/length multisets, so they cannot see whether the `data-v-XXXXX` scope
+// hashes baked into the CSS (`[data-v-X]` selectors) actually match the ones
+// baked into the compiled render templates (`.js`, `scopeId: data-v-X`). If the
+// view stage and the style stage allocate ids in DIFFERENT realms, their hashes
+// diverge and every WXSS rule targets a selector that never appears in the DOM —
+// styles silently stop working while the file lists still match.
+//
+// This script models the browser pool (src/pool.js + src/stage-worker.js) in
+// Node: each stage compiles in its OWN fresh memfs, exactly as a separate Web
+// Worker realm would. It runs the OLD per-worker-setup path and the FIXED
+// shared-setup path and asserts, at the content level, that every scope hash
+// used in CSS also appears in the render output.
+import { readdirSync, readFileSync, statSync } from 'node:fs'
+import { fileURLToPath } from 'node:url'
+import path from 'node:path'
+import { Volume, createFsFromVolume } from 'memfs'
+
+const APP = process.env.APP_DIR
+  || fileURLToPath(new URL('../../../dimina/fe/example/vant', import.meta.url))
+
+const TEXT_EXT = new Set([
+  '.json', '.js', '.ts', '.wxml', '.ddml', '.wxss', '.ddss', '.less',
+  '.scss', '.sass', '.wxs', '.dds', '.css',
+])
+function readDir(dir, baseDir, out) {
+  for (const name of readdirSync(dir)) {
+    if (name === 'node_modules' || name === '.git') continue
+    const full = path.join(dir, name)
+    if (statSync(full).isDirectory()) readDir(full, baseDir, out)
+    else if (TEXT_EXT.has(path.extname(name).toLowerCase())) {
+      out[path.relative(baseDir, full).split(path.sep).join('/')] = readFileSync(full, 'utf8')
+    }
+  }
+}
+
+const seed = {}
+readDir(APP, APP, seed)
+console.log(`[seed] ${Object.keys(seed).length} text files from ${APP}`)
+
+const workPath = '/work'
+const core = await import('../dist/compile-core.node.js')
+const { setupCompile, compileStage, collectOutputs, compileMiniApp, resetCompilerState } = core
+// The pool orchestration under test is the real source module (pure ESM, no
+// browser-only imports), driven below through a mock worker backed by node core.
+const { createCompilerPool } = await import('../src/pool.js')
+const fileSet = (m) => Object.keys(m).sort().join('\n')
+
+// Every realm in the real pool (setup worker AND each stage worker) calls
+// resetCompilerState() before it works (stage-worker.js). In this single-process
+// model, separate Web Worker realms are simulated by calling it before each
+// realm-equivalent operation so module-level caches never leak between them.
+const realm = () => resetCompilerState()
+
+const STAGES = ['logic', 'view', 'style']
+const freshFs = () => createFsFromVolume(Volume.fromJSON(seed, workPath))
+const clean = (m) => { for (const k of Object.keys(m)) if (m[k] == null) delete m[k]; return m }
+
+// CSS carries the scope hash as `[data-v-XXXXX]`; the compiled render carries
+// the SAME 5-char id bare in each `Module({ …, id:"XXXXX", … })` (the runtime
+// prepends `data-v-`). Extract each with its own pattern so we compare the
+// cross-file linkage the runtime actually relies on.
+function hashesIn(files, pred, re) {
+  const set = new Set()
+  for (const k of Object.keys(files)) {
+    if (!pred(k)) continue
+    const v = files[k]
+    if (typeof v !== 'string') continue
+    let m
+    re.lastIndex = 0
+    while ((m = re.exec(v))) set.add(m[1])
+  }
+  return set
+}
+const CSS_RE = /data-v-([a-z0-9]{5})/g
+const RENDER_RE = /\bid:\s*["']([a-z0-9]{5})["']/g
+const isCss = (k) => k.endsWith('.css')
+const isRender = (k) => k.endsWith('.js') && k !== 'main/logic.js' && !k.endsWith('/logic.js')
+
+// Report the CSS-vs-render scope-hash relationship for a merged output map.
+function report(label, files) {
+  const css = hashesIn(files, isCss, CSS_RE)
+  const js = hashesIn(files, isRender, RENDER_RE)
+  const orphanCss = [...css].filter((h) => !js.has(h)) // CSS selectors that target nothing rendered
+  const matched = [...css].filter((h) => js.has(h))
+  console.log(`\n[${label}] css-scope-hashes=${css.size} render-scope-hashes=${js.size} `
+    + `matched=${matched.length} orphanCSS=${orphanCss.length}`)
+  if (orphanCss.length) {
+    console.log(`   orphan CSS hashes (in CSS, absent from render): ${orphanCss.slice(0, 10).join(', ')}${orphanCss.length > 10 ? ' …' : ''}`)
+  }
+  return { css, js, orphanCss, matched }
+}
+
+// --- MODEL A: OLD browser pool — each stage runs setupCompile in its own realm ---
+async function buildPerStageSetup() {
+  const merged = {}
+  for (const stage of STAGES) {
+    realm()
+    const fs = freshFs()
+    const ctx = await setupCompile({ fs, workPath }) // independent id allocation per stage
+    await compileStage({ stage, pages: ctx.pages, storeInfo: ctx.storeInfo, fs })
+    Object.assign(merged, clean(collectOutputs({ fs, targetPath: ctx.targetPath })))
+  }
+  return merged
+}
+
+// --- MODEL B: FIXED pool — setup ONCE, broadcast the bundle across stage realms ---
+// This models the fixed browser pool exactly (mirrors the working Node disk pool):
+// one realm runs setupCompile (id allocation + npm/app-config scaffold); the shared
+// `{ pages, storeInfo }` bundle is broadcast to every stage worker, which only runs
+// compileStage against it. Setup scaffold (app-config.json + npm) is merged in.
+async function buildSharedSetup() {
+  realm()
+  const setupFs = freshFs()
+  const ctx = await setupCompile({ fs: setupFs, workPath })
+  const bundle = { pages: ctx.pages, storeInfo: ctx.storeInfo, targetPath: ctx.targetPath, appId: ctx.appId, name: ctx.name }
+  const merged = clean(collectOutputs({ fs: setupFs, targetPath: ctx.targetPath })) // setup scaffold
+  for (const stage of STAGES) {
+    realm()
+    const fs = freshFs()
+    // structuredClone mimics the structured-clone every postMessage bundle undergoes.
+    const b = structuredClone(bundle)
+    await compileStage({ stage, pages: b.pages, storeInfo: b.storeInfo, fs })
+    Object.assign(merged, clean(collectOutputs({ fs, targetPath: b.targetPath })))
+  }
+  return merged
+}
+
+// --- MODEL C: the REAL src/pool.js orchestration, driven by a mock worker ---
+// Exercises the actual pool code (setup phase → broadcast bundle → merge scaffold)
+// that the browser ships, but backs each "worker" with node core so no wasm/Web
+// Worker is needed. Separate Web Worker realms are modeled by serializing every
+// handler through one chain (isolated module state) + resetCompilerState per op —
+// so this proves the pool's WIRING keeps scope hashes consistent, not just the
+// compile-core sequence MODEL B covers.
+// One shared chain across ALL mock workers: a real Web Worker is its own realm with
+// its own compile-core module (fs backend, env singletons), but here every mock
+// worker shares this process's single node core module. Serializing all handlers
+// through one chain models that realm isolation (only one core op runs at a time),
+// so pool.js's parallel compile-subset dispatch can't cross-corrupt the shared fs.
+let mockChain = Promise.resolve()
+function makeMockWorker() {
+  const w = { onmessage: null, onerror: null, terminate() {} }
+  w.postMessage = (msg) => {
+    mockChain = mockChain.then(async () => {
+      let reply
+      try {
+        if (msg.type === 'warmup') {
+          reply = { type: 'ready', ms: 0 }
+        } else if (msg.type === 'setup') {
+          realm()
+          const fs = createFsFromVolume(Volume.fromJSON(msg.files, msg.workPath))
+          const ctx = await setupCompile({ fs, workPath: msg.workPath })
+          reply = {
+            type: 'setup-done',
+            bundle: { pages: ctx.pages, storeInfo: ctx.storeInfo, targetPath: ctx.targetPath, appId: ctx.appId, name: ctx.name },
+            scaffold: clean(collectOutputs({ fs, targetPath: ctx.targetPath })),
+          }
+        } else if (msg.type === 'compile-subset') {
+          realm()
+          const fs = createFsFromVolume(Volume.fromJSON(msg.files, msg.workPath))
+          const b = structuredClone(msg.bundle) // mimic postMessage structured clone
+          for (const stage of msg.stages) await compileStage({ stage, pages: b.pages, storeInfo: b.storeInfo, fs })
+          reply = { type: 'done', result: { appId: b.appId, name: b.name, files: clean(collectOutputs({ fs, targetPath: b.targetPath })) } }
+        }
+      } catch (e) {
+        reply = { type: 'error', error: String((e && e.stack) || e) }
+      }
+      queueMicrotask(() => { if (w.onmessage) w.onmessage({ data: reply }) })
+    })
+  }
+  return w
+}
+async function buildViaPool() {
+  const pool = createCompilerPool({ createWorker: makeMockWorker, toolchainSetupURL: 'noop://toolchain' })
+  const res = await pool.compile({ files: seed, workPath })
+  pool.dispose()
+  return res
+}
+
+// --- ground truth: single-realm compileMiniApp ---
+realm()
+const inline = clean((await compileMiniApp({ fs: freshFs(), workPath })).files)
+const gt = report('inline (single realm, ground truth)', inline)
+
+const modelA = await buildPerStageSetup()
+const rA = report('MODEL A — per-stage independent setup (current browser pool)', modelA)
+
+const modelB = await buildSharedSetup()
+const rB = report('MODEL B — shared setup bundle (fix)', modelB)
+
+const poolRes = await buildViaPool()
+const modelC = clean(poolRes.files)
+const rC = report('MODEL C — real src/pool.js orchestration (mock worker)', modelC)
+
+let failed = false
+const fail = (m) => { failed = true; console.error(`❌ ${m}`) }
+const pass = (m) => console.log(`✅ ${m}`)
+
+// Ground truth must be self-consistent (every CSS hash targets a rendered element).
+if (gt.orphanCss.length) fail(`ground truth has ${gt.orphanCss.length} orphan CSS hashes — test harness bug`)
+else pass('ground truth: every CSS scope hash appears in the render output')
+
+// Model A is EXPECTED to be broken — assert it reproduces the bug.
+if (rA.orphanCss.length > 0 && rA.matched.length === 0) {
+  pass(`REPRODUCED: per-stage setup yields ${rA.orphanCss.length} orphan CSS hashes, 0 matched — WXSS fully broken`)
+} else if (rA.orphanCss.length > 0) {
+  pass(`REPRODUCED (partial): per-stage setup yields ${rA.orphanCss.length} orphan CSS hashes`)
+} else {
+  fail('per-stage setup did NOT reproduce the mismatch (bug model invalid)')
+}
+
+// Model B (fix) must be fully consistent AND structurally complete.
+if (rB.orphanCss.length === 0 && rB.css.size === gt.css.size) {
+  pass(`FIX VERIFIED: shared setup yields 0 orphan CSS hashes, ${rB.matched.length} matched (== ground truth ${gt.css.size})`)
+} else {
+  fail(`shared setup still has ${rB.orphanCss.length} orphan CSS hashes (css=${rB.css.size} gt=${gt.css.size})`)
+}
+// Both models must emit the SAME file set as the single-realm ground truth — this is
+// what the structural test already checks, and why it stays green while WXSS is broken.
+if (fileSet(modelA) !== fileSet(inline)) fail('MODEL A file set differs from ground truth (unexpected)')
+else pass('MODEL A file set == ground truth (this is exactly why the name/length structural test passes while WXSS is broken)')
+if (fileSet(modelB) !== fileSet(inline)) fail('MODEL B (fix) file set differs from ground truth')
+else pass('MODEL B (fix) file set == ground truth')
+
+// Model C (real pool.js code) must be consistent + complete, and report the right appId.
+if (rC.orphanCss.length === 0 && rC.css.size === gt.css.size) {
+  pass(`POOL WIRING VERIFIED: src/pool.js yields 0 orphan CSS hashes, ${rC.matched.length} matched (== ground truth ${gt.css.size})`)
+} else {
+  fail(`src/pool.js still has ${rC.orphanCss.length} orphan CSS hashes (css=${rC.css.size} gt=${gt.css.size})`)
+}
+if (fileSet(modelC) !== fileSet(inline)) fail('MODEL C (pool.js) file set differs from ground truth')
+else pass('MODEL C (pool.js) file set == ground truth')
+if (!poolRes.appId) fail('MODEL C (pool.js) returned no appId')
+
+console.log(failed ? '\n❌ FAIL' : '\n✅ PASS')
+process.exit(failed ? 1 : 0)

package/src/pool.js

@@ -97,19 +97,33 @@ export function createCompilerPool(options = {}) {
         throw new Error('[compiler] pool.compile expects { files: { relPath: content }, workPath? } (or a non-empty files map)')
       }
       const workPath = input.workPath || defaultWorkPath
+
+      // Phase 1 — one worker runs setup ONCE: it allocates the scope-hash ids
+      // (page + component data-v-XXXXX) and builds miniprogram_npm/app-config.json.
+      // Broadcasting this single bundle to every stage is REQUIRED for correctness:
+      // each stage runs in its own realm, and if each ran its own setup it would roll
+      // independent random uuids, so the CSS `[data-v-X]` selectors would never match
+      // the render `Module id` and every WXSS rule would target nothing (regression
+      // guarded by scripts/test-pool-scopehash.js). This mirrors the Node disk pool,
+      // which likewise sets up once and fans the same { pages, storeInfo } out.
+      const s = await workers[0].send({ type: 'setup', files, workPath })
+      if (!s || s.type === 'error') {
+        throw new Error(s && s.error ? s.error : `[compiler] setup phase failed in stage '${workers[0].stage}' worker`)
+      }
+      const { bundle, scaffold } = s
+
+      // Phase 2 — every stage compiles in parallel against the SHARED bundle. The
+      // non-stage scaffold (app-config.json + npm, produced once) seeds the union.
       const parts = await Promise.all(workers.map((x) =>
-        x.send({ type: 'compile-subset', files, workPath, stages: [x.stage] })))
-      const merged = {}
-      let appId, name
+        x.send({ type: 'compile-subset', files, workPath, stages: [x.stage], bundle })))
+      const merged = { ...(scaffold || {}) }
       for (let i = 0; i < parts.length; i++) {
         const pr = parts[i]
         // pr.error carries the worker's real error string (message + stack) — surface it.
         if (!pr || pr.type === 'error') throw new Error(pr && pr.error ? pr.error : `[compiler] stage '${workers[i].stage}' worker error`)
-        appId = pr.result.appId
-        name = pr.result.name
         Object.assign(merged, pr.result.files)   // stages write disjoint files -> clean union
       }
-      return { appId, name, files: merged }
+      return { appId: bundle.appId, name: bundle.name, files: merged }
     })
     // keep the chain alive regardless of this compile's outcome
     chain = run.then(() => {}, () => {})

package/src/stage-worker.js

@@ -58,21 +58,61 @@ function freshFs(files, workPath) {
   return createFsFromVolume(Volume.fromJSON(files, workPath))
 }
 
+// Run setupCompile ONCE for a compile: parse config, allocate the scope-hash ids
+// (page + component `data-v-XXXXX`), scaffold app-config.json + miniprogram_npm.
+// Returns the SERIALIZABLE id bundle every stage worker must share, plus the
+// non-stage scaffold files. Sharing this one bundle across the per-stage realms is
+// what keeps the CSS `[data-v-X]` selectors and the render `Module id` in agreement:
+// if each stage ran its own setupCompile it would roll its own random uuids and every
+// WXSS rule would target a selector that never renders (see scripts/test-pool-scopehash.js).
+async function runSetup(files, workPath) {
+  const fs = freshFs(files, workPath)
+  resetCompilerState()
+  const ctx = await setupCompile({ fs, workPath })
+  const map = collectOutputs({ fs, targetPath: ctx.targetPath })
+  const scaffold = {}
+  for (const k of Object.keys(map)) if (map[k] != null) scaffold[k] = map[k]
+  const bundle = {
+    pages: ctx.pages,
+    storeInfo: ctx.storeInfo,
+    targetPath: ctx.targetPath,
+    appId: ctx.appId,
+    name: ctx.name,
+  }
+  return { bundle, scaffold }
+}
+
 // Compile only the requested stages against a fresh memfs seeded with the source.
 // resetCompilerState() clears the compiler's module-level caches so this warm realm
 // stays correct across compiles. Stages write disjoint products; we return this
 // worker's subset and the pool unions them.
-async function compileSubset(files, workPath, stages) {
+//
+// With a `bundle` (from runSetup), the stage reuses the coordinator's shared ids
+// (mirroring the Node disk pool, which broadcasts the same { pages, storeInfo } to
+// every stage worker) instead of running its own setupCompile — the fix for the
+// cross-stage scope-hash mismatch. Stages read source from `workPath` and write
+// disjoint products; they never read the setup scaffold, so it is not seeded here.
+// Without a bundle the worker stays self-contained (single-worker / legacy callers).
+async function compileSubset(files, workPath, stages, bundle) {
   const fs = freshFs(files, workPath)
   resetCompilerState()
-  const ctx = await setupCompile({ fs, workPath })
-  for (const stage of stages) {
-    await compileStage({ stage, pages: ctx.pages, storeInfo: ctx.storeInfo, fs })
+  let appId, name, targetPath
+  if (bundle) {
+    for (const stage of stages) {
+      await compileStage({ stage, pages: bundle.pages, storeInfo: bundle.storeInfo, fs })
+    }
+    ;({ appId, name, targetPath } = bundle)
+  } else {
+    const ctx = await setupCompile({ fs, workPath })
+    for (const stage of stages) {
+      await compileStage({ stage, pages: ctx.pages, storeInfo: ctx.storeInfo, fs })
+    }
+    ;({ appId, name, targetPath } = ctx)
   }
-  const map = collectOutputs({ fs, targetPath: ctx.targetPath })
+  const map = collectOutputs({ fs, targetPath })
   const out = {}
   for (const k of Object.keys(map)) if (map[k] != null) out[k] = map[k]
-  return { appId: ctx.appId, name: ctx.name, files: out }
+  return { appId, name, files: out }
 }
 
 self.onmessage = async (e) => {
@@ -88,13 +128,25 @@ self.onmessage = async (e) => {
       self.postMessage({ type: 'ready', ms: Math.round(performance.now() - t0) })
       return
     }
+    if (type === 'setup') {
+      // Coordinator phase: one worker parses config, allocates the shared scope-hash
+      // ids and builds miniprogram_npm once. setupCompile's npm build can invoke the
+      // wasm toolchain, so ensure it's loaded regardless of this worker's own stage.
+      const { files, workPath = '/work', toolchainSetupURL } = e.data
+      if (toolchainSetupURL) toolchainURL = toolchainSetupURL
+      await ensureToolchain()
+      const t = performance.now()
+      const { bundle, scaffold } = await runSetup(files, workPath)
+      self.postMessage({ type: 'setup-done', bundle, scaffold, ms: Math.round(performance.now() - t) })
+      return
+    }
     if (type === 'compile-subset') {
-      const { files, workPath = '/work', stages = ['logic', 'view', 'style'], toolchainSetupURL } = e.data
+      const { files, workPath = '/work', stages = ['logic', 'view', 'style'], bundle, toolchainSetupURL } = e.data
       if (toolchainSetupURL) toolchainURL = toolchainSetupURL
       if (needsToolchain(stages)) await ensureToolchain()
       const warm = !!toolchainReady
       const t = performance.now()
-      const result = await compileSubset(files, workPath, stages)
+      const result = await compileSubset(files, workPath, stages, bundle)
       self.postMessage({ type: 'done', result, ms: Math.round(performance.now() - t), warm })
       return
     }