@dimina-kit/compiler 0.0.1-dev.20260707110006 → 0.0.2-dev.20260710085051

package/dist/compile-core.browser.js

@@ -90457,9 +90457,9 @@ var require_dist3 = __commonJS({
   }
 });
 
-// ../../dimina/fe/node_modules/.pnpm/node-releases@2.0.50/node_modules/node-releases/data/processed/envs.json
+// ../../dimina/fe/node_modules/.pnpm/node-releases@2.0.51/node_modules/node-releases/data/processed/envs.json
 var require_envs2 = __commonJS({
-  "../../dimina/fe/node_modules/.pnpm/node-releases@2.0.50/node_modules/node-releases/data/processed/envs.json"(exports, module) {
+  "../../dimina/fe/node_modules/.pnpm/node-releases@2.0.51/node_modules/node-releases/data/processed/envs.json"(exports, module) {
     module.exports = [
       {
         name: "nodejs",
@@ -93420,6 +93420,14 @@ var require_envs2 = __commonJS({
         lts: false,
         security: false,
         v8: "14.6.202.34"
+      },
+      {
+        name: "nodejs",
+        version: "26.5.0",
+        date: "2026-07-08",
+        lts: false,
+        security: false,
+        v8: "14.6.202.34"
       }
     ];
   }
@@ -93509,9 +93517,9 @@ var require_agents4 = __commonJS({
   }
 });
 
-// ../../dimina/fe/node_modules/.pnpm/electron-to-chromium@1.5.388/node_modules/electron-to-chromium/versions.js
+// ../../dimina/fe/node_modules/.pnpm/electron-to-chromium@1.5.389/node_modules/electron-to-chromium/versions.js
 var require_versions2 = __commonJS({
-  "../../dimina/fe/node_modules/.pnpm/electron-to-chromium@1.5.388/node_modules/electron-to-chromium/versions.js"(exports, module) {
+  "../../dimina/fe/node_modules/.pnpm/electron-to-chromium@1.5.389/node_modules/electron-to-chromium/versions.js"(exports, module) {
     module.exports = {
       "0.20": "39",
       "0.21": "41",
@@ -93771,14 +93779,15 @@ var require_versions2 = __commonJS({
       "42.5": "148",
       "42.6": "148",
       "43.0": "150",
+      "43.1": "150",
       "44.0": "151"
     };
   }
 });
 
-// ../../dimina/fe/node_modules/.pnpm/node-releases@2.0.50/node_modules/node-releases/data/release-schedule/release-schedule.json
+// ../../dimina/fe/node_modules/.pnpm/node-releases@2.0.51/node_modules/node-releases/data/release-schedule/release-schedule.json
 var require_release_schedule2 = __commonJS({
-  "../../dimina/fe/node_modules/.pnpm/node-releases@2.0.50/node_modules/node-releases/data/release-schedule/release-schedule.json"(exports, module) {
+  "../../dimina/fe/node_modules/.pnpm/node-releases@2.0.51/node_modules/node-releases/data/release-schedule/release-schedule.json"(exports, module) {
     module.exports = {
       "v0.8": {
         start: "2012-06-25",
@@ -282555,8 +282564,8 @@ function compileMiniApp(opts = {}) {
   });
   return result2;
 }
-async function runCompile({ fs: fs2, workPath = "/work" } = {}) {
-  const ctx = await setupCompile({ fs: fs2, workPath });
+async function runCompile({ fs: fs2, workPath = "/work", options = {} } = {}) {
+  const ctx = await setupCompile({ fs: fs2, workPath, options });
   const { storeInfo: bundle, pages, appId, name, targetPath } = ctx;
   await compileStage({ stage: "logic", pages, storeInfo: bundle, fs: fs2 });
   await compileStage({ stage: "view", pages, storeInfo: bundle, fs: fs2 });

package/dist/compile-core.node.js

@@ -477,8 +477,8 @@ function compileMiniApp(opts = {}) {
   });
   return result;
 }
-async function runCompile({ fs, workPath = "/work" } = {}) {
-  const ctx = await setupCompile({ fs, workPath });
+async function runCompile({ fs, workPath = "/work", options = {} } = {}) {
+  const ctx = await setupCompile({ fs, workPath, options });
   const { storeInfo: bundle, pages, appId, name, targetPath } = ctx;
   await compileStage({ stage: "logic", pages, storeInfo: bundle, fs });
   await compileStage({ stage: "view", pages, storeInfo: bundle, fs });

package/dist/pool.browser.js

@@ -252,9 +252,9 @@ function createCompilerPool(options = {}) {
   function warmup() {
     return settleAll(workers.map(ensureWarm));
   }
-  async function runAttempt(files, workPath) {
+  async function runAttempt(files, workPath, options2) {
     await settleAll(workers.map(ensureWarm));
-    const s = await requestChecked(workers[0], { type: "setup", files, workPath, wantHeartbeat: true }, "setup", sendTimeoutMs);
+    const s = await requestChecked(workers[0], { type: "setup", files, workPath, options: options2, wantHeartbeat: true }, "setup", sendTimeoutMs);
     const { bundle, scaffold } = s;
     const parts = await settleAll(workers.map((x) => requestChecked(x, { type: "compile-subset", files, workPath, stages: [x.stage], bundle, wantHeartbeat: true }, "compile-subset", sendTimeoutMs)));
     const merged = { ...scaffold || {} };
@@ -271,14 +271,15 @@ function createCompilerPool(options = {}) {
       }
       const files = input.files || input;
       if (!files || typeof files !== "object" || !Object.keys(files).length) {
-        throw new Error("[compiler] pool.compile expects { files: { relPath: content }, workPath? } (or a non-empty files map)");
+        throw new Error("[compiler] pool.compile expects { files: { relPath: content }, workPath?, options? } (or a non-empty files map)");
       }
       const workPath = input.workPath || defaultWorkPath;
+      const options2 = input.options || {};
       try {
-        return await runAttempt(files, workPath);
+        return await runAttempt(files, workPath, options2);
       } catch (err) {
         if (!retryOnWorkerDeath || !err || !WORKER_DEATH_CODES.has(err.code)) throw err;
-        return await runAttempt(files, workPath);
+        return await runAttempt(files, workPath, options2);
       }
     });
     chain = run.then(() => {

package/dist/stage-worker.browser.js

@@ -104394,9 +104394,9 @@ var require_dist3 = __commonJS({
   }
 });
 
-// ../../dimina/fe/node_modules/.pnpm/node-releases@2.0.50/node_modules/node-releases/data/processed/envs.json
+// ../../dimina/fe/node_modules/.pnpm/node-releases@2.0.51/node_modules/node-releases/data/processed/envs.json
 var require_envs2 = __commonJS({
-  "../../dimina/fe/node_modules/.pnpm/node-releases@2.0.50/node_modules/node-releases/data/processed/envs.json"(exports, module) {
+  "../../dimina/fe/node_modules/.pnpm/node-releases@2.0.51/node_modules/node-releases/data/processed/envs.json"(exports, module) {
     module.exports = [
       {
         name: "nodejs",
@@ -107357,6 +107357,14 @@ var require_envs2 = __commonJS({
         lts: false,
         security: false,
         v8: "14.6.202.34"
+      },
+      {
+        name: "nodejs",
+        version: "26.5.0",
+        date: "2026-07-08",
+        lts: false,
+        security: false,
+        v8: "14.6.202.34"
       }
     ];
   }
@@ -107446,9 +107454,9 @@ var require_agents4 = __commonJS({
   }
 });
 
-// ../../dimina/fe/node_modules/.pnpm/electron-to-chromium@1.5.388/node_modules/electron-to-chromium/versions.js
+// ../../dimina/fe/node_modules/.pnpm/electron-to-chromium@1.5.389/node_modules/electron-to-chromium/versions.js
 var require_versions2 = __commonJS({
-  "../../dimina/fe/node_modules/.pnpm/electron-to-chromium@1.5.388/node_modules/electron-to-chromium/versions.js"(exports, module) {
+  "../../dimina/fe/node_modules/.pnpm/electron-to-chromium@1.5.389/node_modules/electron-to-chromium/versions.js"(exports, module) {
     module.exports = {
       "0.20": "39",
       "0.21": "41",
@@ -107708,14 +107716,15 @@ var require_versions2 = __commonJS({
       "42.5": "148",
       "42.6": "148",
       "43.0": "150",
+      "43.1": "150",
       "44.0": "151"
     };
   }
 });
 
-// ../../dimina/fe/node_modules/.pnpm/node-releases@2.0.50/node_modules/node-releases/data/release-schedule/release-schedule.json
+// ../../dimina/fe/node_modules/.pnpm/node-releases@2.0.51/node_modules/node-releases/data/release-schedule/release-schedule.json
 var require_release_schedule2 = __commonJS({
-  "../../dimina/fe/node_modules/.pnpm/node-releases@2.0.50/node_modules/node-releases/data/release-schedule/release-schedule.json"(exports, module) {
+  "../../dimina/fe/node_modules/.pnpm/node-releases@2.0.51/node_modules/node-releases/data/release-schedule/release-schedule.json"(exports, module) {
     module.exports = {
       "v0.8": {
         start: "2012-06-25",
@@ -291679,10 +291688,10 @@ function needsToolchain(stages) {
 function freshFs(files, workPath) {
   return (0, import_memfs.createFsFromVolume)(import_memfs.Volume.fromJSON(files, workPath));
 }
-async function runSetup(files, workPath) {
+async function runSetup(files, workPath, options) {
   const fs2 = freshFs(files, workPath);
   resetCompilerState();
-  const ctx = await setupCompile({ fs: fs2, workPath });
+  const ctx = await setupCompile({ fs: fs2, workPath, options });
   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];
@@ -291695,7 +291704,7 @@ async function runSetup(files, workPath) {
   };
   return { bundle, scaffold };
 }
-async function compileSubset(files, workPath, stages, bundle) {
+async function compileSubset(files, workPath, stages, bundle, options) {
   const fs2 = freshFs(files, workPath);
   resetCompilerState();
   let appId, name, targetPath;
@@ -291706,7 +291715,7 @@ async function compileSubset(files, workPath, stages, bundle) {
     ;
     ({ appId, name, targetPath } = bundle);
   } else {
-    const ctx = await setupCompile({ fs: fs2, workPath });
+    const ctx = await setupCompile({ fs: fs2, workPath, options });
     for (const stage of stages) {
       await compileStage({ stage, pages: ctx.pages, storeInfo: ctx.storeInfo, fs: fs2 });
     }
@@ -291743,21 +291752,21 @@ self.onmessage = async (e) => {
       return;
     }
     if (type === "setup") {
-      const { files, workPath = "/work", toolchainSetupURL } = e.data;
+      const { files, workPath = "/work", options, toolchainSetupURL } = e.data;
       if (toolchainSetupURL) toolchainURL = toolchainSetupURL;
       await ensureToolchain();
       const t = performance.now();
-      const { bundle, scaffold } = await runSetup(files, workPath);
+      const { bundle, scaffold } = await runSetup(files, workPath, options);
       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"], bundle, toolchainSetupURL } = e.data;
+      const { files, workPath = "/work", stages = ["logic", "view", "style"], bundle, options, 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, bundle);
+      const result2 = await compileSubset(files, workPath, stages, bundle, options);
       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.20260707110006",
+  "version": "0.0.2-dev.20260710085051",
   "description": "dmcc compiler bundles (browser + node) that drive @dimina/compiler against a caller-injected node:fs replacement (no bundled fs)",
   "license": "MIT",
   "type": "module",
@@ -93,6 +93,7 @@
     "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",
     "test:stage-worker-message-order": "node scripts/build-compiler.js node && node scripts/test-stage-worker-message-order.js",
-    "test:stage-load-retry": "node scripts/build-compiler.js node && node scripts/test-stage-load-retry.js"
+    "test:stage-load-retry": "node scripts/build-compiler.js node && node scripts/test-stage-load-retry.js",
+    "test:pool-filetypes": "node scripts/build-compiler.js node && node scripts/build-compiler.js browser && node scripts/test-pool-filetypes.js"
   }
 }

package/scripts/test-pool-filetypes.js

@@ -0,0 +1,159 @@
+// Red/green coverage for `options.fileTypes` (custom template/style/view-script
+// dialect, e.g. .qdml/.qdss/.qds) reaching the browser pool's compile protocol.
+//
+// dmcc's env.js already normalizes options.fileTypes into a `compilerOptions`
+// bundle inside storeInfo (dimina/fe/packages/compiler/src/env.js:91-120), and
+// that bundle rides inside bundle.storeInfo through the setup->compile-subset
+// broadcast (compile-core.js's compileStage -> resetStoreInfo, env.js:122-132) —
+// see src/pool.js's runAttempt and src/stage-worker.js's runSetup/compileSubset.
+// This test drives the REAL browser bundles (dist/pool.browser.js +
+// dist/stage-worker.browser.js) in Node, so it fails (red) without the
+// options-threading fix and passes (green) with it — no reimplementation of the
+// protocol handlers under test.
+//
+// Fixture mirrors qdmp's e2e "qd-app" (see
+// ~/code/qdmp/main/packages/qdmp-devtools/e2e/qd-app): a page using .qdml/.qdss/.qds
+// instead of .wxml/.wxss/.wxs, with a <wxs src="./index.qds" module="m" /> view
+// script and a `{{ m.shout(title) }}` mustache expression — so a correct compile
+// must recognize the custom template AND the custom view-script extension.
+//
+// Also covers compile-core.js's compileMiniApp (the one-shot worker entry point)
+// at the bottom, since it shares the exact same options-threading gap.
+
+// Warm real esbuild/oxc-parser module eval AND esbuild's long-lived service child
+// process with the REAL process object BEFORE masking (below) — the service, once
+// spawned, is reused for later transforms even under a masked process, so this
+// must run first.
+import { transform } from 'esbuild'
+import 'oxc-parser'
+
+await transform('const __warm = 1', {})
+
+// dart-sass's bundled browser shim checks process.versions.node at module-eval
+// time (only reached once the lazily-loaded style-compiler chunk imports it) —
+// masking to a browser-shaped stub makes it take the browser branch instead of
+// crashing on `Dynamic require of "url" is not supported` (see
+// scripts/test-stage-toolchain.js for the same technique). Saved so PART B below
+// (a Node-target bundle, which needs the real process — its transitive deps
+// module-eval-check process.versions.node too) can restore it.
+const realProcess = globalThis.process
+globalThis.process = { env: {}, cwd: () => '/' }
+
+const WORKER_URL = new URL('../dist/stage-worker.browser.js', import.meta.url).href
+const TOOLCHAIN_URL = new URL('./toolchain-setup-node-native.js', import.meta.url).href
+const WORK_PATH = '/work'
+
+const FIXTURE_FILES = {
+  'app.json': JSON.stringify({ pages: ['pages/index/index'], window: { navigationBarTitleText: 'QD Ext Demo' } }),
+  'project.config.json': JSON.stringify({ appid: 'qd_ext_demo_001', projectname: 'qd-ext-demo' }),
+  'app.js': "App({\n  onLaunch() {\n    console.log('[QDExt] App launched')\n  },\n})\n",
+  'pages/index/index.js': "Page({\n  data: {\n    title: 'QD Extensions',\n    count: 3,\n  },\n})\n",
+  'pages/index/index.qdss': '.qd-box {\n  padding: 20rpx;\n}\n\n.qd-title {\n  font-size: 36rpx;\n  color: #4A90D9;\n}\n\n.qd-item {\n  font-size: 28rpx;\n  color: #333;\n}\n',
+  'pages/index/index.qdml': '<wxs src="./index.qds" module="m" />\n<view class="qd-box">\n  <view class="qd-title" id="qd-title">{{ m.shout(title) }}</view>\n  <view class="qd-item" wx:for="{{count}}" wx:key="*this">item-{{item}}</view>\n</view>\n',
+  'pages/index/index.json': JSON.stringify({ navigationBarTitleText: 'QD Ext Index' }),
+  'pages/index/index.qds': "function shout(text) {\n  return text + '!'\n}\n\nmodule.exports = {\n  shout: shout,\n}\n",
+}
+const FILE_TYPES_OPTIONS = { fileTypes: { template: ['qdml'], style: ['qdss'], viewScript: ['qds'] } }
+
+let failed = false
+const chk = (cond, msg) => { if (!cond) { failed = true; console.error(`❌ ${msg}`) } else console.log(`✅ ${msg}`) }
+
+// Real page module: exists, non-empty, and carries the compiled .qds wxs module
+// (`shout`) plus the compiled .qdml view (`qd-title`) — the assertion this whole
+// test hinges on. Without options.fileTypes this is guaranteed to fail (the
+// custom extensions are unrecognized, so the page template/view-script are never
+// found), which is exactly the RED this test protects against regressing to.
+function pageModuleIsCompiled(files) {
+  const js = files && files['main/pages_index_index.js']
+  return typeof js === 'string' && js.length > 0 && js.includes('shout') && js.includes('qd-title')
+}
+
+// --- PART A: real browser pool (dist/pool.browser.js + dist/stage-worker.browser.js) ---
+//
+// Each stage worker is its own dynamically-imported module instance (own closure
+// state, mirroring a real Web Worker realm); ALL of them funnel through one shared
+// `chain` so only one is ever "in flight" at a time. This matters because the
+// worker module resolves the bare `self` identifier against whatever
+// `globalThis.self` currently is (see test-stage-toolchain.js's note on the same
+// mechanism) — serializing every send means no two realms' async continuations
+// can ever race over that shared global.
+let chain = Promise.resolve()
+let instanceCounter = 0
+async function makeStageWorker() {
+  const worker = { onmessage: null, onerror: null, terminate() {} }
+  const fakeSelf = {
+    onmessage: null,
+    postMessage(msg) { if (worker.onmessage) worker.onmessage({ data: msg }) },
+  }
+  globalThis.self = fakeSelf
+  instanceCounter += 1
+  await import(`${WORKER_URL}?n=${instanceCounter}`)
+  // stage-worker.js does `self.onmessage = async (e) => {...}` at module top level
+  // against whatever `globalThis.self` was AT IMPORT TIME — capture it now.
+  const boundOnMessage = fakeSelf.onmessage
+  worker.postMessage = (msg) => {
+    chain = chain.then(async () => {
+      globalThis.self = fakeSelf
+      try {
+        await boundOnMessage({ data: msg })
+      } catch (err) {
+        // The real handler already catches internally and posts { type:'error' };
+        // an escaping exception would mean it threw before its own try, so surface
+        // it the same way rather than hanging the pool's pending request forever.
+        fakeSelf.postMessage({ type: 'error', error: String((err && err.stack) || err) })
+      }
+    })
+  }
+  return worker
+}
+
+const { createCompilerPool } = await import('../dist/pool.browser.js')
+
+// One pool, pre-spawned with exactly the 3 default-stage workers this test needs
+// (no crash/respawn expected) — createWorker must be synchronous (pool.js calls it
+// inline), so every worker instance is built up front and handed out from a queue.
+const stageWorkers = []
+for (const stage of ['logic', 'view', 'style']) stageWorkers.push(await makeStageWorker())
+let nextWorker = 0
+const pool = createCompilerPool({
+  createWorker: () => stageWorkers[nextWorker++],
+  toolchainSetupURL: TOOLCHAIN_URL,
+})
+
+const withoutOptions = await pool.compile({ files: FIXTURE_FILES, workPath: WORK_PATH })
+chk(!pageModuleIsCompiled(withoutOptions.files),
+  'PART A (pool.js + stage-worker.js): WITHOUT options.fileTypes, the .qdml/.qdss/.qds page module is NOT compiled '
+  + `(demonstrates the gap this feature closes; got main/pages_index_index.js=${JSON.stringify(withoutOptions.files['main/pages_index_index.js'])})`)
+
+const withOptions = await pool.compile({ files: FIXTURE_FILES, workPath: WORK_PATH, options: FILE_TYPES_OPTIONS })
+chk(pageModuleIsCompiled(withOptions.files),
+  'PART A (pool.js + stage-worker.js): WITH options.fileTypes, the .qdml/.qdss/.qds page module IS compiled and non-empty '
+  + `(main/pages_index_index.js length=${(withOptions.files['main/pages_index_index.js'] || '').length})`)
+chk(withOptions.appId === 'qd_ext_demo_001', `PART A: compiled appId matches project.config.json (got ${withOptions.appId})`)
+const compiledCss = withOptions.files['main/pages_index_index.css'] || ''
+chk(compiledCss.includes('qd-title'), `PART A: .qdss style file compiled into page CSS (got ${JSON.stringify(compiledCss)})`)
+
+await pool.dispose()
+
+// --- PART B: compile-core.js's compileMiniApp (one-shot worker entry point) ---
+// Same options-threading gap, covered directly at the compile-core level (no
+// pool/worker-protocol involved) so a future pool refactor still has this pinned
+// independently of the browser-pool wiring above. This is the NODE-target bundle
+// (dist/compile-core.node.js), whose deps expect a real `process` — restore it
+// before importing.
+globalThis.process = realProcess
+const { compileMiniApp } = await import('../dist/compile-core.node.js')
+const { Volume, createFsFromVolume } = await import('memfs')
+const freshFs = () => createFsFromVolume(Volume.fromJSON(FIXTURE_FILES, WORK_PATH))
+
+const coreWithout = await compileMiniApp({ fs: freshFs(), workPath: WORK_PATH })
+chk(!pageModuleIsCompiled(coreWithout.files),
+  'PART B (compile-core.js compileMiniApp): WITHOUT options.fileTypes, page module NOT compiled')
+
+const coreWith = await compileMiniApp({ fs: freshFs(), workPath: WORK_PATH, options: FILE_TYPES_OPTIONS })
+chk(pageModuleIsCompiled(coreWith.files),
+  'PART B (compile-core.js compileMiniApp): WITH options.fileTypes, page module IS compiled and non-empty '
+  + `(length=${(coreWith.files['main/pages_index_index.js'] || '').length})`)
+
+console.log(failed ? '\n❌ FAIL' : '\n✅ PASS: options.fileTypes reaches the browser pool protocol (pool.js/stage-worker.js) and compile-core.js\'s compileMiniApp')
+process.exit(failed ? 1 : 0)

package/scripts/toolchain-setup-node-native.js

@@ -0,0 +1,13 @@
+// Test-only toolchainSetupURL: installs globalThis.__esbuildTransform /
+// __oxcParseSync from the NATIVE esbuild/oxc-parser already in this package's own
+// dependencies (see package.json), instead of the real esbuild-wasm/oxc wasm32-wasi
+// bindings a real browser host would fetch. Both native functions have the exact
+// signature the browser shims (src/shims/esbuild-wasm.js / oxc-parser.js) forward
+// to verbatim (transform(input,options) / parseSync(filename,code,opts)), so this
+// exercises the REAL dist/stage-worker.browser.js code path end-to-end in Node
+// without paying for a wasm toolchain load.
+import { transform } from 'esbuild'
+import { parseSync } from 'oxc-parser'
+
+globalThis.__esbuildTransform = (input, options) => transform(input, options)
+globalThis.__oxcParseSync = parseSync

package/src/compile-core.js

@@ -455,13 +455,16 @@ let compileChain = Promise.resolve()
  * Compile a mini-program against a caller-injected fs. Calls are serialized per
  * realm (see the singleton note above). Convenience wrapper that runs
  * `setupCompile` + all stages + `collectOutputs` in one realm.
- * @param {{ fs: object, workPath?: string }} opts
+ * @param {{ fs: object, workPath?: string, options?: { fileTypes?: { template?: string[], style?: string[], viewScript?: string[] } } }} opts
  *   fs:       a node:fs replacement (sync subset: existsSync/readFileSync/
  *             readdirSync{withFileTypes}/statSync/writeFileSync/mkdirSync{recursive}/
  *             copyFileSync/rmSync), already seeded with the project source under
  *             `workPath`. The compiler also writes products back into it, and a
  *             missing project.config.json appid is written into it.
  *   workPath: project root inside the fs, default '/work'.
+ *   options:  forwarded to `setupCompile` -> dmcc's `storeInfo` (custom file-type
+ *             dialect, e.g. { fileTypes: { template: ['qdml'], style: ['qdss'],
+ *             viewScript: ['qds'] } }).
  * @returns {Promise<{ appId: string, name: string, files: Record<string,string> }>}
  */
 export function compileMiniApp(opts = {}) {
@@ -472,8 +475,8 @@ export function compileMiniApp(opts = {}) {
   return result
 }
 
-async function runCompile({ fs, workPath = '/work' } = {}) {
-  const ctx = await setupCompile({ fs, workPath })
+async function runCompile({ fs, workPath = '/work', options = {} } = {}) {
+  const ctx = await setupCompile({ fs, workPath, options })
   const { storeInfo: bundle, pages, appId, name, targetPath } = ctx
   // Same order as the original single pass. Stages are independent (no product
   // read-back), so the order is not load-bearing — the worker pool (pool.js) runs

package/src/pool.js

@@ -159,7 +159,7 @@ export function createCompilerPool(options = {}) {
   // One full compile attempt against the resident realms. Ends quiescent: settleAll
   // guarantees no request is still in flight when it returns/throws, so a retry can
   // start fresh without cross-attempt FIFO pairing.
-  async function runAttempt(files, workPath) {
+  async function runAttempt(files, workPath, options) {
     await settleAll(workers.map(ensureWarm))
 
     // Setup step — one worker runs setup ONCE: it allocates the scope-hash ids
@@ -170,7 +170,12 @@ export function createCompilerPool(options = {}) {
     // 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 requestChecked(workers[0], { type: 'setup', files, workPath, wantHeartbeat: true }, 'setup', sendTimeoutMs)
+    // `options` (e.g. { fileTypes }) only needs to reach THIS setup call: dmcc's
+    // storeInfo() bakes the normalized dialect into the returned storeInfo object
+    // (dimina/fe/packages/compiler/src/env.js:106-120), which rides inside `bundle`
+    // below and is restored per-stage via resetStoreInfo (compile-core.js's
+    // compileStage -> env.js:122-132) — so compile-subset never needs its own copy.
+    const s = await requestChecked(workers[0], { type: 'setup', files, workPath, options, wantHeartbeat: true }, 'setup', sendTimeoutMs)
     const { bundle, scaffold } = s
 
     // Compile step — every stage compiles in parallel against the SHARED bundle. The
@@ -188,9 +193,16 @@ export function createCompilerPool(options = {}) {
   let chain = Promise.resolve()
 
   /**
-   * Single argument, no ambiguity: pass { files, workPath }. A bare { relPath: content }
-   * map is also accepted (uses the default workPath).
-   * @param {{ files: Record<string,string>, workPath?: string } | Record<string,string>} input
+   * Single argument, no ambiguity: pass { files, workPath, options }. A bare
+   * { relPath: content } map is also accepted (uses the default workPath, no options).
+   * @param {{
+   *   files: Record<string,string>,
+   *   workPath?: string,
+   *   options?: { fileTypes?: { template?: string[], style?: string[], viewScript?: string[] } },
+   * } | Record<string,string>} input
+   *   options.fileTypes lets a caller register a custom template/style/view-script
+   *   dialect (e.g. { template: ['qdml'], style: ['qdss'], viewScript: ['qds'] }) —
+   *   forwarded to the setup worker's `setupCompile` (dmcc's storeInfo).
    * @returns {Promise<{ appId: string, name: string, files: Record<string,string> }>}
    */
   function compile(input = {}) {
@@ -200,17 +212,18 @@ export function createCompilerPool(options = {}) {
       }
       const files = input.files || input
       if (!files || typeof files !== 'object' || !Object.keys(files).length) {
-        throw new Error('[compiler] pool.compile expects { files: { relPath: content }, workPath? } (or a non-empty files map)')
+        throw new Error('[compiler] pool.compile expects { files: { relPath: content }, workPath?, options? } (or a non-empty files map)')
       }
       const workPath = input.workPath || defaultWorkPath
+      const options = input.options || {}
       try {
-        return await runAttempt(files, workPath)
+        return await runAttempt(files, workPath, options)
       } catch (err) {
         // A worker death is often transient (memory pressure, tab freeze, a one-off
         // toolchain stall) — retry the WHOLE attempt once on fresh workers. Real
         // compile errors (bad user source) are deterministic and are never retried.
         if (!retryOnWorkerDeath || !err || !WORKER_DEATH_CODES.has(err.code)) throw err
-        return await runAttempt(files, workPath)
+        return await runAttempt(files, workPath, options)
       }
     })
     // keep the chain alive regardless of this compile's outcome

package/src/stage-worker.js

@@ -65,10 +65,10 @@ function freshFs(files, workPath) {
 // 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) {
+async function runSetup(files, workPath, options) {
   const fs = freshFs(files, workPath)
   resetCompilerState()
-  const ctx = await setupCompile({ fs, workPath })
+  const ctx = await setupCompile({ fs, workPath, options })
   const map = collectOutputs({ fs, targetPath: ctx.targetPath })
   const scaffold = {}
   for (const k of Object.keys(map)) if (map[k] != null) scaffold[k] = map[k]
@@ -93,7 +93,11 @@ async function runSetup(files, workPath) {
 // 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) {
+// `options` (e.g. { fileTypes }) is only used on the no-bundle fallback path: with a
+// bundle, its storeInfo already carries the normalized dialect from the coordinator's
+// setupCompile call (see runSetup below / pool.js's runAttempt), restored via
+// compileStage -> resetStoreInfo, so re-deriving it here would be redundant.
+async function compileSubset(files, workPath, stages, bundle, options) {
   const fs = freshFs(files, workPath)
   resetCompilerState()
   let appId, name, targetPath
@@ -103,7 +107,7 @@ async function compileSubset(files, workPath, stages, bundle) {
     }
     ;({ appId, name, targetPath } = bundle)
   } else {
-    const ctx = await setupCompile({ fs, workPath })
+    const ctx = await setupCompile({ fs, workPath, options })
     for (const stage of stages) {
       await compileStage({ stage, pages: ctx.pages, storeInfo: ctx.storeInfo, fs })
     }
@@ -150,21 +154,21 @@ self.onmessage = async (e) => {
       // 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
+      const { files, workPath = '/work', options, toolchainSetupURL } = e.data
       if (toolchainSetupURL) toolchainURL = toolchainSetupURL
       await ensureToolchain()
       const t = performance.now()
-      const { bundle, scaffold } = await runSetup(files, workPath)
+      const { bundle, scaffold } = await runSetup(files, workPath, options)
       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'], bundle, toolchainSetupURL } = e.data
+      const { files, workPath = '/work', stages = ['logic', 'view', 'style'], bundle, options, 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, bundle)
+      const result = await compileSubset(files, workPath, stages, bundle, options)
       self.postMessage({ type: 'done', result, ms: Math.round(performance.now() - t), warm })
       return
     }