@rustwrap/webpack 1.0.2 → 1.0.3

package/README.md

@@ -78,12 +78,14 @@ Taking the **strictest** clause on each line yields the declared range. Reading
 | **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`. |
+| **Node globals (browser target)** | Auto-polyfills `process`, `Buffer`, and `global` for `web` builds — parity with webpack's `ProvidePlugin`/node-libs-browser. Using real scope analysis (acorn + eslint-scope), a **`process` shim** (nextTick/env/platform/…), the **`buffer` package's `Buffer`**, and `global`→globalThis are injected **only into modules that reference them as free (unbound) identifiers**. So dependencies that assume Node (e.g. telemetry SDKs pulling in `readable-stream`/`buffer` such as `@aria/webjs-sdk`) work in the browser instead of throwing `process is not defined`. No-op on `target:'node'` and for code that never references them. |
+| **externals** | object map / array / RegExp / sync-callback function (`({request},cb)` & `(ctx,req,cb)`) / `{root}` → external + `output.globals`. **Exact-request match** (webpack semantics): an entry like `{react:"React"}` externalizes `react` only, **not** subpaths like `react/jsx-runtime` (those are bundled, so e.g. the automatic JSX runtime keeps its `jsx`/`jsxs`). Externals are reachable from **both `import` and `require()`** — a bundled CommonJS dependency's internal `require("<external>")` is rewritten to the same global, so it never leaves a bare `require` (which would throw in the browser). |
+| **TypeScript** | Transpiled by Oxc (types stripped, JSX per `tsconfig`). **Ambient `const enum` member accesses are inlined to literals** (tsc parity) by reading the const enums declared in the project's `.ts/.d.ts` and any pulled in via tsconfig `files`/`include` or triple-slash `/// <reference>` — without this, accesses like `XrmClientApi.Constants.X.Y` would survive as runtime references to a namespace that doesn't exist at runtime. Regular (non-const) `enum`s emit runtime objects as usual. |
 | **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`. |
+| **Built-in plugins** | `DefinePlugin` (nested keys; **AST-aware** — replaces expressions only, never the contents of string/template literals or comments), `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). |

package/bin/{rollpack.js → rustwrap-webpack.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 "use strict";
 /*
- * rollpack CLI — a minimal `webpack`-compatible command. pcf-scripts uses the programmatic API
+ * @rustwrap/webpack 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.
  */
@@ -11,7 +11,7 @@ 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.
+// config loads; @rustwrap/webpack 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",
@@ -65,7 +65,7 @@ if (opts.mode) config.mode = opts.mode;
 if (opts.watch) config.watch = true;
 
 if (opts.serve) {
-  // `rollpack serve` / `webpack serve` — start the dev server.
+  // `@rustwrap/webpack 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;

package/lib/build.js

@@ -116,16 +116,45 @@ function convertChunkTemplate(t) {
 function definePlugin(define) {
   const keys = Object.keys(define).sort((a, b) => b.length - a.length);
   if (!keys.length) return null;
+  const acorn = require("acorn");
+  const tt = acorn.tokTypes;
   const escaped = keys.map((k) => k.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
   const re = new RegExp(`(?<![\\w$.])(${escaped.join("|")})(?![\\w$])`, "g");
+  const replaceAll = (code) => code.replace(re, (m) => (define[m] != null ? define[m] : m));
   return {
-    name: "rollpack:define",
+    name: "rustwrap: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;
+      // Collect ranges of string/template/regex literals and comments. webpack's DefinePlugin
+      // replaces expressions only — never the contents of strings or comments — so we must skip
+      // any match landing inside these ranges (a raw text replace would corrupt string literals).
+      const protectedRanges = [];
+      try {
+        acorn.parse(code, {
+          ecmaVersion: "latest",
+          sourceType: "module",
+          allowReturnOutsideFunction: true,
+          allowAwaitOutsideFunction: true,
+          allowHashBang: true,
+          onComment: (_block, _text, start, end) => protectedRanges.push([start, end]),
+          onToken: (t) => {
+            // `template` tokens are the literal chunks between `${}` — protecting them leaves the
+            // interpolated `${expr}` code (separate tokens) eligible for replacement, like webpack.
+            if (t.type === tt.string || t.type === tt.template || t.type === tt.regexp) protectedRanges.push([t.start, t.end]);
+          },
+        });
+      } catch (_) {
+        // Unparseable (already-CJS/odd syntax) — fall back to the identifier-boundary regex rather
+        // than break the build. This preserves prior behavior for the rare unparseable module.
+        re.lastIndex = 0;
+        return { code: replaceAll(code), map: null };
+      }
+      const inProtected = (idx) => protectedRanges.some(([s, e]) => idx >= s && idx < e);
       re.lastIndex = 0;
-      return { code: code.replace(re, (m) => (define[m] != null ? define[m] : m)), map: null };
+      const out = code.replace(re, (m, _g1, offset) => (inProtected(offset) ? m : (define[m] != null ? define[m] : m)));
+      return { code: out, map: null };
     },
   };
 }
@@ -137,13 +166,13 @@ function providePlugin(provide, _context) {
   const eslintScope = require("eslint-scope");
   const simple = entries.filter(([k]) => !k.includes("."));
   return {
-    name: "rollpack:provide",
+    name: "rustwrap: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 });
+        ast = acorn.parse(code, { ecmaVersion: "latest", sourceType: "module", ranges: true, 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 }); }
@@ -168,6 +197,78 @@ function providePlugin(provide, _context) {
   };
 }
 
+// Bundled CommonJS modules can `require("<external>")` (e.g. React's CJS `react/jsx-runtime` does
+// `require("react")`). rolldown maps externals to globals for ESM imports via output.globals, but it
+// does NOT rewrite a CJS module's internal `require(external)` -> the global, leaving a bare
+// `require(...)` that throws "require is not defined" in the browser. This transform rewrites
+// `require("<external>")` to the same platform/global the external resolves to, restoring webpack's
+// behavior (where externals are reachable from both `import` and `require`).
+function externalRequirePlugin(isExternal, globals) {
+  if (typeof isExternal !== "function") return null;
+  const RE = /(?<![\w.$])require\(\s*(['"])([^'"]+)\1\s*\)/g;
+  return {
+    name: "rustwrap:external-require",
+    transform(code) {
+      if (code.indexOf("require(") === -1) return null;
+      let changed = false;
+      const out = code.replace(RE, (m, _q, dep) => {
+        let ext;
+        try { ext = isExternal(dep); } catch { ext = false; }
+        if (!ext) return m;
+        let g;
+        try { g = globals(dep); } catch { g = undefined; }
+        if (!g || !/^[A-Za-z_$][\w$]*$/.test(g)) return m; // only simple global identifiers
+        changed = true;
+        // Reference the platform-provided global (same one output.globals binds for ESM imports);
+        // fall back to globalThis lookup if the bare binding isn't in scope.
+        return `(typeof ${g}!=="undefined"?${g}:(typeof globalThis!=="undefined"?globalThis:window)[${JSON.stringify(g)}])`;
+      });
+      return changed ? { code: out, map: null } : null;
+    },
+  };
+}
+
+// Node-builtin globals polyfill for browser targets (parity with webpack's ProvidePlugin +
+// node-libs-browser, and pcf-scripts' esbuild `pcfEsbuildNodePolyfills`). Rolldown/webpack-5 do not
+// auto-provide these, so a dependency that assumes Node (e.g. telemetry SDKs pulling in
+// readable-stream/buffer) can reference a bare `process.nextTick`/`Buffer` that throws in the
+// browser. Using the same free-variable scope analysis as ProvidePlugin, we inject `process`
+// (inline shim), `global` (globalThis), and `Buffer` (the `buffer` package) ONLY into modules that
+// reference them as free (unbound) identifiers — so it's a no-op for code that doesn't need them.
+function nodePolyfillPlugin(platform) {
+  if (platform === "node") return null; // node target: real builtins, no shim
+  const acorn = require("acorn");
+  const eslintScope = require("eslint-scope");
+  const resolveSafe = (id) => { try { return require.resolve(id); } catch { return null; } };
+  const bufferPath = resolveSafe("buffer/");
+  const processPath = path.join(__dirname, "shims", "process.js");
+  const globalPath = path.join(__dirname, "shims", "global.js");
+  const SHIM_PATHS = new Set([processPath, globalPath, bufferPath].filter(Boolean));
+  return {
+    name: "rustwrap:node-polyfill",
+    transform(code, id) {
+      if (SHIM_PATHS.has(path.normalize(id))) return null; // never inject into the shims themselves
+      // Skip rolldown's internal runtime/virtual modules — their interop helpers reference `Buffer`
+      // in `typeof` guards, which would otherwise pull the whole buffer polyfill into every bundle.
+      if (id.startsWith("\0") || /(?:^|[/\\])rolldown[/\\]|rolldown:/.test(id)) return null;
+      if (/\.(css|scss|sass|less|svg)$/.test(id)) return null;
+      if (!/(?<![\w.$])(process|Buffer|global)\b/.test(code)) return null;
+      let ast;
+      try { ast = acorn.parse(code, { ecmaVersion: "latest", sourceType: "module", ranges: true, allowReturnOutsideFunction: true, allowAwaitOutsideFunction: true, allowHashBang: true }); }
+      catch { return null; }
+      let mgr;
+      try { mgr = eslintScope.analyze(ast, { ecmaVersion: 2022, sourceType: "module", ignoreEval: true, optimistic: true }); }
+      catch { return null; }
+      const free = new Set(mgr.globalScope.through.map((r) => r.identifier.name));
+      let header = "";
+      if (free.has("process")) header += `import __rp_process from ${JSON.stringify(processPath)};\nvar process=__rp_process;\n`;
+      if (free.has("global")) header += `import __rp_global from ${JSON.stringify(globalPath)};\nvar global=__rp_global;\n`;
+      if (free.has("Buffer") && bufferPath) header += `import { Buffer as __rp_Buffer } from ${JSON.stringify(bufferPath)};\nvar Buffer=__rp_Buffer;\n`;
+      return header ? { code: header + code, map: null } : null;
+    },
+  };
+}
+
 function ignorePlugin(ignores) {
   if (!ignores || !ignores.length) return null;
   const matches = (request, ctx) => ignores.some((opt) => {
@@ -177,9 +278,9 @@ function ignorePlugin(ignores) {
     if (typeof opt.checkResource === "function") return opt.checkResource(request, ctx);
     return false;
   });
-  const VID = "\0rollpack-ignored";
+  const VID = "\0rustwrap-ignored";
   return {
-    name: "rollpack:ignore",
+    name: "rustwrap: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; },
   };
@@ -188,7 +289,7 @@ function ignorePlugin(ignores) {
 function normalReplacePlugin(replacements) {
   if (!replacements || !replacements.length) return null;
   return {
-    name: "rollpack:normal-replace",
+    name: "rustwrap:normal-replace",
     resolveId(source, importer) {
       for (const [re, repl] of replacements) {
         if (re.test(source)) {
@@ -209,17 +310,26 @@ function entryRel(e, chunkFileName) {
 
 async function runMake(compilation, cfg, context) {
   const compiler = compilation.compiler;
-  const rp = compiler.$rollpack || {};
+  const rp = compiler.$rustwrap || {};
   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);
+  // Inline ambient `const enum` member accesses to literals (tsc parity). Without this, oxc/rolldown
+  // leave e.g. `XrmClientApi.Constants.GlobalNotificationLevel.success` as a runtime reference to a
+  // namespace that doesn't exist at runtime -> "XrmClientApi is not defined". We feed the collected
+  // `Ns.Enum.Member` -> literal map through the same Define replacement. Explicit user defines win.
+  try {
+    const { collectConstEnumDefines } = require("./const-enum");
+    const ce = collectConstEnumDefines(context);
+    for (const k of Object.keys(ce)) if (define[k] == null) define[k] = ce[k];
+  } catch { /* typescript unavailable or parse failure -> skip inlining (non-fatal) */ }
   // 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__)";
+    define["module.hot"] = "(typeof window!=='undefined'&&window.__rustwrap_hot__)";
+    define["import.meta.hot"] = "(typeof window!=='undefined'&&window.__rustwrap_hot__)";
   }
   const resolve = buildResolve(cfg, context);
   const { sourcemap } = devtoolToRolldown(cfg.devtool);
@@ -232,6 +342,8 @@ async function runMake(compilation, cfg, context) {
     loaderPlugin(cfg, context, compilation),
     providePlugin(rp.provide, context),
     definePlugin(define),
+    externalRequirePlugin(ext.isExternal, ext.globals),
+    nodePolyfillPlugin(platform),
   ].filter(Boolean);
 
   const t0 = Date.now();

package/lib/compiler.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- * rollpack Compiler/Compilation — a tapable-based webpack lifecycle so real plugins (apply(compiler))
+ * @rustwrap/webpack Compiler/Compilation — a tapable-based webpack lifecycle so real plugins (apply(compiler))
  * run. The heavy lifting (producing entry bundles) happens in the `make` phase via Rolldown; plugins
  * then add/modify compilation.assets through processAssets/emit hooks before they're written.
  */
@@ -255,9 +255,24 @@ class Compiler {
     };
     run();
     let watcher;
+    // Ignore writes we cause ourselves (the build's own output dir) and irrelevant paths — otherwise
+    // emitting into output.path retriggers the watcher in an infinite rebuild/reload loop. fs.watch
+    // reports paths RELATIVE to root, so the output dir often has no leading separator (e.g.
+    // "out/controls/x/bundle.js") — anchor to start as well as after a separator.
+    const outPath = this.options && this.options.output && this.options.output.path;
+    const outRel = outPath ? path.relative(root, outPath).replace(/\\/g, "/") : "";
+    const ignored = (f) => {
+      if (!f) return false;
+      const n = f.replace(/\\/g, "/");
+      if (/(^|\/)(node_modules|\.git)(\/|$)/.test(n)) return true;
+      if (/\.d\.ts$/.test(n)) return true;
+      if (outRel && outRel !== "." && !outRel.startsWith("..") && (n === outRel || n.startsWith(outRel + "/"))) return true;
+      if (/^(out|dist)(\/|$)/.test(n)) return true; // fallback for default output dirs at the root
+      return false;
+    };
     try {
       watcher = fs.watch(root, { recursive: true }, (_ev, f) => {
-        if (f && /node_modules|[\\/](out|dist)[\\/]|\.d\.ts$/.test(f)) return;
+        if (ignored(f)) return;
         if (building) return;
         this.hooks.invalid.call(f, Date.now());
         clearTimeout(timer); timer = setTimeout(run, (watchOptions && watchOptions.aggregateTimeout) || 200);

package/lib/config.js

@@ -110,8 +110,11 @@ function buildExternals(cfg, context) {
     return undefined;
   };
   const resolveGlobal = (id) => {
-    if (map[id]) return map[id];
-    for (const k of Object.keys(map)) if (id === k || id.startsWith(k + "/")) return map[k];
+    // Webpack object externals match the EXACT request only (never subpaths). Matching subpaths
+    // (e.g. `react/jsx-runtime` under a `react` external) wrongly maps the automatic JSX runtime to
+    // the platform React global, which lacks jsx/jsxs -> "jsxs is not a function". Exact-match keeps
+    // react/jsx-runtime (and other subpath entrypoints) bundled, exactly as webpack does.
+    if (Object.prototype.hasOwnProperty.call(map, id)) return map[id];
     const f = callFn(id); if (f) return f;
     return undefined;
   };
@@ -125,8 +128,8 @@ function buildExternals(cfg, context) {
   return { isExternal, globals };
 }
 
-function buildDefine(cfg, prod, rollpackDefine) {
-  const def = Object.assign({ "process.env.NODE_ENV": JSON.stringify(prod ? "production" : "development") }, rollpackDefine || {});
+function buildDefine(cfg, prod, rustwrapDefine) {
+  const def = Object.assign({ "process.env.NODE_ENV": JSON.stringify(prod ? "production" : "development") }, rustwrapDefine || {});
   return def;
 }
 

package/lib/const-enum.js

@@ -0,0 +1,136 @@
+"use strict";
+/*
+ * Ambient `const enum` inlining (tsc-parity).
+ *
+ * tsc/ts-loader inline ambient `const enum` member accesses to literal values at compile time
+ * (e.g. `XrmClientApi.Constants.GlobalNotificationLevel.success` -> `1`). Fast TS transformers
+ * (oxc/rolldown, esbuild, swc) do NOT inline ambient const enums declared in `.d.ts`, leaving the
+ * member access as a runtime reference to a namespace object that doesn't exist at runtime ->
+ * "XrmClientApi is not defined".
+ *
+ * This module parses const enums (with their full namespace path) from the project's `.ts/.tsx`
+ * sources and any `.d.ts` they pull in via triple-slash `/// <reference path=.../>`, and returns a
+ * map of `Ns.Sub.Enum.Member` -> literal. build.js merges that map into the Define map so the
+ * existing (AST-aware) define replacement inlines them exactly like tsc would.
+ */
+const fs = require("fs");
+const path = require("path");
+
+function loadTS(context) {
+  try { return require(require.resolve("typescript", { paths: [context, process.cwd()] })); }
+  catch { return null; }
+}
+
+// Walk a directory for .ts/.tsx sources (skipping node_modules/out/dist/dot-dirs).
+function walkSources(dir, out, depth) {
+  if (depth > 10) return;
+  let entries;
+  try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch { return; }
+  for (const e of entries) {
+    if (e.name === "node_modules" || e.name === "out" || e.name === "dist" || e.name.startsWith(".")) continue;
+    const full = path.join(dir, e.name);
+    if (e.isDirectory()) walkSources(full, out, depth + 1);
+    else if (/\.(ts|tsx)$/.test(e.name)) out.add(path.normalize(full));
+  }
+}
+
+// Resolve triple-slash `/// <reference path='...'/>` directives to absolute paths.
+function refsIn(file) {
+  let text;
+  try { text = fs.readFileSync(file, "utf8"); } catch { return []; }
+  const out = [];
+  const re = /\/\/\/\s*<reference\s+path\s*=\s*['"]([^'"]+)['"]\s*\/>/g;
+  let m;
+  while ((m = re.exec(text))) out.push(path.resolve(path.dirname(file), m[1]));
+  return out;
+}
+
+// Parse one file's const enums into map[fullPath] = literalString.
+function collectFile(ts, file, map) {
+  let text;
+  try { text = fs.readFileSync(file, "utf8"); } catch { return; }
+  if (!/const\s+enum/.test(text)) return; // fast skip — most files have none
+  let sf;
+  try { sf = ts.createSourceFile(file, text, ts.ScriptTarget.Latest, true); } catch { return; }
+  const nsStack = [];
+  const isConst = (node) => {
+    const mods = ts.canHaveModifiers ? ts.getModifiers(node) : node.modifiers;
+    return !!(mods && mods.some((m) => m.kind === ts.SyntaxKind.ConstKeyword));
+  };
+  const visit = (node) => {
+    if (ts.isModuleDeclaration(node) && node.name && node.body) {
+      nsStack.push(node.name.text);
+      ts.forEachChild(node.body, visit);
+      nsStack.pop();
+      return;
+    }
+    if (ts.isEnumDeclaration(node) && isConst(node)) {
+      const enumName = node.name.text;
+      let auto = 0;
+      for (const member of node.members) {
+        let memberName;
+        try { memberName = member.name.getText(sf).replace(/^['"]|['"]$/g, ""); } catch { continue; }
+        let value;
+        const init = member.initializer;
+        if (!init) {
+          value = auto; auto += 1;
+        } else if (ts.isNumericLiteral(init)) {
+          value = Number(init.text); auto = value + 1;
+        } else if (ts.isPrefixUnaryExpression(init) && init.operator === ts.SyntaxKind.MinusToken && ts.isNumericLiteral(init.operand)) {
+          value = -Number(init.operand.text); auto = value + 1;
+        } else if (ts.isStringLiteral(init)) {
+          value = init.text; // string enum member — no auto-increment afterwards
+        } else {
+          continue; // computed/complex initializer — cannot safely inline
+        }
+        const literal = typeof value === "string" ? JSON.stringify(value) : String(value);
+        map[[...nsStack, enumName, memberName].join(".")] = literal;
+      }
+      return;
+    }
+    ts.forEachChild(node, visit);
+  };
+  visit(sf);
+}
+
+// Build the const-enum -> literal map for a build rooted at `context`.
+function collectConstEnumDefines(context) {
+  const ts = loadTS(context);
+  if (!ts) return {}; // typescript not installed -> no-op (degrade to prior behavior)
+
+  const files = new Set();
+
+  // Primary: resolve the tsconfig exactly as tsc would (honoring `extends`, `files`, `include`,
+  // `exclude`). This is what pulls in ambient typings declared via `files` in a base tsconfig
+  // (e.g. XrmClientApi.d.ts), which triple-slash scanning alone would miss.
+  try {
+    const configPath = ts.findConfigFile(context, ts.sys.fileExists, "tsconfig.json");
+    if (configPath) {
+      const host = Object.assign({}, ts.sys, { onUnRecoverableConfigFileDiagnostic() {} });
+      const parsed = ts.getParsedCommandLineOfConfigFile(configPath, {}, host);
+      if (parsed && parsed.fileNames) for (const f of parsed.fileNames) files.add(path.normalize(f));
+    }
+  } catch { /* fall through to source walk */ }
+
+  // Fallback / supplement: walk sources under context when tsconfig resolution yields nothing.
+  if (files.size === 0) walkSources(context, files, 0);
+
+  // Always also follow triple-slash `/// <reference path>` directives transitively (covers files
+  // referenced directly from source but not listed by the tsconfig).
+  const queue = Array.from(files);
+  while (queue.length) {
+    const f = queue.shift();
+    for (const r of refsIn(f)) {
+      const n = path.normalize(r);
+      if (!files.has(n)) { files.add(n); queue.push(n); }
+    }
+  }
+
+  const map = {};
+  for (const f of files) {
+    try { collectFile(ts, f, map); } catch { /* keep going */ }
+  }
+  return map;
+}
+
+module.exports = { collectConstEnumDefines };

package/lib/css.js

@@ -1,7 +1,7 @@
 "use strict";
 /*
  * Native CSS pipeline (webpack's css-loader/style-loader emit webpack-runtime-coupled output that a
- * non-webpack bundler can't consume, so rollpack handles CSS itself, Vite-style):
+ * non-webpack bundler can't consume, so @rustwrap/webpack handles CSS itself, Vite-style):
  *   - .scss/.sass -> compiled with the consumer's `sass` (or node-sass) if available.
  *   - .less       -> compiled with the consumer's `less` if available.
  *   - .css        -> used as-is.
@@ -27,7 +27,7 @@ function compile(resource, context, compilation) {
       if (sass && sass.compile) return sass.compile(resource, { style: "compressed", loadPaths: [path.dirname(resource)] }).css;
       const nodeSass = resolveFrom("node-sass", dirs);
       if (nodeSass && nodeSass.renderSync) return nodeSass.renderSync({ file: resource, outputStyle: "compressed" }).css.toString();
-      compilation && compilation.warnings.push({ message: `rollpack: no 'sass' available to compile ${path.basename(resource)} — emitting empty CSS` });
+      compilation && compilation.warnings.push({ message: `@rustwrap/webpack: no 'sass' available to compile ${path.basename(resource)} — emitting empty CSS` });
       return "";
     }
     if (ext === ".less") {
@@ -37,7 +37,7 @@ function compile(resource, context, compilation) {
     }
     return fs.readFileSync(resource, "utf8");
   } catch (e) {
-    compilation && compilation.errors.push({ message: `rollpack CSS (${path.basename(resource)}): ${e && e.message || e}` });
+    compilation && compilation.errors.push({ message: `@rustwrap/webpack CSS (${path.basename(resource)}): ${e && e.message || e}` });
     return "";
   }
 }
@@ -91,7 +91,7 @@ async function handleCss(resource, cfg, compilation, prod, context, extract) {
     return { code: exportDefault, moduleType: "js" };
   }
 
-  const inject = `(function(){if(typeof document==='undefined')return;var c=${JSON.stringify(css)};if(!c)return;var s=document.createElement('style');s.setAttribute('data-rollpack','');s.appendChild(document.createTextNode(c));document.head.appendChild(s);})();`;
+  const inject = `(function(){if(typeof document==='undefined')return;var c=${JSON.stringify(css)};if(!c)return;var s=document.createElement('style');s.setAttribute('data-rustwrap','');s.appendChild(document.createTextNode(c));document.head.appendChild(s);})();`;
   return { code: `${inject}\n${exportDefault}`, moduleType: "js" };
 }
 

package/lib/dev-server.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- * rollpack dev server — a webpack-dev-server-shaped dev server over the rollpack Compiler.
+ * @rustwrap/webpack dev server — a webpack-dev-server-shaped dev server over the @rustwrap/webpack Compiler.
  *
  * It serves the compiled assets (+ static dirs) over HTTP, watches sources and rebuilds via the
  * Compiler, and pushes updates to the browser over Server-Sent Events. The injected client either
@@ -27,7 +27,7 @@ function mime(file) { return MIME[path.extname(file).toLowerCase()] || "applicat
 // Browser client: connects SSE, applies hot dispose handlers, then reloads on each successful build.
 const CLIENT = `(function(){
   if (typeof window === "undefined" || !window.EventSource) return;
-  var hot = window.__rollpack_hot__ || (window.__rollpack_hot__ = (function(){
+  var hot = window.__rustwrap_hot__ || (window.__rustwrap_hot__ = (function(){
     var accepts = [], disposes = [], statusHandlers = [], status = "idle", data = {};
     function setStatus(s){ status = s; statusHandlers.forEach(function(h){ try { h(s); } catch(e){} }); }
     return {
@@ -40,15 +40,15 @@ const CLIENT = `(function(){
     };
   })());
   var first = true;
-  var es = new EventSource("/__rollpack_sse");
+  var es = new EventSource("/__rustwrap_sse");
   es.addEventListener("message", function(ev){
     var msg; try { msg = JSON.parse(ev.data); } catch(e){ return; }
     if (msg.type === "connected") { first = false; return; }
-    if (msg.type === "errors") { console.error("%c[rollpack] build failed", "color:red", "\\n" + (msg.errors||[]).join("\\n")); return; }
+    if (msg.type === "errors") { console.error("%c[@rustwrap/webpack] build failed", "color:red", "\\n" + (msg.errors||[]).join("\\n")); return; }
     if (msg.type === "ok") {
       hot._setStatus("check");
       try { hot._disposes.forEach(function(cb){ try { cb(hot.data); } catch(e){} }); } catch(e){}
-      console.log("[rollpack] update — reloading");
+      console.log("[@rustwrap/webpack] update — reloading");
       hot._setStatus("apply");
       location.reload();
     }
@@ -68,7 +68,7 @@ function normalizeStatic(stat, context) {
 }
 
 function injectClient(html) {
-  const tag = `<script src="/__rollpack_hmr_client.js"></script>`;
+  const tag = `<script src="/__rustwrap_hmr_client.js"></script>`;
   if (/<\/body>/i.test(html)) return html.replace(/<\/body>/i, tag + "</body>");
   if (/<\/head>/i.test(html)) return html.replace(/<\/head>/i, tag + "</head>");
   return html + "\n" + tag;
@@ -98,14 +98,14 @@ class DevServer {
       historyApiFallback: o.historyApiFallback,
     };
     // Enable hot defines for the build.
-    if (o.hot !== false) { compiler.$rollpack = compiler.$rollpack || {}; compiler.$rollpack.hot = true; }
+    if (o.hot !== false) { compiler.$rustwrap = compiler.$rustwrap || {}; compiler.$rustwrap.hot = true; }
 
     this.server = http.createServer((req, res) => this.handle(req, res, ctx));
     return new Promise((resolve) => {
       this.server.listen(port, host, () => {
         const actualPort = (this.server.address() && this.server.address().port) || port;
         const url = `http://${host === "0.0.0.0" ? "localhost" : host}:${actualPort}/`;
-        console.log(`\x1b[36m\x1b[1mrollpack\x1b[0m dev server running at \x1b[33m${url}\x1b[0m`);
+        console.log(`\x1b[36m\x1b[1m@rustwrap/webpack\x1b[0m dev server running at \x1b[33m${url}\x1b[0m`);
         // Build + watch, push updates to clients.
         this.watching = compiler.watch(compiler.options.watchOptions || {}, (err, stats) => {
           if (err) { console.error(err); return; }
@@ -128,8 +128,8 @@ class DevServer {
 
   handle(req, res, ctx) {
     const url = decodeURIComponent((req.url || "/").split("?")[0]);
-    if (url === "/__rollpack_sse") return this.sse(res);
-    if (url === "/__rollpack_hmr_client.js") { res.writeHead(200, { "Content-Type": "application/javascript", "Cache-Control": "no-cache" }); return res.end(CLIENT); }
+    if (url === "/__rustwrap_sse") return this.sse(res);
+    if (url === "/__rustwrap_hmr_client.js") { res.writeHead(200, { "Content-Type": "application/javascript", "Cache-Control": "no-cache" }); return res.end(CLIENT); }
     const rel = url.replace(/^\/+/, "") || "index.html";
     const bases = [ctx.outDir, ...ctx.staticDirs];
     for (const b of bases) if (this.serveFile(path.join(b, rel), res)) return;
@@ -138,7 +138,7 @@ class DevServer {
       for (const b of bases) if (this.serveFile(path.join(b, "index.html"), res)) return;
     }
     res.writeHead(404, { "Content-Type": "text/plain" });
-    res.end("rollpack dev server: not found — " + url);
+    res.end("@rustwrap/webpack dev server: not found — " + url);
   }
 
   serveFile(file, res) {

package/lib/index.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- * rollpack — a webpack-compatible Node API and CLI backed by the Rolldown bundler.
+ * @rustwrap/webpack — a webpack-compatible Node API and CLI backed by the Rolldown bundler.
  *
  * This is the public entry: the `webpack(options, callback)` factory, the Compiler/Compilation
  * lifecycle (tapable hooks, so real plugins run), and the full `webpack.*` namespace. The actual
@@ -32,11 +32,11 @@ function webpack(options, callback) {
 function createCompiler(options) {
   const context = options.context || process.cwd();
   const compiler = new Compiler(context, options);
-  compiler.$rollpack = { define: {}, provide: {}, ignore: [], normalReplace: [] };
+  compiler.$rustwrap = { define: {}, provide: {}, ignore: [], normalReplace: [] };
   compiler.hooks.environment.call();
   compiler.hooks.afterEnvironment.call();
 
-  // Apply user plugins (real apply(compiler) — taps hooks / populates $rollpack).
+  // Apply user plugins (real apply(compiler) — taps hooks / populates $rustwrap).
   for (const p of options.plugins || []) {
     try {
       if (p && typeof p.apply === "function") p.apply(compiler);
@@ -47,16 +47,16 @@ function createCompiler(options) {
   compiler.hooks.afterResolvers.call(compiler);
 
   // The make phase: Rolldown build -> compilation.assets.
-  compiler.hooks.make.tapPromise("rollpack", (compilation) => runMake(compilation, options, context));
+  compiler.hooks.make.tapPromise("rustwrap", (compilation) => runMake(compilation, options, context));
 
   // After assets are produced: performance hints + ignoreWarnings (before Stats is created).
-  compiler.hooks.afterEmit.tapPromise("rollpack:post", async (compilation) => {
+  compiler.hooks.afterEmit.tapPromise("rustwrap:post", async (compilation) => {
     applyPerformance(options, compilation);
     filterWarnings(options, compilation);
   });
 
   // Default console summary (unless stats are silenced).
-  compiler.hooks.done.tapPromise("rollpack:summary", async (stats) => {
+  compiler.hooks.done.tapPromise("rustwrap:summary", async (stats) => {
     const quiet = options.stats === false || options.stats === "none" || options.stats === "errors-only"
       || (options.infrastructureLogging && (options.infrastructureLogging.level === "none" || options.infrastructureLogging.level === "error"));
     if (!quiet) printSummary(stats);
@@ -95,7 +95,7 @@ function printSummary(stats) {
   const total = (j.assets || []).reduce((s, a) => s + a.size, 0);
   for (const e of j.errors || []) console.log(`${C.y}ERROR${C.r} ${e.message}`);
   for (const w of j.warnings || []) console.log(`${C.y}WARNING${C.r} ${w.message}`);
-  console.log(`${C.c}${C.b}rollpack${C.r} ${C.g}${(j.assets || []).length} assets${C.r} ${C.m}${fmtSize(total)}${C.r} ${C.d}via rolldown in${C.r} ${C.y}${fmtTime(j.time || 0)}${C.r}`);
+  console.log(`${C.c}${C.b}@rustwrap/webpack${C.r} ${C.g}${(j.assets || []).length} assets${C.r} ${C.m}${fmtSize(total)}${C.r} ${C.d}via rolldown in${C.r} ${C.y}${fmtTime(j.time || 0)}${C.r}`);
   for (const a of j.assets || []) console.log(`  ${C.d}asset${C.r} ${C.c}${a.name}${C.r}  ${C.m}${fmtSize(a.size)}${C.r}`);
 }
 

package/lib/loaders.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- * rollpack loader system — runs real webpack loader chains (module.rules) via loader-runner, so
+ * @rustwrap/webpack loader system — runs real webpack loader chains (module.rules) via loader-runner, so
  * css-loader/style-loader/sass-loader/@svgr/raw-loader/url-loader/file-loader/custom loaders work.
  *
  * JS/TS/JSX transpilation is left to Rolldown/Oxc (faster, equivalent output), so the well-known
@@ -129,7 +129,7 @@ function loaderPlugin(cfg, context, compilation) {
   const cssExtract = require("./css").cssExtractEnabled(cfg);
   const hasRules = buckets.pre.length || buckets.normal.length || buckets.post.length || (buckets._oneOf && buckets._oneOf.length);
   return {
-    name: "rollpack:loaders",
+    name: "rustwrap:loaders",
     async load(id) {
       const [resource, query] = id.split("?");
       // Native CSS pipeline, independent of configured css/style loaders.

package/lib/plugins.js

@@ -1,7 +1,7 @@
 "use strict";
 /*
  * Built-in webpack plugins. Bundler-affecting plugins (Define/Provide/Environment/Ignore/
- * NormalModuleReplacement) populate `compiler.$rollpack`, which build.js reads during the Rolldown
+ * NormalModuleReplacement) populate `compiler.$rustwrap`, which build.js reads during the Rolldown
  * make phase. Asset-affecting plugins (Banner) tap compilation.processAssets. The rest are faithful
  * no-ops or thin shims so configs load and run.
  */
@@ -18,14 +18,14 @@ function flattenDefinitions(defs, prefix, out) {
 
 class DefinePlugin {
   constructor(definitions) { this.definitions = definitions || {}; }
-  apply(compiler) { Object.assign(compiler.$rollpack.define, flattenDefinitions(this.definitions, "", {})); }
+  apply(compiler) { Object.assign(compiler.$rustwrap.define, flattenDefinitions(this.definitions, "", {})); }
 }
 DefinePlugin.runtimeValue = (fn, deps) => { const v = fn({}); return typeof v === "string" ? v : JSON.stringify(v); };
 
 class EnvironmentPlugin {
   constructor(...keys) { this.keys = Array.isArray(keys[0]) ? keys[0] : (typeof keys[0] === "object" ? keys[0] : keys); }
   apply(compiler) {
-    const d = compiler.$rollpack.define;
+    const d = compiler.$rustwrap.define;
     if (Array.isArray(this.keys)) for (const k of this.keys) d[`process.env.${k}`] = JSON.stringify(process.env[k] !== undefined ? process.env[k] : "");
     else for (const [k, def] of Object.entries(this.keys)) d[`process.env.${k}`] = JSON.stringify(process.env[k] !== undefined ? process.env[k] : def);
   }
@@ -33,7 +33,7 @@ class EnvironmentPlugin {
 
 class ProvidePlugin {
   constructor(definitions) { this.definitions = definitions || {}; }
-  apply(compiler) { Object.assign(compiler.$rollpack.provide, this.definitions); }
+  apply(compiler) { Object.assign(compiler.$rustwrap.provide, this.definitions); }
 }
 
 class BannerPlugin {
@@ -69,12 +69,12 @@ class BannerPlugin {
 
 class IgnorePlugin {
   constructor(options) { this.options = (options && options.resourceRegExp) ? options : { resourceRegExp: options && options.checkResource ? undefined : options, checkResource: options && options.checkResource }; }
-  apply(compiler) { compiler.$rollpack.ignore.push(this.options); }
+  apply(compiler) { compiler.$rustwrap.ignore.push(this.options); }
 }
 
 class NormalModuleReplacementPlugin {
   constructor(resourceRegExp, newResource) { this.resourceRegExp = resourceRegExp; this.newResource = newResource; }
-  apply(compiler) { compiler.$rollpack.normalReplace.push([this.resourceRegExp, this.newResource]); }
+  apply(compiler) { compiler.$rustwrap.normalReplace.push([this.resourceRegExp, this.newResource]); }
 }
 
 class ContextReplacementPlugin {
@@ -110,7 +110,7 @@ class RuntimeChunkPlugin extends NoopPlugin {}
 class SplitChunksPlugin extends NoopPlugin {}
 class WatchIgnorePlugin extends NoopPlugin {}
 class LoaderOptionsPlugin extends NoopPlugin {}
-class HotModuleReplacementPlugin { apply(compiler) { compiler.$rollpack = compiler.$rollpack || {}; compiler.$rollpack.hot = true; } }
+class HotModuleReplacementPlugin { apply(compiler) { compiler.$rustwrap = compiler.$rustwrap || {}; compiler.$rustwrap.hot = true; } }
 class DllPlugin extends NoopPlugin {}
 class DllReferencePlugin extends NoopPlugin {}
 class HashedModuleIdsPlugin extends NoopPlugin {}

package/lib/shims/global.js

@@ -0,0 +1,8 @@
+// Browser `global` shim (parity with webpack, which maps `global` -> the global object).
+export default (typeof globalThis !== "undefined"
+  ? globalThis
+  : typeof self !== "undefined"
+    ? self
+    : typeof window !== "undefined"
+      ? window
+      : this);

package/lib/shims/process.js

@@ -0,0 +1,31 @@
+// Browser `process` shim (parity with webpack's process/browser). Covers what readable-stream and
+// most Node-assuming libraries touch (nextTick, env, platform, versions, no-op event methods).
+var process = {
+  env: {},
+  argv: [],
+  browser: true,
+  platform: "browser",
+  arch: "browser",
+  version: "",
+  versions: {},
+  title: "browser",
+  nextTick: function (cb) {
+    var args = [].slice.call(arguments, 1);
+    var run = function () { cb.apply(null, args); };
+    (typeof queueMicrotask !== "undefined" ? queueMicrotask : function (f) { setTimeout(f, 0); })(run);
+  },
+  cwd: function () { return "/"; },
+  chdir: function () {},
+  on: function () { return process; },
+  once: function () { return process; },
+  off: function () { return process; },
+  addListener: function () { return process; },
+  removeListener: function () { return process; },
+  removeAllListeners: function () { return process; },
+  emit: function () { return false; },
+  prependListener: function () { return process; },
+  listeners: function () { return []; },
+  binding: function () { throw new Error("process.binding is not supported in the browser"); },
+  umask: function () { return 0; },
+};
+export default process;

package/lib/stats.js

@@ -21,7 +21,7 @@ function createStats(compilation) {
     toJson(opts) {
       return {
         version: require("../package.json").version,
-        rollpack: true,
+        rustwrap: true,
         hash: compilation.hash || "",
         time,
         builtAt: Date.now(),
@@ -47,7 +47,7 @@ function createStats(compilation) {
       for (const e of errors) lines.push(`${C.y}ERROR${C.r} ` + (e.message || String(e)));
       for (const w of warnings) lines.push(`${C.y}WARNING${C.r} ` + (w.message || String(w)));
       const total = assetList.reduce((s, a) => s + a.size, 0);
-      lines.push(`${C.c}rollpack${C.r} ${C.g}${assetList.length} assets${C.r} ${C.d}${fmt(total)} in ${time}ms${C.r}`);
+      lines.push(`${C.c}@rustwrap/webpack${C.r} ${C.g}${assetList.length} assets${C.r} ${C.d}${fmt(total)} in ${time}ms${C.r}`);
       for (const a of assetList) lines.push(`  ${C.d}asset${C.r} ${C.c}${a.name}${C.r}  ${fmt(a.size)}`);
       return lines.join("\n");
     },

package/package.json

@@ -1,45 +1,46 @@
-{
-  "name": "@rustwrap/webpack",
-  "version": "1.0.2",
-  "description": "A webpack-compatible Node API and CLI backed by the Rolldown bundler (Rust/Oxc) for fast builds and excellent tree-shaking. Drop-in `webpack` override for pcf-scripts and webpack-based pipelines.",
-  "main": "lib/index.js",
-  "publishConfig": {
-    "access": "public"
-  },
-  "scripts": {
-    "test": "node test/run.js"
-  },
-  "bin": {
-    "webpack": "bin/rollpack.js",
-    "rollpack": "bin/rollpack.js"
-  },
-  "files": [
-    "lib/",
-    "bin/",
-    "README.md"
-  ],
-  "dependencies": {
-    "acorn": "^8.17.0",
-    "eslint-scope": "^9.1.2",
-    "loader-runner": "^4.3.2",
-    "mime-types": "^3.0.2",
-    "postcss": "^8.5.16",
-    "postcss-modules": "^6.0.1",
-    "rolldown": "^1.1.3",
-    "schema-utils": "^4.3.3",
-    "tapable": "^2.3.3",
-    "terser-webpack-plugin": "^5.6.1",
-    "webpack-sources": "^3.5.0"
-  },
-  "keywords": [
-    "webpack",
-    "rolldown",
-    "bundler",
-    "pcf",
-    "tree-shaking"
-  ],
-  "license": "MIT",
-  "engines": {
-    "node": "^20.19.0 || ^22.13.0 || >=24"
-  }
-}
+{
+  "name": "@rustwrap/webpack",
+  "version": "1.0.3",
+  "description": "A webpack-compatible Node API and CLI backed by the Rolldown bundler (Rust/Oxc) for fast builds and excellent tree-shaking. Drop-in `webpack` override for pcf-scripts and webpack-based pipelines.",
+  "main": "lib/index.js",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "test": "node test/run.js"
+  },
+  "bin": {
+    "webpack": "bin/rustwrap-webpack.js",
+    "rustwrap-webpack": "bin/rustwrap-webpack.js"
+  },
+  "files": [
+    "lib/",
+    "bin/",
+    "README.md"
+  ],
+  "dependencies": {
+    "acorn": "^8.17.0",
+    "eslint-scope": "^9.1.2",
+    "loader-runner": "^4.3.2",
+    "mime-types": "^3.0.2",
+    "postcss": "^8.5.16",
+    "postcss-modules": "^6.0.1",
+    "rolldown": "^1.1.3",
+    "schema-utils": "^4.3.3",
+    "tapable": "^2.3.3",
+    "terser-webpack-plugin": "^5.6.1",
+    "webpack-sources": "^3.5.0",
+    "buffer": "^6.0.3"
+  },
+  "keywords": [
+    "webpack",
+    "rolldown",
+    "bundler",
+    "pcf",
+    "tree-shaking"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": "^20.19.0 || ^22.13.0 || >=24"
+  }
+}