@dimina-kit/compiler 0.0.1-dev.20260702173719

package/dist/toolchain.browser.js

@@ -0,0 +1,30 @@
+globalThis.global ||= globalThis;
+globalThis.process ||= { env: {}, cwd: () => "/" };
+globalThis.process.cwd ||= () => "/";
+
+// src/toolchain.js
+async function installEsbuildFromURL(moduleURL, wasmURL) {
+  const code = await fetch(moduleURL).then((r) => {
+    if (!r.ok) throw new Error(`[compiler] installEsbuildFromURL: failed to fetch ${moduleURL} (${r.status})`);
+    return r.text();
+  });
+  const blobURL = URL.createObjectURL(new Blob([code], { type: "text/javascript" }));
+  const esbuild = await import(
+    /* @vite-ignore */
+    blobURL
+  );
+  await esbuild.initialize({ wasmURL, worker: true });
+  globalThis.__esbuildTransform = (input, options) => esbuild.transform(input, options);
+  return esbuild;
+}
+function installOxc(oxcModule) {
+  const parseSync = oxcModule && (oxcModule.parseSync || oxcModule.default && oxcModule.default.parseSync);
+  if (typeof parseSync !== "function") {
+    throw new Error("[compiler] installOxc: expected an oxc-parser module exposing parseSync (pass `await import('oxc-parser')`)");
+  }
+  globalThis.__oxcParseSync = parseSync;
+}
+export {
+  installEsbuildFromURL,
+  installOxc
+};

package/package.json

@@ -0,0 +1,87 @@
+{
+  "name": "@dimina-kit/compiler",
+  "version": "0.0.1-dev.20260702173719",
+  "description": "dmcc compiler bundles (browser + node) that drive @dimina/compiler against a caller-injected node:fs replacement (no bundled fs)",
+  "license": "MIT",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/EchoTechFE/dimina-kit.git",
+    "directory": "packages/compiler"
+  },
+  "homepage": "https://github.com/EchoTechFE/dimina-kit/tree/main/packages/compiler#readme",
+  "bugs": {
+    "url": "https://github.com/EchoTechFE/dimina-kit/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./dist/compile-core.node.js",
+  "exports": {
+    ".": "./dist/compile-core.node.js",
+    "./browser": "./dist/compile-core.browser.js",
+    "./pool-node": "./dist/pool.node.js",
+    "./pool": "./dist/pool.browser.js",
+    "./stage-worker": "./dist/stage-worker.browser.js",
+    "./toolchain": "./dist/toolchain.browser.js",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "src",
+    "scripts"
+  ],
+  "dependencies": {
+    "@babel/parser": "^7.29.7",
+    "@vue/compiler-sfc": "^3.5.39",
+    "assert": "^2.1.0",
+    "autoprefixer": "^10.5.2",
+    "buffer": "^6.0.3",
+    "cheerio": "^1.2.0",
+    "cssnano": "^8.0.2",
+    "esbuild": "^0.28.1",
+    "estree-walker": "^3.0.3",
+    "events": "^3.3.0",
+    "htmlparser2": "^12.0.0",
+    "less": "^4.6.7",
+    "magic-string": "^0.30.21",
+    "memfs": "^4.57.8",
+    "oxc-parser": "^0.137.0",
+    "oxc-walker": "^1.0.0",
+    "path-browserify": "^1.0.1",
+    "postcss": "^8.5.15",
+    "postcss-selector-parser": "^7.1.4",
+    "sass": "^1.101.0",
+    "source-map-js": "^1.2.1",
+    "stream-browserify": "^3.0.0",
+    "util": "^0.12.5"
+  },
+  "peerDependencies": {
+    "@oxc-parser/binding-wasm32-wasi": "^0.137.0",
+    "esbuild-wasm": "^0.28.0"
+  },
+  "peerDependenciesMeta": {
+    "@oxc-parser/binding-wasm32-wasi": {
+      "optional": true
+    },
+    "esbuild-wasm": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "esbuild-wasm": "^0.28.0"
+  },
+  "scripts": {
+    "build:node": "node scripts/build-compiler.js node",
+    "build:browser": "node scripts/build-compiler.js browser",
+    "build": "pnpm run build:node && pnpm run build:browser",
+    "test:node": "node scripts/build-compiler.js node && node --import ./scripts/register-kit.js scripts/test-node.js",
+    "test:appid": "node scripts/build-compiler.js node && node --import ./scripts/register-kit.js scripts/test-appid-fallback.js",
+    "test:hardening": "node scripts/build-compiler.js node && node --import ./scripts/register-kit.js scripts/test-hardening.js",
+    "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-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"
+  }
+}

package/scripts/build-compiler.js

@@ -0,0 +1,207 @@
+import esbuild from 'esbuild'
+import { readFile } from 'node:fs/promises'
+import { fileURLToPath } from 'node:url'
+import { createRequire } from 'node:module'
+import path from 'node:path'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const root = path.resolve(__dirname, '..')
+const shim = (f) => path.join(root, 'src/shims', f)
+
+// The dart-sass package lives in dimina-kit's `dimina` submodule fe workspace.
+// Resolve it from there (instead of a machine-specific absolute path) and force
+// its pure-JS browser entry (`sass.default.js`) — NOT the node launcher.
+const kitFeRequire = createRequire(path.resolve(root, '../../dimina/fe/package.json'))
+const sassBrowserEntry = path.join(path.dirname(kitFeRequire.resolve('sass')), 'sass.default.js')
+
+// Pin the browser CSS pipeline to the SAME autoprefixer the node build / real dmcc
+// resolve at runtime. esbuild's bundler resolution would otherwise pick a different
+// autoprefixer island (10.5.2, from the dimina fe pnpm store) than node require does
+// (10.5.0, worktree-root store); the 10.5.2 one adds stray -ms- prefixes for ie 11,
+// diverging from dmcc. Anchor the resolve at the node bundle location so browser and
+// node reference use byte-identical autoprefixer + its browserslist/caniuse island.
+const nodeRuntimeRequire = createRequire(path.join(root, 'dist/compile-core.node.js'))
+const autoprefixerEntry = nodeRuntimeRequire.resolve('autoprefixer')
+
+// mode "node"    -> Layer1: validate orchestration in Node, native esbuild/oxc kept external
+// mode "browser" -> bundle everything for the browser (pure-JS + wasm toolchain)
+// Passed as argv (cross-platform; `MODE=x node ...` breaks on Windows cmd), env MODE kept as fallback.
+const MODE = process.argv[2] || process.env.MODE || 'node'
+const USE_WASM = process.env.USE_WASM === '1' || MODE === 'browser'
+
+// Append exports for functions/reset-hooks the compiler defines but does not
+// export, without touching the submodule source on disk. The reset hooks clear
+// the compiler's module-level caches so a pooled worker realm can compile more
+// than once without cross-compile contamination (see resetCompilerState).
+const exportAppend = {
+  name: 'export-append',
+  setup(build) {
+    const appends = {
+      'logic-compiler.js': '\nexport { writeCompileRes }\nexport function __resetLogicState() { processedModules.clear() }\nexport function __setEnableSourcemap(v) { enableSourcemap = !!v }\n',
+      'style-compiler.js': '\nexport function __resetStyleState() { compileRes.clear() }\n',
+      'view-compiler.js': '\nexport function __resetViewState() { compileResCache.clear(); wxsModuleRegistry.clear(); wxsFilePathMap.clear() }\n',
+      'utils.js': '\nexport function __resetAssets() { for (const k of Object.keys(assetsMap)) delete assetsMap[k] }\n',
+    }
+    build.onLoad({ filter: /(core[\\/](logic|style|view)-compiler|common[\\/]utils)\.js$/ }, async (args) => {
+      const base = path.basename(args.path)
+      const src = await readFile(args.path, 'utf8')
+      return { contents: src + (appends[base] || ''), loader: 'js' }
+    })
+  },
+}
+
+// In node mode, keep heavy/native deps external (resolved at runtime via NODE_PATH).
+// Isolate the oxc swap: in node mode, optionally replace native oxc with wasm
+// while keeping native esbuild (so any failure is attributable to oxc only).
+const USE_OXC_WASM = process.env.USE_OXC_WASM === '1'
+
+// Keep the CSS pipeline external in the node build: inlining browserslist entangles
+// its config lookup with the compiler's INJECTED fs (browserslist would walk the
+// memfs project tree instead of the real disk). External keeps browserslist on real
+// node fs. NOTE: this makes the node build resolve autoprefixer from the worktree
+// root store; to compare against true dmcc, generate the reference with
+// NODE_PATH pointed at dimina/fe/node_modules (dmcc's own 10.5.2). See dump-node-ref.
+const NODE_EXTERNAL = [
+  'esbuild', 'sass', 'less', 'postcss',
+  'autoprefixer', 'cssnano', 'cheerio', 'htmlparser2', '@vue/compiler-sfc',
+  'magic-string', 'source-map-js', 'postcss-selector-parser',
+  ...(USE_OXC_WASM ? ['@oxc-parser/wasm'] : ['oxc-parser', 'oxc-walker']),
+]
+
+const common = {
+  entryPoints: [path.join(root, 'src/compile-core.js')],
+  bundle: true,
+  format: 'esm',
+  target: ['es2022'],
+  plugins: [exportAppend],
+  logLevel: 'info',
+}
+
+const oxcWasmAlias = USE_OXC_WASM
+  ? { 'oxc-parser': shim('oxc-parser.js'), 'oxc-walker': shim('oxc-walker.js') }
+  : {}
+
+// compile-core.node.js: the injectable in-memory seam — fs is SHIMMED so the caller
+// passes a node:fs replacement (memfs). worker_threads is shimmed (isMainThread=true)
+// to skip dmcc's parentPort bootstrap since we drive the exports inline.
+const nodeShimAlias = {
+  'node:fs': shim('fs.js'),
+  'fs': shim('fs.js'),
+  'node:worker_threads': shim('worker_threads.js'),
+  ...oxcWasmAlias,
+}
+
+// pool.node.js / stage-worker.node.js: the resident Node disk pool. fs is NATIVE
+// (dmcc writes real disk staging, then publishToDist copies to outputDir) — do NOT
+// alias it. worker_threads is STILL shimmed so dmcc's own `if(!isMainThread)` parentPort
+// bootstrap stays OFF (otherwise its handler would race ours on the same port); the pool
+// and stage worker reach the REAL Worker/parentPort via createRequire (bypasses this alias).
+const nodeNativeAlias = {
+  'node:worker_threads': shim('worker_threads.js'),
+  ...oxcWasmAlias,
+}
+
+let opts
+if (MODE === 'node') {
+  opts = {
+    ...common,
+    platform: 'node',
+    external: NODE_EXTERNAL,
+  }
+} else {
+  const alias = {
+    'node:fs': shim('fs.js'),
+    'fs': shim('fs.js'),
+    'node:fs/promises': shim('fs-promises.js'),
+    'fs/promises': shim('fs-promises.js'),
+    'node:os': shim('os.js'),
+    'os': shim('os.js'),
+    'node:process': shim('process.js'),
+    'process': shim('process.js'),
+    'node:url': shim('url.js'),
+    'url': shim('url.js'),
+    'node:worker_threads': shim('worker_threads.js'),
+    'node:path': 'path-browserify',
+    'path': 'path-browserify',
+    'node:events': 'events',
+    'node:buffer': 'buffer',
+    'node:stream': 'stream-browserify',
+    'stream': 'stream-browserify',
+    'node:util': 'util',
+    'node:assert': 'assert',
+    'less': shim('less.js'),
+    // force the pure-JS (browser) sass entry, not the node launcher
+    'sass': sassBrowserEntry,
+    // force esbuild-wasm's browser ESM build (not the node build)
+    'esbuild-wasm': path.join(root, 'node_modules/esbuild-wasm/esm/browser.js'),
+  }
+  // CSS pipeline: by default bundle the REAL autoprefixer + cssnano (same versions
+  // as the node/dmcc build) so the browser CSS output is byte-identical to dmcc.
+  // They pull browserslist + caniuse-lite, which only need process.env (already in
+  // the banner) since the compiler passes overrideBrowserslist and skips config
+  // lookup. Set REAL_CSS=0 to fall back to the old no-op shims (CSS left un-minified).
+  if (process.env.REAL_CSS === '0') {
+    alias['autoprefixer'] = shim('postcss-noop-plugin.js')
+    alias['cssnano'] = shim('postcss-noop-plugin.js')
+  } else {
+    // pin autoprefixer to the node/dmcc-resolved copy (see above)
+    alias['autoprefixer'] = autoprefixerEntry
+  }
+  if (USE_WASM) {
+    alias['esbuild'] = shim('esbuild-wasm.js')
+    alias['oxc-parser'] = shim('oxc-parser.js')
+    alias['oxc-walker'] = shim('oxc-walker.js')
+  }
+  opts = {
+    ...common,
+    platform: 'browser',
+    format: 'esm',
+    alias,
+    define: {
+      'process.env.NODE_ENV': '"production"',
+      // some postcss plugins reference __filename/__dirname for source locations;
+      // esbuild's browser platform leaves them undefined, so provide stable stubs.
+      '__filename': '"/index.js"',
+      '__dirname': '"/"',
+    },
+    // Tiny process shim — env + cwd only. NO process.versions.node, so dart-sass,
+    // esbuild-wasm and the Go wasm runtime still detect a browser env; cwd is needed
+    // by browserslist (real autoprefixer/cssnano) and is safe to expose.
+    banner: {
+      js: [
+        'globalThis.global ||= globalThis;',
+        'globalThis.process ||= { env: {}, cwd: () => "/" };',
+        'globalThis.process.cwd ||= () => "/";',
+      ].join('\n'),
+    },
+  }
+}
+
+// Browser mode ships three bundles from the same config: the core seams
+// (compile-core.browser.js), the package's resident stage worker
+// (stage-worker.browser.js, bundles the compiler + memfs), and the light-weight
+// orchestrated pool (pool.browser.js). Node mode ships only the core.
+const outputs = MODE === 'node'
+  ? [
+      { in: 'src/compile-core.js', out: 'dist/compile-core.node.js', alias: nodeShimAlias },
+      // Resident Node worker_threads disk pool (real fs, dmcc-parity output + sourcemap).
+      { in: 'src/pool-node.js', out: 'dist/pool.node.js', alias: nodeNativeAlias },
+      { in: 'src/stage-worker-node.js', out: 'dist/stage-worker.node.js', alias: nodeNativeAlias },
+    ]
+  : [
+      { in: 'src/browser-entry.js', out: 'dist/compile-core.browser.js' },
+      { in: 'src/stage-worker.js', out: 'dist/stage-worker.browser.js' },
+      { in: 'src/pool.js', out: 'dist/pool.browser.js' },
+      { in: 'src/toolchain.js', out: 'dist/toolchain.browser.js' },
+    ]
+
+for (const o of outputs) {
+  const built = {
+    ...opts,
+    entryPoints: [path.join(root, o.in)],
+    outfile: path.join(root, o.out),
+    ...(o.alias ? { alias: o.alias } : {}),
+  }
+  await esbuild.build(built)
+  console.log(`✅ built MODE=${MODE} USE_WASM=${USE_WASM ? 1 : 0} -> ${o.out}`)
+}

package/scripts/gen-bench-fixture.js

@@ -0,0 +1,24 @@
+// Emit an example's text source as a flat {relPath: content} JSON so the browser
+// benchmark can seed each fs backend without a bundler.
+//   usage: node gen-bench-fixture.js <dest.json> [example=base]
+import { readdirSync, readFileSync, statSync, writeFileSync } from 'node:fs'
+import { fileURLToPath } from 'node:url'
+import path from 'node:path'
+
+const EXAMPLE = process.argv[3] || 'base'
+const APP = fileURLToPath(new URL(`../../../dimina/fe/example/${EXAMPLE}`, import.meta.url))
+const TEXT = new Set(['.json', '.js', '.ts', '.wxml', '.ddml', '.wxss', '.ddss', '.less', '.scss', '.sass', '.wxs', '.dds', '.css'])
+const out = {}
+;(function rd(d, b) {
+  for (const n of readdirSync(d)) {
+    if (n === 'node_modules' || n === '.git') continue
+    const f = path.join(d, n)
+    if (statSync(f).isDirectory()) rd(f, b)
+    else if (TEXT.has(path.extname(n).toLowerCase())) out[path.relative(b, f).split(path.sep).join('/')] = readFileSync(f, 'utf8')
+  }
+})(APP, APP)
+
+const dest = process.argv[2]
+if (!dest) throw new Error('usage: node gen-bench-fixture.js <dest.json>')
+writeFileSync(dest, JSON.stringify(out))
+console.log(`fixture: ${Object.keys(out).length} files -> ${dest}`)

package/scripts/kit-resolve-hook.js

@@ -0,0 +1,35 @@
+// ESM resolve hook: resolve bare external specifiers from dimina-kit's node_modules
+// (Layer 1 node test only; the browser bundle inlines everything).
+import { createRequire, isBuiltin } from 'node:module'
+import { pathToFileURL } from 'node:url'
+
+// Resolve bare deps from the dimina-kit workspace root node_modules relative to
+// this file, not a machine-specific path.
+const kitRequire = createRequire(new URL('../../../package.json', import.meta.url))
+
+function isBare(spec) {
+  return !spec.startsWith('.') && !spec.startsWith('/')
+    && !spec.startsWith('node:') && !spec.includes('://')
+    && !isBuiltin(spec)
+}
+
+export async function resolve(specifier, context, next) {
+  if (isBare(specifier)) {
+    // Try normal resolution FIRST so packages reachable from the importer (e.g. memfs
+    // and its CJS deps) load with their own correct versions and CJS/ESM interop. Only
+    // when the default can't find a bare dep — the compiler's externals
+    // (sass/less/oxc/esbuild…) that live in the kit workspace root, not next to this
+    // bundle — fall back to kit-root resolution.
+    try {
+      return await next(specifier, context)
+    } catch {
+      try {
+        const p = kitRequire.resolve(specifier)
+        return { url: pathToFileURL(p).href, shortCircuit: true }
+      } catch {
+        // fall through to the default's own error below
+      }
+    }
+  }
+  return next(specifier, context)
+}

package/scripts/register-kit.js

@@ -0,0 +1,2 @@
+import { register } from 'node:module'
+register('./kit-resolve-hook.js', import.meta.url)

package/scripts/test-appid-fallback.js

@@ -0,0 +1,114 @@
+// Guards that compileMiniApp always returns a usable appId, even when the
+// project does not include a project.config.json with an explicit appid field.
+// A missing/undefined appId would silently corrupt downstream resource paths
+// (container ?appId= query string, file path prefixes) with no error thrown.
+
+import assert from 'node:assert/strict'
+import { Volume, createFsFromVolume } from 'memfs'
+import { compileMiniApp } from '../dist/compile-core.node.js'
+
+// web-compiler carries no fs; the caller injects one. memfs stands in as the
+// downstream fs here — seed a files map at workPath and hand over its fs.
+const WP = '/work'
+const fsOf = (files) => createFsFromVolume(Volume.fromJSON(files, WP))
+
+// Minimal valid mini-program with no project.config.json.
+const MINIMAL_FILES = {
+  'app.js': 'App({})',
+  'app.json': JSON.stringify({ pages: ['pages/index'] }),
+  'pages/index.js': 'Page({ data: {} })',
+  'pages/index.wxml': '<view>hello</view>',
+}
+
+// A project that carries an explicit appid in project.config.json.
+const EXPLICIT_APPID = 'wxTESTappid123456'
+const FILES_WITH_CONFIG = {
+  ...MINIMAL_FILES,
+  'project.config.json': JSON.stringify({
+    appid: EXPLICIT_APPID,
+    compileType: 'miniprogram',
+    setting: { es6: true },
+  }),
+}
+
+let passed = 0
+let failed = 0
+
+function ok(label, fn) {
+  try {
+    fn()
+    console.log(`  ✅ PASS  ${label}`)
+    passed++
+  } catch (err) {
+    console.error(`  ❌ FAIL  ${label}`)
+    console.error(`         ${err.message}`)
+    failed++
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Group 1: No project.config.json — appId must be a non-empty string and must
+// not appear as the literal text "undefined" in any output file path.
+// ---------------------------------------------------------------------------
+console.log('\nGroup 1: no project.config.json → appId must be a usable non-empty string')
+
+const r1 = await compileMiniApp({ fs: fsOf(MINIMAL_FILES), workPath: WP })
+console.log(`  actual appId = ${JSON.stringify(r1.appId)}`)
+
+ok('appId is a string', () => {
+  assert.equal(typeof r1.appId, 'string', `expected string, got ${typeof r1.appId}`)
+})
+
+ok('appId is non-empty', () => {
+  assert.ok(r1.appId.length > 0, 'appId must not be an empty string')
+})
+
+ok('appId is not the literal "undefined"', () => {
+  assert.notEqual(r1.appId, 'undefined', 'appId must not be the string "undefined"')
+})
+
+const keysWithUndefined = Object.keys(r1.files).filter((k) => k.includes('undefined'))
+ok('output file paths contain no "undefined" segment', () => {
+  assert.deepEqual(
+    keysWithUndefined,
+    [],
+    `These output paths contain "undefined": ${JSON.stringify(keysWithUndefined)}`,
+  )
+})
+
+// ---------------------------------------------------------------------------
+// Group 2: Determinism — same input twice must yield identical appId values.
+// ---------------------------------------------------------------------------
+console.log('\nGroup 2: determinism — same input produces the same appId on repeated calls')
+
+const r2a = await compileMiniApp({ fs: fsOf(MINIMAL_FILES), workPath: WP })
+const r2b = await compileMiniApp({ fs: fsOf(MINIMAL_FILES), workPath: WP })
+console.log(`  call-1 appId = ${JSON.stringify(r2a.appId)}`)
+console.log(`  call-2 appId = ${JSON.stringify(r2b.appId)}`)
+
+ok('appId is stable across two calls with the same input', () => {
+  assert.equal(r2a.appId, r2b.appId, 'appId must be deterministic for the same input')
+})
+
+// ---------------------------------------------------------------------------
+// Group 3: Explicit appid — project.config.json.appid takes precedence and
+// must be forwarded verbatim. Existing behaviour must not regress.
+// ---------------------------------------------------------------------------
+console.log('\nGroup 3: explicit appid in project.config.json is returned verbatim')
+
+const r3 = await compileMiniApp({ fs: fsOf(FILES_WITH_CONFIG), workPath: WP })
+console.log(`  actual appId = ${JSON.stringify(r3.appId)}`)
+
+ok(`appId equals the declared "${EXPLICIT_APPID}"`, () => {
+  assert.equal(r3.appId, EXPLICIT_APPID)
+})
+
+// ---------------------------------------------------------------------------
+// Summary
+// ---------------------------------------------------------------------------
+console.log(`\n${'─'.repeat(60)}`)
+console.log(`Results: ${passed} passed, ${failed} failed`)
+if (failed > 0) {
+  process.exit(1)
+}
+console.log('All assertions passed.')

package/scripts/test-decompose.js

@@ -0,0 +1,90 @@
+// Decomposed-path test: drive the parallel seams directly — setupCompile once,
+// then each stage (logic/view/style) on its own, then collectOutputs — the exact
+// call shape the parallel worker pipeline uses (minus the multi-realm split, which
+// Phase 3's real workers add). Proves two things Phase 3 relies on:
+//   1. the seams are callable directly (not only through compileMiniApp), and
+//   2. each stage writes ONLY its own products (disjoint outputs) — the invariant
+//      that lets stages run concurrently over one shared fs.
+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/base', 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 {
+      const rel = path.relative(baseDir, full).split(path.sep).join('/')
+      if (TEXT_EXT.has(path.extname(name).toLowerCase())) out[rel] = readFileSync(full, 'utf8')
+    }
+  }
+}
+
+let failed = 0
+function check(cond, msg) {
+  if (cond) console.log(`  ✅ ${msg}`)
+  else { console.log(`  ❌ ${msg}`); failed++ }
+}
+
+const files = {}
+readDir(APP, APP, files)
+console.log(`[seed] ${Object.keys(files).length} text files from ${APP}`)
+
+const {
+  setupCompile, compileStage, collectOutputs, STAGE_NAMES,
+} = await import('../dist/compile-core.node.js')
+
+const workPath = '/work'
+const fs = createFsFromVolume(Volume.fromJSON(files, workPath))
+
+// --- setup once ---
+const ctx = await setupCompile({ fs, workPath })
+console.log(`\n[setup] appId=${ctx.appId} name=${ctx.name} target=${ctx.targetPath}`)
+check(STAGE_NAMES.join(',') === 'logic,view,style', `STAGE_NAMES = [${STAGE_NAMES}]`)
+check(typeof ctx.storeInfo === 'object' && !!ctx.pages, 'setupCompile returns { storeInfo, pages }')
+
+const cssCount = (m) => Object.keys(m).filter((k) => k.endsWith('.css')).length
+const jsCount = (m) => Object.keys(m).filter((k) => k.endsWith('.js')).length
+
+const stageArgs = { pages: ctx.pages, storeInfo: ctx.storeInfo, fs }
+
+// --- logic only: main/logic.js appears; no styles yet ---
+await compileStage({ stage: 'logic', ...stageArgs })
+const afterLogic = collectOutputs({ fs, targetPath: ctx.targetPath })
+console.log(`\n[after logic] ${Object.keys(afterLogic).length} files, js=${jsCount(afterLogic)} css=${cssCount(afterLogic)}`)
+check('main/logic.js' in afterLogic, 'logic stage wrote main/logic.js')
+check(cssCount(afterLogic) === 0, 'logic stage wrote NO .css (style stage untouched)')
+
+// --- view: page view scripts appear; still no styles ---
+await compileStage({ stage: 'view', ...stageArgs })
+const afterView = collectOutputs({ fs, targetPath: ctx.targetPath })
+console.log(`[after view]  ${Object.keys(afterView).length} files, js=${jsCount(afterView)} css=${cssCount(afterView)}`)
+check(jsCount(afterView) > jsCount(afterLogic), 'view stage added page view .js files')
+check(cssCount(afterView) === 0, 'view stage wrote NO .css (style stage untouched)')
+
+// --- style: .css appears now ---
+await compileStage({ stage: 'style', ...stageArgs })
+const out = collectOutputs({ fs, targetPath: ctx.targetPath })
+console.log(`[after style] ${Object.keys(out).length} files, js=${jsCount(out)} css=${cssCount(out)}`)
+check(cssCount(out) > 0, 'style stage wrote .css files')
+
+// --- full artifact set (same expectations as test-node) ---
+for (const n of ['main/logic.js', 'main/app-config.json']) {
+  check(n in out && out[n].length > 0, `output has non-empty ${n}`)
+}
+check(out['main/logic.js'].startsWith('modDefine('), 'main/logic.js starts with modDefine(')
+
+console.log(`\n────────────────────────────────────────────────────────`)
+if (failed) { console.error(`❌ ${failed} decompose assertion(s) failed.`); process.exit(1) }
+console.log('✅ Decomposed seams work independently; stages write disjoint products.')