@rustwrap/webpack 1.0.1

package/README.md

@@ -0,0 +1,106 @@
+# @rustwrap/webpack
+
+A **webpack-compatible** Node API and CLI backed by the [Rolldown](https://rolldown.rs) bundler
+(Rust / Oxc). Drop-in replacement for `webpack` in `pcf-scripts` and webpack-based pipelines —
+**much smaller bundles** (rollup-grade tree-shaking) and **far faster builds**, while honouring the
+webpack config/API surface.
+
+## Why
+Webpack bundles for Fluent-v9 PCF controls can approach the 5 MB PCF limit. Rolldown's tree-shaking
+removes far more dead code. `@rustwrap/webpack` exposes the webpack Node API + tapable plugin lifecycle that
+`pcf-scripts` and webpack plugins expect, and translates the config onto Rolldown.
+
+### Measured (representative builds)
+| Build | webpack | @rustwrap/webpack |
+|---|---|---|
+| Fluent-v9 PCF control | 0.84 MB | **0.73 MB** |
+| Multi-entry client bundle (14 entries) | 2.37 MB | **2.06 MB** |
+
+## Architecture
+- **`lib/index.js`** — `webpack(options, cb)` factory + the full `webpack.*` namespace.
+- **`lib/compiler.js`** — tapable `Compiler`/`Compilation`/`MultiCompiler` with the standard webpack
+  lifecycle hooks (`run`, `make`, `thisCompilation`, `compilation`, `processAssets` (staged), `emit`,
+  `afterEmit`, `done`, …). This is what lets **real third-party plugins** (`apply(compiler)`) run.
+- **`lib/build.js`** — the `make` phase: runs Rolldown per entry and writes results into
+  `compilation.assets` (the compiler emits them after plugins' `processAssets`).
+- **`lib/loaders.js`** — runs real webpack loader chains (`module.rules`) via `loader-runner`.
+- **`lib/css.js`** — native CSS pipeline (sass/less compile + style-inject or extract).
+- **`lib/assets.js`** — asset modules. **`lib/plugins.js`** — built-in plugins.
+- **`lib/template.js`** — output filename templates. **`lib/stats.js`** — Stats. **`lib/sourcemap.js`** — devtool.
+
+## Use as a webpack override
+```json
+{
+  "overrides": { "webpack": "npm:@rustwrap/webpack@^1" },
+  "devDependencies": { "webpack": "npm:@rustwrap/webpack@^1" }
+}
+```
+The CLI stubs unresolved webpack-only plugin requires (`terser-webpack-plugin`, `webpack-bundle-analyzer`,
+`eslint-webpack-plugin`, …) so existing `webpack.config.js` files load unchanged.
+
+## Support matrix
+
+### ✅ Supported
+| Area | Notes |
+|---|---|
+| **Node API** | `webpack(options, cb)`, `webpack(options)`→Compiler (`run`/`watch`/`close`), **MultiCompiler** (array of configs → MultiStats), function config `(env,argv)=>…`. |
+| **Plugin system** | Real **tapable** `Compiler`/`Compilation` hooks. `apply(compiler)` plugins run. `compilation.hooks.processAssets` is **stage-ordered**. `emitAsset`/`updateAsset`/`getAsset`/`deleteAsset`/`renameAsset`. `webpack.sources` (webpack-sources). |
+| **entry** | string / array / object / `{import, filename}`; `[name]`. |
+| **output** | `path`, `filename`, `chunkFilename`, `clean`, `publicPath` (asset URLs), `library` (string / `["NS","[name]"]` / `{name,type}`), `libraryTarget` → `var`/`window`/`assign`→iife, `umd`, `commonjs`/`commonjs2`→cjs, `module`→es, `amd`. |
+| **Filename templates** | `[name]`, `[ext]`, `[base]`, `[path]`, `[query]`, `[id]`, `[hash]`, `[contenthash]`, `[chunkhash]` (with `:N`). |
+| **mode** | `production`/`development`/`none` → minify on/off. |
+| **module.rules (loaders)** | Real loader chains via `loader-runner`: `test`/`include`/`exclude`/`resourceQuery`/`oneOf`/`enforce:pre|post`/`use` array/`options`/custom loaders. JS/TS/JSX transpilation is done by **Oxc** (transpile-only loaders `ts-loader`/`babel-loader`/`swc-loader`/`esbuild-loader` are skipped — equivalent, faster). |
+| **CSS** | Native: `.scss`/`.sass` (consumer's `sass`), `.less` (consumer's `less`), `.css`; style-injected, or **extracted** when `MiniCssExtractPlugin` is present. **CSS Modules** (`*.module.*`) are properly scoped via `postcss-modules` (scoped class names + `{local:scoped}` export map + `composes`). |
+| **Asset modules** | `asset/resource` (emit + URL), `asset/inline` (data URI), `asset/source`, `asset` (auto by `parser.dataUrlCondition.maxSize`); `generator.filename`/`output.assetModuleFilename`. |
+| **externals** | object map / array / RegExp / sync-callback function (`({request},cb)` & `(ctx,req,cb)`) / `{root}` → external + `output.globals`. |
+| **resolve** | `alias`, `extensions`, `mainFields`, `mainFiles`, `conditionNames`, `modules`, `extensionAlias`, `symlinks`, `fallback` (`false`→empty module), nearest `tsconfig.json` paths. |
+| **devtool (source maps)** | `source-map`, `inline-source-map`, `hidden-source-map`, `nosources-*`, `eval-*` (≈inline). Emits `.map` + `sourceMappingURL`. |
+| **target** | `web` (default) and `node`/`node*` (→ Rolldown `platform:'node'`, node builtins external). |
+| **optimization** | `minimize`; **`minimizer` TerserPlugin `terserOptions` mapped to Rolldown's minifier**: `compress.drop_console`/`drop_debugger`/`passes`/`ecma`(→target)/`keep_classnames`/`keep_fnames`, `mangle` on/off/`toplevel`/`keep_*`, `format.comments`→`legalComments`. `usedExports:false` disables tree-shaking. Tree-shaking + scope-hoisting are always on via Rolldown. |
+| **Built-in plugins** | `DefinePlugin` (nested keys), `EnvironmentPlugin`, `ProvidePlugin` (**real free-variable scope analysis** via acorn + eslint-scope), `BannerPlugin`, `IgnorePlugin`, `NormalModuleReplacementPlugin`, `SourceMapDevToolPlugin`/`EvalSourceMapDevToolPlugin`, `ProgressPlugin`, `optimize.LimitChunkCountPlugin` (forces single chunk), `LoaderOptionsPlugin`, `WatchIgnorePlugin`, `HotModuleReplacementPlugin` (enables `module.hot`), `ContextReplacementPlugin`. |
+| **Dev server / HMR** | `webpack serve` / `new webpack.DevServer(options, compiler)`. HTTP static serving (`static`), `historyApiFallback`, watch + rebuild, **SSE live-reload**, and a `module.hot`/`import.meta.hot` runtime so HMR-guarded code runs. (Hot updates apply via fast full reload — see Approximated.) |
+| **Third-party plugins** | Anything tapping `compilation.hooks.processAssets`/`compiler.hooks.emit`/`done`/etc. works (Copy-style, Html-style, Banner, analyzers). |
+| **performance** | `hints`/`maxAssetSize` enforced (warning/error). |
+| **ignoreWarnings** | RegExp / function filters. |
+| **stats** | `Stats` with `hasErrors`/`hasWarnings`/`toJson`/`toString({colors})`; quiet via `stats:false|'none'|'errors-only'`. |
+| **watch** | `compiler.watch` / `watch:true` with `watchOptions.aggregateTimeout`. |
+| **code-splitting** | dynamic `import()` → chunks for **es/cjs** output (`output.chunkFilename`). |
+| **Namespace** | `webpack.Compiler/Compilation/MultiCompiler/sources/WebpackError/util/ModuleFilenameHelpers/version`, all built-in plugins, `webpack.optimize.*`, `webpack.container.*`, `webpack.ids.*`. |
+
+### ➖ Approximated (faithful but not byte-identical to webpack)
+- **`optimization.splitChunks` / cacheGroups / runtimeChunk** — Rolldown does its own chunking; the
+  fine-grained cacheGroup controls are not mapped. Single-file output is preserved where required.
+- **`devtool: eval` / `eval-source-map`** — emit a correct **inline source map** (full original
+  sources, debuggable in devtools). The literal per-module `eval()` wrapping is a webpack-internal
+  rebuild mechanism and isn't reproduced on a whole-bundle engine — the debugging result is equivalent.
+- **HMR** — `module.hot`/`import.meta.hot` exist and run dispose handlers, but updates apply via a
+  fast **full reload** (Rolldown emits a whole bundle, not webpack hot-update chunks), so module
+  state is not preserved across edits.
+- **`output.environment` / `target` browserslist downleveling** — Oxc emits modern JS; no ES5 downlevel.
+
+### ❌ Not supported (Rolldown architecture / out of scope)
+- **Module Federation** (`container.ModuleFederationPlugin` is a no-op), **DllPlugin**.
+- **`experiments.asyncWebAssembly` / lazyCompilation**, persistent **`cache: {type:'filesystem'}`** semantics
+  (accepted/ignored — Rolldown has its own caching).
+- Deep `Compilation` graph internals (`moduleGraph`/`chunkGraph`/templates) that some advanced plugins reach into.
+
+## Test
+`npm test` runs `test/run.js` — a synthetic feature matrix (36 assertions) covering tree-shaking,
+multi-entry/MultiCompiler, Define/Environment/Banner, the loader system + CSS, custom plugins via
+hooks, externals, source maps, `[contenthash]`, performance/ignoreWarnings, code-splitting, and the
+namespace.
+
+## Engine & dependencies
+Rolldown is the bundling engine. The other deps fall into two groups:
+- **Engine / compat layer (actually used by `@rustwrap/webpack`):** `rolldown`, `loader-runner`,
+  `webpack-sources`, `tapable`, `mime-types`, `acorn` + `eslint-scope` (ProvidePlugin scope
+  analysis), `postcss` + `postcss-modules` (CSS Modules scoping).
+- **webpack drop-in deps (declared so a normal `npm install` of the `webpack` override still
+  resolves them, exactly like webpack would provide them transitively):** `terser-webpack-plugin`
+  (consumer configs reference it in `optimization.minimizer`; `@rustwrap/webpack` reads its options and never
+  calls `.apply()`), `schema-utils` (required by many third-party plugins). These mirror the
+  packages webpack itself depends on, so existing `webpack.config.js` files keep working after the
+  override. The CLI additionally stubs any *other* unresolved webpack-only plugin require
+  (`webpack-bundle-analyzer`, `eslint-webpack-plugin`, …) as a safety net.
+
+`@rustwrap/webpack` does not implement its own bundler — the engine is Rolldown.

package/bin/rollpack.js

@@ -0,0 +1,82 @@
+#!/usr/bin/env node
+"use strict";
+/*
+ * rollpack CLI — a minimal `webpack`-compatible command. pcf-scripts uses the programmatic API
+ * (require("webpack")(config, cb)), so this CLI only covers basic `webpack [--config f] [--mode m]`
+ * invocations for direct use.
+ */
+const path = require("path");
+const fs = require("fs");
+const Module = require("module");
+
+// webpack.config.js files often `require()` webpack-ecosystem plugins (TerserPlugin, analyzer,
+// eslint-webpack-plugin, ...) that Rolldown doesn't need. Stub any that aren't resolvable so the
+// config loads; rollpack reads the relevant intent (mode, externals, Define/Banner) from the object.
+const STUB_PKGS = new Set([
+  "terser-webpack-plugin", "webpack-bundle-analyzer", "eslint-webpack-plugin",
+  "css-minimizer-webpack-plugin", "mini-css-extract-plugin", "fork-ts-checker-webpack-plugin",
+  "webpack-cli", "style-loader", "css-loader", "sass-loader", "ts-loader",
+]);
+function makeStub() {
+  class StubPlugin { constructor(o) { this.options = o; } apply() {} }
+  return new Proxy(StubPlugin, { get(t, p) { if (p in t) return t[p]; if (typeof p === "string" && /^[A-Z]/.test(p)) return StubPlugin; return undefined; } });
+}
+const origLoad = Module._load;
+Module._load = function (request, parent, isMain) {
+  try { return origLoad.apply(this, arguments); }
+  catch (e) { if (STUB_PKGS.has(request)) return makeStub(); throw e; }
+};
+
+const webpack = require("../lib/index.js");
+
+function parseArgs(argv) {
+  const o = { mode: undefined, config: undefined, watch: false, env: {}, serve: false, port: undefined, host: undefined };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "serve" || a === "dev" || a === "server") o.serve = true;
+    else if (a === "build") { /* default */ }
+    else if (a === "--config" || a === "-c") o.config = argv[++i];
+    else if (a === "--mode") o.mode = argv[++i];
+    else if (a === "--watch" || a === "-w") o.watch = true;
+    else if (a === "--port") o.port = parseInt(argv[++i], 10);
+    else if (a === "--host") o.host = argv[++i];
+    else if (a.startsWith("--env")) { const kv = (a.includes("=") ? a.slice(6) : argv[++i] || "").split("="); o.env[kv[0]] = kv.length > 1 ? kv[1] : true; }
+  }
+  return o;
+}
+
+function findConfig(explicit) {
+  if (explicit) return path.resolve(explicit);
+  for (const n of ["webpack.config.js", "webpack.config.cjs"]) {
+    const p = path.resolve(process.cwd(), n);
+    if (fs.existsSync(p)) return p;
+  }
+  return null;
+}
+
+const opts = parseArgs(process.argv.slice(2));
+const configPath = findConfig(opts.config);
+let config = {};
+if (configPath) {
+  config = require(configPath);
+  if (typeof config === "function") config = config(opts.env, { mode: opts.mode }) || {};
+}
+if (opts.mode) config.mode = opts.mode;
+if (opts.watch) config.watch = true;
+
+if (opts.serve) {
+  // `rollpack serve` / `webpack serve` — start the dev server.
+  if (!config.mode) config.mode = "development";
+  const devServerOpts = Object.assign({ hot: true }, config.devServer || {});
+  if (opts.port) devServerOpts.port = opts.port;
+  if (opts.host) devServerOpts.host = opts.host;
+  const compiler = webpack(config);
+  const server = new webpack.DevServer(devServerOpts, compiler);
+  server.start().catch((e) => { console.error(String(e && e.stack || e)); process.exit(1); });
+  process.on("SIGINT", () => server.stop().then(() => process.exit(0)));
+} else {
+  webpack(config, (err, stats) => {
+    if (err) { console.error(String(err && err.stack || err)); process.exit(1); }
+    if (stats && stats.hasErrors()) { console.error(stats.toString()); process.exit(2); }
+  });
+}

package/lib/assets.js

@@ -0,0 +1,58 @@
+"use strict";
+/*
+ * Asset modules (webpack 5): type "asset/resource" (emit a file, import resolves to its URL),
+ * "asset/inline" (data URI), "asset/source" (raw string), and "asset" (auto: inline under the
+ * dataUrlCondition.maxSize threshold, else resource).
+ */
+const path = require("path");
+const fs = require("fs");
+const crypto = require("crypto");
+
+function hash(content, len) {
+  const algo = crypto.getHashes().includes("md4") ? "md4" : "sha256";
+  return crypto.createHash(algo).update(content).digest("hex").slice(0, len || 20);
+}
+
+function interpolate(template, resource, content, publicPath) {
+  const ext = path.extname(resource);
+  const name = path.basename(resource, ext);
+  const h = hash(content, 20);
+  if (typeof template === "function") template = template({ filename: resource });
+  return (template || "[hash][ext]")
+    .replace(/\[ext\]/gi, ext)
+    .replace(/\[name\]/gi, name)
+    .replace(/\[base\]/gi, name + ext)
+    .replace(/\[(?:content|full)?hash(?::(\d+))?\]/gi, (_m, n) => h.slice(0, n ? parseInt(n, 10) : 20));
+}
+
+// Returns a Rolldown load() result: an ESM module exporting the asset's URL / data-uri / source.
+function handleAsset(resource, meta, cfg, compilation, _prod) {
+  const out = cfg.output || {};
+  const content = fs.readFileSync(resource);
+  const type = meta.type;
+  const mimeFor = (p) => { try { return require("mime-types").lookup(p) || "application/octet-stream"; } catch (_) { return "application/octet-stream"; } };
+
+  let resolvedType = type;
+  if (type === "asset") {
+    const maxSize = (meta.parser && meta.parser.dataUrlCondition && meta.parser.dataUrlCondition.maxSize) || 8192;
+    resolvedType = content.length <= maxSize ? "asset/inline" : "asset/resource";
+  }
+
+  if (resolvedType === "asset/source") {
+    return { code: `export default ${JSON.stringify(content.toString("utf8"))};`, moduleType: "js" };
+  }
+  if (resolvedType === "asset/inline") {
+    const mime = mimeFor(resource);
+    const dataUri = `data:${mime};base64,${content.toString("base64")}`;
+    return { code: `export default ${JSON.stringify(dataUri)};`, moduleType: "js" };
+  }
+  // asset/resource: emit the file and resolve to its public URL.
+  const tmpl = (meta.generator && meta.generator.filename) || out.assetModuleFilename || "[hash][ext]";
+  const filename = interpolate(tmpl, resource, content, out.publicPath).replace(/^\.?[\\/]/, "");
+  if (compilation) compilation.emitAsset(filename, content, { sourceFilename: resource });
+  const publicPath = (meta.generator && meta.generator.publicPath) || out.publicPath || "";
+  const url = (typeof publicPath === "string" ? publicPath : "") + filename;
+  return { code: `export default ${JSON.stringify(url)};`, moduleType: "js" };
+}
+
+module.exports = { handleAsset, hash, interpolate };

package/lib/build.js

@@ -0,0 +1,295 @@
+"use strict";
+/*
+ * build.js — the Rolldown "make" phase. Produces each entry's bundle and writes the result into
+ * compilation.assets (the Compiler emits them later, after plugins' processAssets hooks). Integrates
+ * the loader system, asset modules, Define/Provide/Ignore/NormalModuleReplacement, source maps,
+ * target/platform, externals and library output formats.
+ */
+const path = require("path");
+const { rolldown } = require("rolldown");
+const { normalizeEntries, buildExternals, buildResolve, buildDefine } = require("./config");
+const { loaderPlugin } = require("./loaders");
+const { devtoolToRolldown } = require("./sourcemap");
+
+// Non-JS extensions whose content our loader/asset plugin turns into JS — tell Rolldown to treat the
+// load() output as JS (Rolldown otherwise infers type from extension and rejects e.g. CSS).
+const NON_JS_EXT = [
+  ".css", ".scss", ".sass", ".less", ".styl", ".svg", ".png", ".jpg", ".jpeg", ".gif", ".webp",
+  ".avif", ".ico", ".bmp", ".woff", ".woff2", ".ttf", ".eot", ".otf", ".txt", ".md", ".mdx",
+  ".html", ".htm", ".xml", ".csv", ".tsv", ".vue", ".graphql", ".gql", ".pug", ".hbs", ".ejs",
+];
+function nonJsModuleTypes() { const m = {}; for (const e of NON_JS_EXT) m[e] = e === ".svg" ? "jsx" : "js"; return m; }
+
+function targetPlatform(target) {
+  const t = Array.isArray(target) ? target : [target];
+  if (t.includes("node") || t.some((x) => typeof x === "string" && /^node/.test(x))) return "node";
+  return "browser";
+}
+
+function readMinimize(cfg) {
+  if (cfg.optimization && typeof cfg.optimization.minimize === "boolean") return cfg.optimization.minimize;
+  return cfg.mode !== "development" && cfg.mode !== "none";
+}
+function readDropConsole(cfg) {
+  const min = cfg.optimization && cfg.optimization.minimizer;
+  for (const p of Array.isArray(min) ? min : []) {
+    const t = p && (p.options || p);
+    const c = t && t.terserOptions && t.terserOptions.compress;
+    if (c && c.drop_console) return true;
+  }
+  return false;
+}
+
+function esTarget(ecma) {
+  if (ecma == null) return undefined;
+  const n = String(ecma);
+  if (n === "5") return "es5";
+  if (/^20\d\d$/.test(n)) return "es" + n;
+  if (/^es/i.test(n)) return n.toLowerCase();
+  return undefined;
+}
+
+// Map a TerserPlugin's `terserOptions` (in optimization.minimizer) to Rolldown's MinifyOptions, so
+// drop_console/drop_debugger, mangle (on/off/toplevel/keep_*), passes, ecma target and comment
+// handling are honored — not just drop_console. Returns false/true/MinifyOptions.
+function buildMinify(cfg, minimize) {
+  if (!minimize) return false;
+  const min = cfg.optimization && cfg.optimization.minimizer;
+  let terser = null;
+  for (const p of Array.isArray(min) ? min : []) {
+    const opts = (p && p.options) || {};
+    if (opts.terserOptions) { terser = opts.terserOptions; break; }
+    const cn = p && p.constructor && p.constructor.name;
+    if (cn === "TerserPlugin") { terser = opts.terserOptions || {}; break; }
+  }
+  if (!terser) return true;
+  const t = terser;
+  const out = {};
+  // compress
+  if (t.compress === false) {
+    out.compress = false;
+  } else {
+    const c = (t.compress && typeof t.compress === "object") ? t.compress : {};
+    const compress = {};
+    if (c.drop_console != null) compress.dropConsole = !!c.drop_console;
+    if (c.drop_debugger != null) compress.dropDebugger = !!c.drop_debugger;
+    if (c.passes != null) compress.maxIterations = c.passes;
+    if (c.sequences === false) compress.sequences = false;
+    const tgt = esTarget(t.ecma || c.ecma);
+    if (tgt) compress.target = tgt;
+    if (t.keep_classnames || c.keep_classnames || t.keep_fnames || c.keep_fnames) compress.keepNames = { function: !!(t.keep_fnames || c.keep_fnames), class: !!(t.keep_classnames || c.keep_classnames) };
+    if (Object.keys(compress).length) out.compress = compress;
+  }
+  // mangle
+  if (t.mangle === false) {
+    out.mangle = false;
+  } else {
+    const mo = (t.mangle && typeof t.mangle === "object") ? t.mangle : {};
+    const m = {};
+    if (mo.toplevel != null || t.toplevel != null) m.toplevel = !!(mo.toplevel != null ? mo.toplevel : t.toplevel);
+    if (mo.keep_classnames || mo.keep_fnames || t.keep_classnames || t.keep_fnames) m.keepNames = { function: !!(mo.keep_fnames || t.keep_fnames), class: !!(mo.keep_classnames || t.keep_classnames) };
+    if (Object.keys(m).length) out.mangle = m;
+  }
+  // comments (terserOptions.format.comments / output.comments)
+  const comments = (t.format && t.format.comments !== undefined) ? t.format.comments : (t.output && t.output.comments);
+  if (comments !== undefined) {
+    out.codegen = { legalComments: comments === false ? "none" : (comments === "all" || comments === true ? "inline" : "eof") };
+  }
+  return Object.keys(out).length ? out : true;
+}
+
+// PCF and other single-bundle setups force one chunk via LimitChunkCountPlugin({maxChunks:1}).
+function singleChunkForced(cfg) {
+  for (const p of cfg.plugins || []) {
+    const n = p && p.constructor && p.constructor.name;
+    if (n === "LimitChunkCountPlugin" && p.options && typeof p.options.maxChunks === "number" && p.options.maxChunks <= 1) return true;
+  }
+  return false;
+}
+
+// Map webpack chunkFilename tokens to Rolldown's ([contenthash]/[chunkhash] -> [hash], [id] -> [name]).
+function convertChunkTemplate(t) {
+  return String(t).replace(/\[(content|chunk)hash(?::\d+)?\]/g, "[hash]").replace(/\[id\]/g, "[name]").replace(/^\.?[\\/]/, "");
+}
+
+// ---- Rolldown plugins for Define / Provide / Ignore / NormalModuleReplacement -------------------
+function definePlugin(define) {
+  const keys = Object.keys(define).sort((a, b) => b.length - a.length);
+  if (!keys.length) return null;
+  const escaped = keys.map((k) => k.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+  const re = new RegExp(`(?<![\\w$.])(${escaped.join("|")})(?![\\w$])`, "g");
+  return {
+    name: "rollpack:define",
+    transform(code, id) {
+      if (/[/\\]node_modules[/\\]/.test(id) && !/process\.env|typeof process|__DEV__/.test(code)) return null;
+      re.lastIndex = 0;
+      if (!re.test(code)) return null;
+      re.lastIndex = 0;
+      return { code: code.replace(re, (m) => (define[m] != null ? define[m] : m)), map: null };
+    },
+  };
+}
+
+function providePlugin(provide, _context) {
+  const entries = Object.entries(provide || {});
+  if (!entries.length) return null;
+  const acorn = require("acorn");
+  const eslintScope = require("eslint-scope");
+  const simple = entries.filter(([k]) => !k.includes("."));
+  return {
+    name: "rollpack:provide",
+    transform(code, id) {
+      if (/\.(css|scss|sass|less|svg)$/.test(id) || !simple.length) return null;
+      if (!simple.some(([k]) => code.includes(k))) return null;
+      let ast;
+      try {
+        ast = acorn.parse(code, { ecmaVersion: "latest", sourceType: "module", allowReturnOutsideFunction: true, allowAwaitOutsideFunction: true, allowHashBang: true });
+      } catch (_) { return null; } // unparseable (already-CJS/odd) — skip rather than break the build
+      let manager;
+      try { manager = eslintScope.analyze(ast, { ecmaVersion: 2022, sourceType: "module", ignoreEval: true, optimistic: true }); }
+      catch (_) { return null; }
+      // Truly free references = those that never resolved to a binding (bubble to the global scope).
+      const free = new Set(manager.globalScope.through.map((r) => r.identifier.name));
+      let header = "";
+      for (const [name, spec] of simple) {
+        if (!free.has(name)) continue;
+        const local = `__rp_provide_${name.replace(/[^\w$]/g, "_")}`;
+        if (Array.isArray(spec)) {
+          if (spec.length > 1) header += `import { ${spec[1]} as ${local} } from ${JSON.stringify(spec[0])};\n`;
+          else header += `import ${local} from ${JSON.stringify(spec[0])};\n`;
+        } else {
+          header += `import ${local} from ${JSON.stringify(spec)};\n`;
+        }
+        header += `var ${name} = ${local};\n`;
+      }
+      if (!header) return null;
+      return { code: header + code, map: null };
+    },
+  };
+}
+
+function ignorePlugin(ignores) {
+  if (!ignores || !ignores.length) return null;
+  const matches = (request, ctx) => ignores.some((opt) => {
+    if (!opt) return false;
+    if (opt.resourceRegExp && !opt.resourceRegExp.test(request)) return false;
+    if (opt.resourceRegExp && opt.resourceRegExp.test(request)) { if (opt.contextRegExp) return opt.contextRegExp.test(ctx || ""); return true; }
+    if (typeof opt.checkResource === "function") return opt.checkResource(request, ctx);
+    return false;
+  });
+  const VID = "\0rollpack-ignored";
+  return {
+    name: "rollpack:ignore",
+    resolveId(source, importer) { if (matches(source, importer && path.dirname(importer))) return VID; return null; },
+    load(id) { if (id === VID) return "export default {};"; return null; },
+  };
+}
+
+function normalReplacePlugin(replacements) {
+  if (!replacements || !replacements.length) return null;
+  return {
+    name: "rollpack:normal-replace",
+    resolveId(source, importer) {
+      for (const [re, repl] of replacements) {
+        if (re.test(source)) {
+          let target = typeof repl === "function" ? (() => { const r = { request: source }; repl(r); return r.request; })() : repl;
+          if (target && !path.isAbsolute(target) && importer) target = path.resolve(path.dirname(importer), target);
+          return this.resolve ? this.resolve(target, importer, { skipSelf: true }) : target;
+        }
+      }
+      return null;
+    },
+  };
+}
+
+function entryRel(e, chunkFileName) {
+  const rel = (e.filename || chunkFileName).replace(/^\.[\\/]/, "").replace(/\\/g, "/");
+  return rel;
+}
+
+async function runMake(compilation, cfg, context) {
+  const compiler = compilation.compiler;
+  const rp = compiler.$rollpack || {};
+  const prod = cfg.mode !== "development" && cfg.mode !== "none";
+  const minimize = readMinimize(cfg);
+  const entries = normalizeEntries(cfg, context);
+  const ext = buildExternals(cfg, context);
+  const define = buildDefine(cfg, prod, rp.define);
+  // When hot is enabled (dev server or HotModuleReplacementPlugin), make `module.hot` /
+  // `import.meta.hot` resolve to the injected client runtime so HMR-guarded code runs.
+  if (rp.hot) {
+    define["module.hot"] = "(typeof window!=='undefined'&&window.__rollpack_hot__)";
+    define["import.meta.hot"] = "(typeof window!=='undefined'&&window.__rollpack_hot__)";
+  }
+  const resolve = buildResolve(cfg, context);
+  const { sourcemap } = devtoolToRolldown(cfg.devtool);
+  const platform = targetPlatform(cfg.target);
+  const moduleTypes = nonJsModuleTypes();
+  const minifyOpt = buildMinify(cfg, minimize);
+  const plugins = [
+    ignorePlugin(rp.ignore),
+    normalReplacePlugin(rp.normalReplace),
+    loaderPlugin(cfg, context, compilation),
+    providePlugin(rp.provide, context),
+    definePlugin(define),
+  ].filter(Boolean);
+
+  const t0 = Date.now();
+  compilation.__startTime = t0;
+
+  for (const e of entries) {
+    let bundle;
+    try {
+      bundle = await rolldown({
+        input: e.input,
+        external: ext.isExternal,
+        platform,
+        treeshake: cfg.optimization && cfg.optimization.usedExports === false ? false : true,
+        resolve,
+        moduleTypes,
+        plugins,
+        onLog: () => {},
+      });
+      const minifyOptForEntry = minifyOpt;
+      const codeSplitting = (e.format === "es" || e.format === "cjs") && !singleChunkForced(cfg) && entries.length === 1;
+      const chunkTmpl = convertChunkTemplate((cfg.output && cfg.output.chunkFilename) || "[name].js");
+      const gen = await bundle.generate({
+        format: e.format,
+        name: e.libraryName || undefined,
+        extend: e.extend,
+        globals: ext.globals,
+        minify: minifyOptForEntry,
+        codeSplitting,
+        chunkFileNames: chunkTmpl,
+        sourcemap,
+      });
+      for (const o of gen.output) {
+        if (o.type === "chunk") {
+          let code = o.code != null ? o.code : "";
+          const rel0 = o.isEntry ? entryRel(e, o.fileName) : o.fileName.replace(/\\/g, "/");
+          const rel = require("./template").interpolateName(rel0, { name: o.isEntry ? e.name : path.basename(rel0, path.extname(rel0)), chunkName: e.name, id: e.name, content: code, ext: path.extname(rel0) || ".js" });
+          if (o.map && sourcemap && sourcemap !== "inline") {
+            const mapName = rel + ".map";
+            compilation.emitAsset(mapName, typeof o.map === "string" ? o.map : JSON.stringify(o.map));
+            if (sourcemap !== "hidden") code += `\n//# sourceMappingURL=${path.posix.basename(mapName)}`;
+          }
+          compilation.emitAsset(rel, code);
+        } else {
+          // Rolldown also emits the sourcemap as a separate asset named after the chunk's default
+          // fileName; we already emit the map (renamed to match the entry) from chunk.map above.
+          if (/\.map$/.test(o.fileName)) continue;
+          compilation.emitAsset(o.fileName.replace(/\\/g, "/"), o.source);
+        }
+      }
+    } catch (err) {
+      const detail = (err && (err.message || err.toString())) || String(err);
+      const more = err && Array.isArray(err.errors) ? err.errors.map((x) => x.message || String(x)).join(" | ") : "";
+      compilation.errors.push({ message: `${e.name}: ${detail}${more ? " :: " + more : ""}` });
+    } finally {
+      if (bundle) { try { await bundle.close(); } catch (_) {} }
+    }
+  }
+  compilation.__time = Date.now() - t0;
+}
+
+module.exports = { runMake, definePlugin, providePlugin, ignorePlugin, normalReplacePlugin };