@dimina-kit/compiler 0.0.1-dev.20260702173719

package/src/pool.js

@@ -0,0 +1,122 @@
+// Orchestrated compile pool — the "batteries-included" export. The downstream calls
+// createCompilerPool(...).compile(source) and gets the merged build back; the pool
+// owns ALL the orchestration the downstream used to hand-write:
+//   - a resident worker per stage, kept warm so the wasm toolchain loads ONCE
+//   - dmcc-consistent stage-level parallelism (logic | view | style each in a realm)
+//   - realm reuse across compiles (resetCompilerState inside the worker)
+//   - dispatch + disjoint-output merge
+//
+// What stays with the downstream is only what is genuinely host-specific:
+//   - createWorker(): how to spawn a module Worker running this package's stage worker
+//     (bundler/hosting-specific — one line)
+//   - toolchainSetupURL: an ESM the worker imports to install the two wasm hooks
+//     (esbuild.wasm / oxc wasm are host-hosted assets)
+//   - the source itself (a { relPath: content } map). OPFS is intentionally NOT here:
+//     it's an optional zero-copy source-distribution the downstream can layer on.
+
+const DEFAULT_STAGES = ['logic', 'view', 'style']
+
+/**
+ * @param {{
+ *   createWorker: () => Worker,     // required: spawn a module worker running dist/stage-worker.browser.js
+ *   toolchainSetupURL: string,      // required: ESM URL that installs __esbuildTransform/__oxcParseSync in the worker
+ *   stages?: string[],              // default ['logic','view','style']
+ *   workPath?: string,              // default '/work'
+ *   onLog?: (entry: { level: string, message: string }) => void,  // worker console diagnostics
+ * }} options
+ */
+export function createCompilerPool(options = {}) {
+  const {
+    createWorker,
+    toolchainSetupURL,
+    stages = DEFAULT_STAGES,
+    workPath: defaultWorkPath = '/work',
+    onLog,
+  } = options
+  if (typeof createWorker !== 'function') {
+    throw new Error('[compiler] createCompilerPool: options.createWorker (() => Worker) is required')
+  }
+  if (!toolchainSetupURL) {
+    throw new Error('[compiler] createCompilerPool: options.toolchainSetupURL is required')
+  }
+
+  // one resident worker per stage. send() returns a promise resolved by the worker's
+  // next message; replies are FIFO so a per-worker queue pairs them up.
+  const workers = stages.map((stage) => {
+    const w = createWorker()
+    const q = []
+    w.onmessage = (e) => {
+      const d = e.data
+      // Diagnostics the compiler logs inside the worker (missing components, unsupported
+      // wx APIs, style-preprocessor fallbacks, …) arrive as out-of-band { type:'log' }
+      // messages — surface them via onLog instead of pairing them with a send() reply.
+      if (d && d.type === 'log') { if (onLog) { try { onLog({ level: d.level, message: d.message, stage }) } catch { /* ignore */ } } return }
+      const r = q.shift(); if (r) r(d)
+    }
+    w.onerror = (ev) => {
+      // Worker-script-level failure (module load / uncaught). ErrorEvent.message is often
+      // empty for these — surface filename:lineno and a hint so it's not a bare "error".
+      const msg = (ev && (ev.message || (ev.error && ev.error.message)))
+        || 'worker failed to load or threw (no message — often a module-load / static-asset / cross-origin failure)'
+      const where = ev && ev.filename ? ` (${ev.filename}:${ev.lineno || 0})` : ''
+      const r = q.shift(); if (r) r({ type: 'error', error: `[compiler] stage '${stage}' worker error: ${msg}${where}` })
+    }
+    return { stage, w, send: (m) => new Promise((res) => { q.push(res); w.postMessage(m) }) }
+  })
+
+  let warmed = null
+  async function warmup() {
+    if (!warmed) {
+      warmed = Promise.all(workers.map((x) => x.send({ type: 'warmup', toolchainSetupURL })))
+        .then((rs) => rs.forEach((r, i) => {
+          // The worker's own try/catch reports the REAL cause (e.g. a toolchainSetupURL
+          // import failure) as r.error — surface it verbatim, tagged with the stage.
+          if (r && r.type === 'error') throw new Error(r.error || `[compiler] stage '${workers[i].stage}' warmup failed`)
+        }))
+        .catch((err) => { warmed = null; throw err })
+    }
+    return warmed
+  }
+
+  // Compiles share the resident realms, so they must not overlap — serialize them.
+  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
+   * @returns {Promise<{ appId: string, name: string, files: Record<string,string> }>}
+   */
+  function compile(input = {}) {
+    const run = chain.then(async () => {
+      await warmup()
+      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)')
+      }
+      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
+      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 }
+    })
+    // keep the chain alive regardless of this compile's outcome
+    chain = run.then(() => {}, () => {})
+    return run
+  }
+
+  function dispose() {
+    for (const x of workers) { try { x.w.terminate() } catch { /* ignore */ } }
+  }
+
+  return { warmup, compile, dispose, stages: [...stages] }
+}

package/src/shims/esbuild-wasm.js

@@ -0,0 +1,19 @@
+// Replacement for `esbuild` (native). esbuild-wasm is NOT bundled here — bundling
+// its embedded Go runtime corrupts it (the bundler renames its internal `globalThis`
+// shadow). Instead the host worker loads esbuild-wasm as a pristine module and
+// installs `globalThis.__esbuildTransform`; we just delegate to it.
+
+export function initEsbuild() {
+  // no-op: the host worker initializes esbuild-wasm and sets the hook
+  return Promise.resolve()
+}
+
+export async function transform(input, options) {
+  const fn = globalThis.__esbuildTransform
+  if (!fn) {
+    throw new Error('[esbuild] globalThis.__esbuildTransform not installed by host')
+  }
+  return fn(input, options)
+}
+
+export default { transform, initEsbuild }

package/src/shims/fs-promises.js

@@ -0,0 +1,20 @@
+// node:fs/promises -> forwards to the injected fs's promises API.
+// The compiler uses no async fs; this exists only to satisfy the alias, so the
+// bundle carries no memfs (or any) fs implementation of its own.
+import { promises } from './fs.js'
+
+export default promises
+export const readFile = (...a) => promises.readFile(...a)
+export const writeFile = (...a) => promises.writeFile(...a)
+export const mkdir = (...a) => promises.mkdir(...a)
+export const rm = (...a) => promises.rm(...a)
+export const rmdir = (...a) => promises.rmdir(...a)
+export const readdir = (...a) => promises.readdir(...a)
+export const copyFile = (...a) => promises.copyFile(...a)
+export const stat = (...a) => promises.stat(...a)
+export const lstat = (...a) => promises.lstat(...a)
+export const unlink = (...a) => promises.unlink(...a)
+export const rename = (...a) => promises.rename(...a)
+export const appendFile = (...a) => promises.appendFile(...a)
+export const access = (...a) => promises.access(...a)
+export const realpath = (...a) => promises.realpath(...a)

package/src/shims/fs.js

@@ -0,0 +1,59 @@
+// node:fs / fs -> whatever the caller injects; there is NO built-in backend.
+//
+// The compiler is all `import fs from 'node:fs'` + `fs.xxx`, aliased to this
+// shim. compileMiniApp({ fs }) sets the active backend via setFs() for the
+// duration of one compile; with nothing injected, every fs.* call throws. This
+// is what lets web-compiler carry no fs implementation of its own — the host
+// brings its own node:fs replacement (memfs, or anything meeting the contract).
+let current = null
+
+export function setFs(impl) { current = impl }
+export function resetFs() { current = null }
+export function getFs() { return current }
+
+// Forward a method to the injected backend. Every method — including lstat /
+// realpath / access — forwards to the real fs; there are NO synthetic fallbacks.
+// (An identity realpath, a no-op access, or lstat aliased to stat would hand the
+// compiler wrong semantics silently.) A method the backend lacks throws.
+const call = (name) => (...args) => {
+  if (!current) throw new Error('[compiler] no fs backend injected — call compileMiniApp({ fs })')
+  const fn = current[name]
+  if (typeof fn === 'function') return fn.apply(current, args)
+  throw new Error(`[compiler] injected fs is missing ${name}()`)
+}
+
+export const existsSync = call('existsSync')
+export const readFileSync = call('readFileSync')
+export const writeFileSync = call('writeFileSync')
+export const mkdirSync = call('mkdirSync')
+export const rmSync = call('rmSync')
+export const rmdirSync = call('rmdirSync')
+export const readdirSync = call('readdirSync')
+export const copyFileSync = call('copyFileSync')
+export const statSync = call('statSync')
+export const lstatSync = call('lstatSync')
+export const unlinkSync = call('unlinkSync')
+export const renameSync = call('renameSync')
+export const appendFileSync = call('appendFileSync')
+export const realpathSync = call('realpathSync')
+export const accessSync = call('accessSync')
+export const readlinkSync = call('readlinkSync')
+export const watch = call('watch')
+
+// Async API — forwarded to the injected fs.promises if present. The compiler
+// uses no async fs; this only satisfies the node:fs/promises alias.
+export const promises = new Proxy({}, {
+  get: (_t, prop) => (...args) => {
+    if (!current || !current.promises || typeof current.promises[prop] !== 'function') {
+      throw new Error(`[compiler] injected fs has no promises.${String(prop)}()`)
+    }
+    return current.promises[prop](...args)
+  },
+})
+
+const fs = {
+  existsSync, readFileSync, writeFileSync, mkdirSync, rmSync, rmdirSync,
+  readdirSync, copyFileSync, statSync, lstatSync, unlinkSync, renameSync,
+  appendFileSync, realpathSync, accessSync, readlinkSync, watch, promises,
+}
+export default fs

package/src/shims/less.js

@@ -0,0 +1,9 @@
+// Minimal `less` stub for the browser build.
+// The base example uses .wxss only; .less compilation is not wired yet.
+// (less ships a browser build; proper interop can replace this stub later.)
+const less = {
+  render() {
+    return Promise.reject(new Error('[less] .less compilation not supported in this browser build yet'))
+  },
+}
+export default less

package/src/shims/os.js

@@ -0,0 +1,11 @@
+// minimal node:os shim for browser
+export const cpus = () => [{}, {}, {}, {}]
+export const totalmem = () => 2 * 1024 * 1024 * 1024
+export const freemem = () => 1 * 1024 * 1024 * 1024
+export const platform = () => 'browser'
+export const tmpdir = () => '/tmp'
+// homedir: lilconfig (via the real cssnano's config lookup) calls os.homedir()
+// while walking up for a cssnano config. We have none, so any stable path works.
+export const homedir = () => '/'
+export const EOL = '\n'
+export default { cpus, totalmem, freemem, platform, tmpdir, homedir, EOL }

package/src/shims/oxc-parser.js

@@ -0,0 +1,21 @@
+// oxc-parser replacement. The browser-capable wasm build is oxc-parser's OWN
+// official wasm32-wasi binding (version-matched, maintained) — loaded by the host
+// worker (it has top-level await + a relative wasm fetch + WASI worker, so it
+// can't be inlined into this bundle). The host installs globalThis.__oxcParseSync;
+// the wasm `parseSync(filename, sourceText, options)` signature matches native, so
+// we forward verbatim — no adaptation, identical AST.
+
+export function parseSync(filename, code, opts) {
+  const fn = globalThis.__oxcParseSync
+  if (!fn) {
+    throw new Error('[oxc] globalThis.__oxcParseSync not installed by host')
+  }
+  return fn(filename, code, opts)
+}
+
+// kept for API compatibility; the host worker initializes the wasm directly.
+export function initOxc() {
+  return Promise.resolve()
+}
+
+export default { parseSync, initOxc }

package/src/shims/oxc-walker.js

@@ -0,0 +1,29 @@
+// Replacement for oxc-walker's `walk` (generic ESTree-ish traversal).
+// The compiler only uses walk(ast, { enter(node, parent) }) — no skip/replace/remove.
+const SKIP_KEYS = new Set([
+  'type', 'start', 'end', 'loc', 'range', 'parent',
+  'leadingComments', 'trailingComments', 'innerComments',
+])
+
+export function walk(ast, visitor = {}) {
+  const { enter, leave } = visitor
+  function visit(node, parent) {
+    if (!node || typeof node.type !== 'string') return
+    if (enter) enter(node, parent)
+    for (const key in node) {
+      if (SKIP_KEYS.has(key)) continue
+      const val = node[key]
+      if (Array.isArray(val)) {
+        for (const c of val) {
+          if (c && typeof c.type === 'string') visit(c, node)
+        }
+      } else if (val && typeof val.type === 'string') {
+        visit(val, node)
+      }
+    }
+    if (leave) leave(node, parent)
+  }
+  visit(ast, null)
+}
+
+export default { walk }

package/src/shims/postcss-noop-plugin.js

@@ -0,0 +1,9 @@
+// No-op postcss plugin standing in for autoprefixer / cssnano in the browser build.
+// Those pull in browserslist/caniuse which need a Node `process` global; the demo
+// skips autoprefixing & minification rather than polluting global process
+// (which would make sass / esbuild-wasm / the Go wasm runtime mis-detect Node).
+function noop() {
+  return { postcssPlugin: 'noop-shim', Once() {} }
+}
+noop.postcss = true
+export default noop

package/src/shims/process.js

@@ -0,0 +1,20 @@
+// minimal node:process shim for browser
+const proc = {
+  cwd: () => '/',
+  chdir: () => {},
+  platform: 'browser',
+  env: {},
+  argv: ['node', 'compiler'],
+  version: 'v18.0.0',
+  versions: { node: '18.0.0' },
+  nextTick: (cb, ...args) => Promise.resolve().then(() => cb(...args)),
+  exit: () => {},
+  on: () => {},
+  hrtime: () => [0, 0],
+}
+export default proc
+export const cwd = proc.cwd
+export const env = proc.env
+export const platform = proc.platform
+export const argv = proc.argv
+export const nextTick = proc.nextTick

package/src/shims/url.js

@@ -0,0 +1,4 @@
+// minimal node:url shim
+export const fileURLToPath = (u) => String(u).replace(/^file:\/\//, '')
+export const pathToFileURL = (p) => ({ href: `file://${p}`, toString: () => `file://${p}` })
+export default { fileURLToPath, pathToFileURL }

package/src/shims/worker_threads.js

@@ -0,0 +1,10 @@
+// node:worker_threads shim.
+// isMainThread = true so the compiler files SKIP their `if (!isMainThread)` parentPort
+// bootstrap blocks. We drive the exported compile functions directly instead.
+export const isMainThread = true
+export const parentPort = null
+export const workerData = null
+export class Worker {
+  constructor() { throw new Error('worker_threads.Worker is not available in browser build') }
+}
+export default { isMainThread, parentPort, workerData, Worker }

package/src/stage-worker-node.js

@@ -0,0 +1,41 @@
+// Resident Node worker_threads stage worker for the disk pool.
+//
+// One of these runs per stage (logic | view | style). It stays warm across builds
+// (the pool never terminates it between compiles) and writes its stage's product
+// files DIRECTLY to the shared real-disk staging dir (getTargetPath(), carried in
+// the storeInfo the main thread ships). Stages write disjoint file names, so the
+// three workers can write the same staging dir concurrently — exactly like dmcc's
+// own index.js does.
+//
+// fs is NATIVE here (this bundle is built without the fs alias — see build-compiler.js),
+// so dmcc's `import fs from 'node:fs'` hits real disk. worker_threads is SHIMMED for
+// dmcc (isMainThread=true) so its own parentPort bootstrap stays off; we grab the REAL
+// parentPort via createRequire to talk to the pool.
+import { createRequire } from 'node:module'
+import { runStage, resetCompilerState } from './compile-core.js'
+import { resetStoreInfo, getAppId, getAppName } from '../../../dimina/fe/packages/compiler/src/env.js'
+
+const { parentPort } = createRequire(import.meta.url)('node:worker_threads')
+
+if (!parentPort) {
+  throw new Error('[compiler] stage-worker-node.js must run inside a worker_threads Worker')
+}
+
+parentPort.on('message', async (msg) => {
+  const { stage, pages, storeInfo, sourcemap } = msg || {}
+  try {
+    // Warm-realm hygiene: clear this worker's module-level caches so a reused worker
+    // does not leak state from the previous build (same contract as the browser pool).
+    resetCompilerState()
+    // Restore the env singletons (paths/config/targetPath) from the main thread's setup.
+    resetStoreInfo(storeInfo)
+    await runStage(stage, pages, { sourcemap })
+    parentPort.postMessage({ type: 'done', stage, appId: getAppId(), name: getAppName() })
+  } catch (error) {
+    parentPort.postMessage({
+      type: 'error',
+      stage,
+      error: { message: error && error.message, stack: error && error.stack, name: error && error.name },
+    })
+  }
+})

package/src/stage-worker.js

@@ -0,0 +1,88 @@
+// Resident stage worker — shipped BY this package so downstream doesn't hand-write
+// worker glue. One instance runs ONE full compile stage (logic | view | style) in a
+// whole realm; the pool (src/pool.js) keeps three of them warm and unions the
+// disjoint outputs. This is the dmcc-consistent parallel axis (each stage entirely
+// in one realm, so view sees all pages and app-level module dedup still holds).
+//
+// The wasm toolchain (esbuild-wasm + oxc-parser) can't be inlined here (their Go/WASI
+// runtimes break when bundled), and their .wasm assets are host-specific — so the
+// host provides ONE `toolchainSetupURL`: an ESM module that, when imported inside
+// this worker, installs `globalThis.__esbuildTransform` and `globalThis.__oxcParseSync`
+// (see README). That URL is the ONLY wasm-hosting detail the downstream owns; all
+// orchestration, fs seeding, reset-reuse and merge live in this package.
+//
+// Source distribution is deliberately OPFS-free: the pool posts the source map and we
+// seed it into our own memfs. A downstream that wants zero-copy OPFS distribution can
+// layer it on top (hydrate OPFS -> a files map before calling the pool).
+import { Volume, createFsFromVolume } from 'memfs'
+import { setupCompile, compileStage, collectOutputs, resetCompilerState } from './compile-core.js'
+
+// The compiler logs diagnostics (missing components, unsupported wx APIs, style
+// preprocessor fallbacks, asset-copy failures, …) via console.* inside this worker,
+// where a downstream can't see them. Forward them to the pool as { type:'log' } so
+// createCompilerPool({ onLog }) can surface them; still log locally for devtools.
+for (const level of ['log', 'warn', 'error']) {
+  const orig = typeof console[level] === 'function' ? console[level].bind(console) : () => {}
+  console[level] = (...args) => {
+    try { self.postMessage({ type: 'log', level, message: args.map((a) => (typeof a === 'string' ? a : String(a))).join(' ') }) } catch { /* ignore */ }
+    orig(...args)
+  }
+}
+
+// Load the host's wasm toolchain exactly once. Memoized on the setup URL; a failed
+// load clears the cache so a later message can retry instead of replaying the reject.
+let toolchainReady = null
+let toolchainURL = null
+function ensureToolchain(url) {
+  if (url) toolchainURL = url
+  if (!toolchainReady) {
+    if (!toolchainURL) return Promise.reject(new Error('[compiler] stage worker not warmed up: no toolchainSetupURL (call pool.warmup first)'))
+    toolchainReady = import(/* @vite-ignore */ toolchainURL)
+      .catch((err) => { toolchainReady = null; throw new Error(`[compiler] toolchain setup failed importing ${toolchainURL}: ${(err && err.message) || err}`) })
+  }
+  return toolchainReady
+}
+
+function freshFs(files, workPath) {
+  return createFsFromVolume(Volume.fromJSON(files, workPath))
+}
+
+// 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) {
+  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 })
+  }
+  const map = collectOutputs({ fs, targetPath: ctx.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 }
+}
+
+self.onmessage = async (e) => {
+  const { type } = e.data || {}
+  try {
+    if (type === 'warmup') {
+      const t0 = performance.now()
+      await ensureToolchain(e.data.toolchainSetupURL)
+      self.postMessage({ type: 'ready', ms: Math.round(performance.now() - t0) })
+      return
+    }
+    if (type === 'compile-subset') {
+      const { files, workPath = '/work', stages = ['logic', 'view', 'style'], toolchainSetupURL } = e.data
+      await ensureToolchain(toolchainSetupURL)
+      const warm = !!toolchainReady
+      const t = performance.now()
+      const result = await compileSubset(files, workPath, stages)
+      self.postMessage({ type: 'done', result, ms: Math.round(performance.now() - t), warm })
+      return
+    }
+  } catch (err) {
+    self.postMessage({ type: 'error', error: String((err && err.stack) || err) })
+  }
+}

package/src/toolchain.js

@@ -0,0 +1,49 @@
+// Optional helpers for writing the host's `toolchainSetupURL` module (the ESM the pool's
+// stage worker imports to install the two wasm hooks). They package the two fiddly bits
+// a downstream would otherwise hand-write:
+//
+//   1. esbuild-wasm's browser build is usually hosted as a STATIC asset (its Go runtime
+//      breaks when bundled). Bundlers (Vite/Webpack/Rollup) refuse to `import()` a file
+//      that lives in the static/public dir — so we fetch it and import a Blob URL, which
+//      side-steps the bundler module graph. `installEsbuildFromURL` does exactly that.
+//   2. Installing the globals the compiler shims delegate to (`__esbuildTransform`,
+//      `__oxcParseSync`).
+//
+// oxc-parser stays a HOST import: only your bundler can resolve `oxc-parser` + fetch its
+// wasm, so you pass the already-imported module to `installOxc`.
+//
+// Typical host toolchain-setup.js (imported by the stage worker at warmup):
+//   import { installEsbuildFromURL, installOxc } from '@dimina-kit/compiler/toolchain'
+//   installOxc(await import('oxc-parser'))
+//   await installEsbuildFromURL('/esbuild-browser.mjs', '/esbuild.wasm')
+
+/**
+ * Load esbuild-wasm's browser ESM from a static-asset URL (via a Blob URL, so bundlers
+ * don't choke) and install `globalThis.__esbuildTransform`.
+ * @param {string} moduleURL  URL of esbuild-wasm's browser ESM (e.g. '/esbuild-browser.mjs')
+ * @param {string} wasmURL    URL of esbuild.wasm (e.g. '/esbuild.wasm')
+ * @returns {Promise<any>} the initialized esbuild module
+ */
+export 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
+}
+
+/**
+ * Install `globalThis.__oxcParseSync` from an already-imported oxc-parser module.
+ * @param {{ parseSync?: Function, default?: { parseSync?: Function } }} oxcModule  `await import('oxc-parser')`
+ */
+export 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
+}