@rustwrap/webpack 1.0.1

package/lib/dev-server.js

@@ -0,0 +1,176 @@
+"use strict";
+/*
+ * rollpack dev server — a webpack-dev-server-shaped dev server over the rollpack 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
+ * triggers a fast full reload (live-reload) or, when `hot` is enabled, runs registered
+ * `module.hot` dispose handlers first. Granular state-preserving HMR is not possible on a
+ * whole-bundle engine, so hot updates fall back to a reload (documented).
+ *
+ * Constructor is compatible with `new WebpackDevServer(options, compiler)` (and the legacy
+ * `(compiler, options)` order).
+ */
+const http = require("http");
+const fs = require("fs");
+const path = require("path");
+
+const MIME = {
+  ".html": "text/html", ".js": "application/javascript", ".mjs": "application/javascript",
+  ".css": "text/css", ".json": "application/json", ".map": "application/json", ".svg": "image/svg+xml",
+  ".png": "image/png", ".jpg": "image/jpeg", ".jpeg": "image/jpeg", ".gif": "image/gif",
+  ".webp": "image/webp", ".ico": "image/x-icon", ".woff": "font/woff", ".woff2": "font/woff2",
+  ".ttf": "font/ttf", ".wasm": "application/wasm", ".txt": "text/plain",
+};
+function mime(file) { return MIME[path.extname(file).toLowerCase()] || "application/octet-stream"; }
+
+// 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 accepts = [], disposes = [], statusHandlers = [], status = "idle", data = {};
+    function setStatus(s){ status = s; statusHandlers.forEach(function(h){ try { h(s); } catch(e){} }); }
+    return {
+      _accepts: accepts, _disposes: disposes,
+      accept: function(dep, cb){ if (typeof dep === "function" || dep == null) { accepts.push(dep || function(){}); } else { accepts.push(cb || function(){}); } },
+      decline: function(){}, dispose: function(cb){ disposes.push(cb); }, addDisposeHandler: function(cb){ disposes.push(cb); },
+      removeDisposeHandler: function(){}, invalidate: function(){ location.reload(); },
+      data: data, status: function(){ return status; }, addStatusHandler: function(cb){ statusHandlers.push(cb); }, removeStatusHandler: function(){},
+      apply: function(){ return Promise.resolve([]); }, check: function(){ return Promise.resolve(null); }, _setStatus: setStatus,
+    };
+  })());
+  var first = true;
+  var es = new EventSource("/__rollpack_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 === "ok") {
+      hot._setStatus("check");
+      try { hot._disposes.forEach(function(cb){ try { cb(hot.data); } catch(e){} }); } catch(e){}
+      console.log("[rollpack] update — reloading");
+      hot._setStatus("apply");
+      location.reload();
+    }
+  });
+  es.addEventListener("error", function(){ /* EventSource auto-retries */ });
+})();`;
+
+function normalizeStatic(stat, context) {
+  if (stat === false) return [];
+  if (stat == null) return [path.join(context, "public"), context];
+  const arr = Array.isArray(stat) ? stat : [stat];
+  return arr.map((s) => {
+    if (typeof s === "string") return path.isAbsolute(s) ? s : path.resolve(context, s);
+    if (s && s.directory) return path.isAbsolute(s.directory) ? s.directory : path.resolve(context, s.directory);
+    return context;
+  });
+}
+
+function injectClient(html) {
+  const tag = `<script src="/__rollpack_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;
+}
+
+class DevServer {
+  constructor(options, compiler) {
+    // Support both `new DevServer(options, compiler)` and legacy `(compiler, options)`.
+    if (options && (typeof options.run === "function" || options.hooks)) { const t = options; options = compiler; compiler = t; }
+    this.options = options || {};
+    this.compiler = compiler;
+    this.sseClients = new Set();
+    this.server = null;
+    this.watching = null;
+    this.lastHash = "";
+  }
+
+  start(cb) {
+    const o = this.options;
+    const compiler = this.compiler;
+    const port = o.port != null ? o.port : 8080;
+    const host = o.host || "localhost";
+    const context = compiler.context;
+    const ctx = {
+      outDir: compiler.outputPath,
+      staticDirs: normalizeStatic(o.static, context),
+      historyApiFallback: o.historyApiFallback,
+    };
+    // Enable hot defines for the build.
+    if (o.hot !== false) { compiler.$rollpack = compiler.$rollpack || {}; compiler.$rollpack.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`);
+        // Build + watch, push updates to clients.
+        this.watching = compiler.watch(compiler.options.watchOptions || {}, (err, stats) => {
+          if (err) { console.error(err); return; }
+          this.lastHash = (stats && stats.toJson && stats.toJson().hash) || String(Date.now());
+          this.broadcast(stats);
+        });
+        if (cb) cb(null, this);
+        resolve(this);
+      });
+    });
+  }
+
+  broadcast(stats) {
+    const hasErrors = stats && stats.hasErrors && stats.hasErrors();
+    const payload = JSON.stringify(hasErrors
+      ? { type: "errors", hash: this.lastHash, errors: (stats.toJson().errors || []).map((e) => e.message) }
+      : { type: "ok", hash: this.lastHash });
+    for (const res of this.sseClients) { try { res.write(`data: ${payload}\n\n`); } catch (_) {} }
+  }
+
+  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); }
+    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;
+    // SPA history fallback to index.html for extension-less routes.
+    if (ctx.historyApiFallback !== false && !path.extname(rel)) {
+      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);
+  }
+
+  serveFile(file, res) {
+    try {
+      if (!fs.existsSync(file) || !fs.statSync(file).isFile()) return false;
+      const type = mime(file);
+      let body = fs.readFileSync(file);
+      if (type === "text/html") body = Buffer.from(injectClient(body.toString("utf8")));
+      res.writeHead(200, { "Content-Type": type, "Cache-Control": "no-cache" });
+      res.end(body);
+      return true;
+    } catch (_) { return false; }
+  }
+
+  sse(res) {
+    res.writeHead(200, { "Content-Type": "text/event-stream", "Cache-Control": "no-cache", Connection: "keep-alive", "Access-Control-Allow-Origin": "*" });
+    res.write("retry: 1000\n\n");
+    res.write(`data: ${JSON.stringify({ type: "connected" })}\n\n`);
+    this.sseClients.add(res);
+    res.on("close", () => this.sseClients.delete(res));
+  }
+
+  // webpack-dev-server v4 API
+  startCallback(cb) { this.start().then(() => cb && cb(), cb); }
+  stopCallback(cb) { this.stop().then(() => cb && cb(), cb); }
+  async stop() {
+    if (this.watching) await new Promise((r) => this.watching.close(r));
+    for (const r of this.sseClients) { try { r.end(); } catch (_) {} }
+    this.sseClients.clear();
+    if (this.server) await new Promise((r) => this.server.close(r));
+  }
+  close(cb) { this.stop().then(() => cb && cb(), cb); }
+}
+
+module.exports = DevServer;

package/lib/empty-module.js

@@ -0,0 +1,2 @@
+// Empty module used for `resolve.fallback[x] = false`, IgnorePlugin, and null-loader equivalents.
+module.exports = {};

package/lib/index.js

@@ -0,0 +1,162 @@
+"use strict";
+/*
+ * rollpack — 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
+ * bundling + tree-shaking is done by Rolldown (see build.js); the rest of this package translates
+ * the webpack config/API surface.
+ */
+const crypto = require("crypto");
+const { Compiler, Compilation, MultiCompiler, sources } = require("./compiler");
+const { runMake } = require("./build");
+const plugins = require("./plugins");
+
+function webpack(options, callback) {
+  if (typeof options === "function") options = options(process.env, {}) || {};
+  let compiler;
+  if (Array.isArray(options)) compiler = new MultiCompiler(options.map((o) => createCompiler(o || {})));
+  else compiler = createCompiler(options || {});
+  if (typeof callback === "function") {
+    const watch = Array.isArray(options) ? options.some((o) => o && o.watch) : options.watch;
+    if (watch) {
+      const wo = Array.isArray(options) ? (options[0].watchOptions || {}) : (options.watchOptions || {});
+      return compiler.watch(wo, callback);
+    }
+    compiler.run(callback);
+    return compiler;
+  }
+  return compiler;
+}
+
+function createCompiler(options) {
+  const context = options.context || process.cwd();
+  const compiler = new Compiler(context, options);
+  compiler.$rollpack = { define: {}, provide: {}, ignore: [], normalReplace: [] };
+  compiler.hooks.environment.call();
+  compiler.hooks.afterEnvironment.call();
+
+  // Apply user plugins (real apply(compiler) — taps hooks / populates $rollpack).
+  for (const p of options.plugins || []) {
+    try {
+      if (p && typeof p.apply === "function") p.apply(compiler);
+      else if (typeof p === "function") p.call(compiler, compiler);
+    } catch (e) { /* a plugin that needs deep webpack internals — keep building */ }
+  }
+  compiler.hooks.afterPlugins.call(compiler);
+  compiler.hooks.afterResolvers.call(compiler);
+
+  // The make phase: Rolldown build -> compilation.assets.
+  compiler.hooks.make.tapPromise("rollpack", (compilation) => runMake(compilation, options, context));
+
+  // After assets are produced: performance hints + ignoreWarnings (before Stats is created).
+  compiler.hooks.afterEmit.tapPromise("rollpack:post", async (compilation) => {
+    applyPerformance(options, compilation);
+    filterWarnings(options, compilation);
+  });
+
+  // Default console summary (unless stats are silenced).
+  compiler.hooks.done.tapPromise("rollpack: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);
+  });
+
+  return compiler;
+}
+
+function applyPerformance(options, compilation) {
+  const perf = options.performance;
+  if (!perf || perf.hints === false) return;
+  const max = perf.maxAssetSize || 250000;
+  for (const name of Object.keys(compilation.assets)) {
+    if (!/\.(js|mjs|cjs|css)$/.test(name)) continue;
+    const size = bytes(compilation.assets[name].source());
+    if (size > max) {
+      const msg = `asset ${name} (${(size / 1024) | 0} KiB) exceeds the recommended size limit (${(max / 1024) | 0} KiB)`;
+      (perf.hints === "error" ? compilation.errors : compilation.warnings).push({ message: msg });
+    }
+  }
+}
+
+function filterWarnings(options, compilation) {
+  const ig = options.ignoreWarnings;
+  if (!ig || !ig.length) return;
+  compilation.warnings = compilation.warnings.filter((w) => !ig.some((rule) =>
+    rule instanceof RegExp ? rule.test(w.message || "") : (typeof rule === "function" ? rule(w, compilation) : false)));
+}
+
+function bytes(c) { return Buffer.isBuffer(c) ? c.length : Buffer.byteLength(String(c), "utf8"); }
+function fmtSize(b) { return b > 1048576 ? (b / 1048576).toFixed(2) + " MiB" : (b / 1024).toFixed(1) + " KiB"; }
+function fmtTime(ms) { return ms >= 1000 ? (ms / 1000).toFixed(2) + "s" : ms + "ms"; }
+const C = (process.stdout.isTTY || process.env.FORCE_COLOR) ? { d: "\x1b[2m", b: "\x1b[1m", g: "\x1b[32m", c: "\x1b[36m", y: "\x1b[33m", m: "\x1b[35m", r: "\x1b[0m" } : { d: "", b: "", g: "", c: "", y: "", m: "", r: "" };
+function printSummary(stats) {
+  const j = stats.toJson();
+  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}`);
+  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}`);
+}
+
+// ---------------------------------------------------------------------------------------------
+// Public namespace (webpack.*)
+// ---------------------------------------------------------------------------------------------
+class WebpackError extends Error { constructor(msg) { super(msg); this.name = "WebpackError"; } }
+
+webpack.webpack = webpack;
+webpack.Compiler = Compiler;
+webpack.Compilation = Compilation;
+webpack.MultiCompiler = MultiCompiler;
+webpack.sources = sources;
+webpack.WebpackError = WebpackError;
+webpack.version = require("../package.json").version;
+webpack.util = {
+  createHash: (algo) => {
+    const norm = (algo === "xxhash64" || algo === "md4") ? (crypto.getHashes().includes("md4") ? "md4" : "sha256") : (algo || "sha256");
+    try { return crypto.createHash(norm); } catch (_) { return crypto.createHash("sha256"); }
+  },
+};
+webpack.ModuleFilenameHelpers = {
+  matchPart: (str, test) => test == null ? true : (test instanceof RegExp ? test.test(str) : (typeof test === "string" ? str.includes(test) : !!test)),
+  matchObject: (obj, str) => {
+    if (!obj) return true;
+    if (obj.test && !webpack.ModuleFilenameHelpers.matchPart(str, obj.test)) return false;
+    if (obj.include && !webpack.ModuleFilenameHelpers.matchPart(str, obj.include)) return false;
+    if (obj.exclude && webpack.ModuleFilenameHelpers.matchPart(str, obj.exclude)) return false;
+    return true;
+  },
+};
+webpack.RuntimeGlobals = {};
+webpack.DevServer = require("./dev-server.js");
+
+// Built-in plugins
+Object.assign(webpack, {
+  DefinePlugin: plugins.DefinePlugin,
+  EnvironmentPlugin: plugins.EnvironmentPlugin,
+  ProvidePlugin: plugins.ProvidePlugin,
+  BannerPlugin: plugins.BannerPlugin,
+  IgnorePlugin: plugins.IgnorePlugin,
+  NormalModuleReplacementPlugin: plugins.NormalModuleReplacementPlugin,
+  ContextReplacementPlugin: plugins.ContextReplacementPlugin,
+  SourceMapDevToolPlugin: plugins.SourceMapDevToolPlugin,
+  EvalSourceMapDevToolPlugin: plugins.EvalSourceMapDevToolPlugin,
+  ProgressPlugin: plugins.ProgressPlugin,
+  LoaderOptionsPlugin: plugins.LoaderOptionsPlugin,
+  HotModuleReplacementPlugin: plugins.HotModuleReplacementPlugin,
+  WatchIgnorePlugin: plugins.WatchIgnorePlugin,
+  DllPlugin: plugins.DllPlugin,
+  DllReferencePlugin: plugins.DllReferencePlugin,
+  HashedModuleIdsPlugin: plugins.HashedModuleIdsPlugin,
+  NamedModulesPlugin: plugins.NamedModulesPlugin,
+  NamedChunksPlugin: plugins.NamedChunksPlugin,
+  NoEmitOnErrorsPlugin: plugins.NoEmitOnErrorsPlugin,
+});
+webpack.optimize = plugins.optimize;
+webpack.container = plugins.container;
+webpack.sharing = {};
+webpack.web = {};
+webpack.node = {};
+webpack.ids = { HashedModuleIdsPlugin: plugins.HashedModuleIdsPlugin };
+
+module.exports = webpack;

package/lib/loaders.js

@@ -0,0 +1,211 @@
+"use strict";
+/*
+ * rollpack 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
+ * transpile-only loaders (ts-loader, babel-loader, swc-loader, esbuild-loader) are filtered OUT of
+ * chains; everything else runs. A file is processed by this system only when it has a non-empty
+ * remaining loader chain.
+ */
+const path = require("path");
+const fs = require("fs");
+const { runLoaders } = require("loader-runner");
+
+const SKIP_LOADERS = /[\\/](ts-loader|babel-loader|swc-loader|esbuild-loader|@swc[\\/]loader|style-loader|css-loader|sass-loader|less-loader|postcss-loader|mini-css-extract-plugin)[\\/]/i;
+const JS_EXT = /\.(jsx?|mjs|cjs|tsx?|mts|cts)$/i;
+
+// Flatten module.rules into pre/normal/post buckets, resolving `oneOf` and nested `rules`.
+function flattenRules(rules, out) {
+  for (const r of rules || []) {
+    if (!r) continue;
+    if (r.oneOf) { out._oneOf = out._oneOf || []; out._oneOf.push(r.oneOf); }
+    flattenRule(r, out);
+    if (r.rules) flattenRules(r.rules, out);
+  }
+  return out;
+}
+function flattenRule(r, out) {
+  if (!r || (!r.test && !r.resource && !r.include && !r.exclude && !r.use && !r.loader && !r.resourceQuery)) return;
+  const bucket = r.enforce === "pre" ? out.pre : r.enforce === "post" ? out.post : out.normal;
+  bucket.push(r);
+}
+
+function ruleMatches(rule, resource, query) {
+  const cond = (c, val) => {
+    if (c == null) return undefined;
+    if (c instanceof RegExp) return c.test(val);
+    if (typeof c === "string") return val.startsWith(c) || val === c;
+    if (typeof c === "function") return !!c(val);
+    if (Array.isArray(c)) return c.some((x) => cond(x, val) === true);
+    if (typeof c === "object") {
+      if (c.and) return c.and.every((x) => cond(x, val) === true);
+      if (c.or) return c.or.some((x) => cond(x, val) === true);
+      if (c.not) return !cond(c.not, val);
+      return undefined;
+    }
+    return undefined;
+  };
+  const test = rule.test !== undefined ? cond(rule.test, resource) : (rule.resource !== undefined ? cond(rule.resource, resource) : undefined);
+  if (test === false) return false;
+  if (rule.include !== undefined && cond(rule.include, resource) !== true) return false;
+  if (rule.exclude !== undefined && cond(rule.exclude, resource) === true) return false;
+  if (rule.resourceQuery !== undefined && cond(rule.resourceQuery, query || "") !== true) return false;
+  // a rule with no positive resource condition but include/query still counts only if something matched
+  if (test === undefined && rule.include === undefined && rule.resourceQuery === undefined) return false;
+  return true;
+}
+
+// Normalize a rule's `use`/`loader` into [{loader, options, ident}], in declared order.
+function ruleUse(rule) {
+  let use = rule.use || rule.loader || rule.loaders;
+  if (!use) return [];
+  if (!Array.isArray(use)) use = [use];
+  return use.map((u) => {
+    if (typeof u === "string") return { loader: u, options: rule.options };
+    if (typeof u === "function") return { loader: "__inline_fn__", fn: u };
+    return { loader: u.loader, options: u.options, ident: u.ident };
+  }).filter((u) => u.loader);
+}
+
+function resolveLoader(name, contexts) {
+  if (path.isAbsolute(name) && fs.existsSync(name)) return name;
+  for (const base of contexts) {
+    try { return require.resolve(name, { paths: [base] }); } catch (_) {}
+    try { return require.resolve(name + "/package.json", { paths: [base] }).replace(/package\.json$/, "index.js"); } catch (_) {}
+  }
+  return null;
+}
+
+// Build the ordered loader list (post + normal + pre) for a resource, filtering transpile loaders.
+function loadersFor(resource, query, buckets, contexts) {
+  const collect = (bucketRules) => {
+    const acc = [];
+    for (const rule of bucketRules) {
+      if (!ruleMatches(rule, resource, query)) continue;
+      if (rule.type && /^asset/.test(rule.type)) { acc._assetType = rule.type; acc._parser = rule.parser; acc._generator = rule.generator; }
+      for (const u of ruleUse(rule)) acc.push(u);
+    }
+    return acc;
+  };
+  // oneOf: first matching sub-rule wins
+  let oneOfUse = [];
+  let assetMeta = null;
+  for (const group of buckets._oneOf || []) {
+    for (const rule of group) {
+      if (ruleMatches(rule, resource, query)) {
+        if (rule.type && /^asset/.test(rule.type)) assetMeta = { type: rule.type, parser: rule.parser, generator: rule.generator };
+        oneOfUse = ruleUse(rule);
+        break;
+      }
+    }
+    if (oneOfUse.length || assetMeta) break;
+  }
+  const normal = collect(buckets.normal).concat(oneOfUse);
+  const pre = collect(buckets.pre);
+  const post = collect(buckets.post);
+  if (normal._assetType && !assetMeta) assetMeta = { type: normal._assetType, parser: normal._parser, generator: normal._generator };
+  // webpack order for runLoaders: [post, normal, pre] (normal phase runs right->left, so pre first)
+  let chain = post.concat(normal).concat(pre);
+  // resolve + filter transpile-only loaders
+  chain = chain
+    .map((u) => {
+      if (u.fn) return { loader: "inline", options: u.options, normal: u.fn, pitch: u.fn.pitch };
+      const p = resolveLoader(u.loader, contexts);
+      return p ? { loader: p, options: u.options, ident: u.ident } : null;
+    })
+    .filter((u) => u && !(typeof u.loader === "string" && SKIP_LOADERS.test(u.loader)));
+  return { chain, assetMeta };
+}
+
+/*
+ * A Rolldown plugin that applies module.rules. For any resolved module whose extension is non-JS or
+ * which has a non-empty (non-transpile) loader chain, it runs the chain and returns the JS result.
+ */
+function loaderPlugin(cfg, context, compilation) {
+  const buckets = flattenRules((cfg.module && cfg.module.rules) || [], { pre: [], normal: [], post: [] });
+  const contexts = [context, process.cwd()];
+  const prod = cfg.mode !== "development";
+  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",
+    async load(id) {
+      const [resource, query] = id.split("?");
+      // Native CSS pipeline, independent of configured css/style loaders.
+      if (/\.(css|scss|sass|less)$/i.test(resource)) {
+        return require("./css").handleCss(resource, cfg, compilation, prod, context, cssExtract);
+      }
+      if (!hasRules) return null;
+      const { chain, assetMeta } = loadersFor(resource, query, buckets, contexts);
+      const isJs = JS_EXT.test(resource);
+      if (!chain.length && !assetMeta) {
+        if (isJs) return null; // let Oxc handle JS/TS natively
+        // Non-JS file with no configured loader: emit as an asset/resource (webpack-5-like default)
+        // so the build doesn't choke parsing it as JS.
+        return require("./assets").handleAsset(resource, { type: "asset/resource" }, cfg, compilation, prod);
+      }
+      // Asset module handling (type: asset/*) takes precedence when no JS-producing loaders remain.
+      if (assetMeta && !chain.length) {
+        return require("./assets").handleAsset(resource, assetMeta, cfg, compilation, prod);
+      }
+      if (!chain.length) return null;
+      const source = fs.readFileSync(resource);
+      const result = await runChain(chain, resource, source, cfg, context, compilation, prod);
+      return result;
+    },
+  };
+}
+
+function runChain(chain, resource, source, cfg, context, compilation, prod) {
+  return new Promise((resolve, reject) => {
+    runLoaders({
+      resource,
+      loaders: chain,
+      context: makeLoaderContext(cfg, context, compilation, prod, resource),
+      readResource: (_p, cb) => cb(null, source),
+    }, (err, res) => {
+      if (err) return reject(err);
+      let code = res.result && res.result[0];
+      if (code == null) return resolve({ code: "export default undefined;", moduleType: "js" });
+      if (Buffer.isBuffer(code)) code = code.toString("utf8");
+      const map = res.result && res.result[1];
+      resolve({ code: String(code), map: map && typeof map === "object" ? map : null, moduleType: "js" });
+    });
+  });
+}
+
+// A reasonable webpack NormalModule loaderContext.
+function makeLoaderContext(cfg, context, compilation, prod, resource) {
+  const dir = path.dirname(resource);
+  return {
+    rootContext: context,
+    context: dir,
+    resourcePath: resource,
+    resourceQuery: "",
+    mode: prod ? "production" : "development",
+    sourceMap: !!cfg.devtool,
+    target: cfg.target || "web",
+    hot: false,
+    webpack: true,
+    _compiler: compilation && compilation.compiler,
+    _compilation: compilation,
+    _module: { type: "javascript/auto", resource },
+    getOptions(schema) { return (this.__options) || {}; },
+    emitWarning(w) { compilation && compilation.warnings.push({ message: String(w && w.message || w) }); },
+    emitError(e) { compilation && compilation.errors.push({ message: String(e && e.message || e) }); },
+    emitFile(name, content, map, assetInfo) { compilation && compilation.emitAsset(name, content, assetInfo); },
+    addDependency() {}, dependency() {}, addContextDependency() {}, addMissingDependency() {}, clearDependencies() {},
+    getLogger() { const noop = () => {}; return new Proxy({}, { get: () => noop }); },
+    resolve(ctx, request, cb) { try { cb(null, require.resolve(request, { paths: [ctx] })); } catch (e) { cb(e); } },
+    getResolve() { return (ctx, request, cb) => { try { const p = require.resolve(request, { paths: [ctx] }); return cb ? cb(null, p) : Promise.resolve(p); } catch (e) { return cb ? cb(e) : Promise.reject(e); } }; },
+    utils: {
+      absolutify: (ctxt, p) => path.resolve(ctxt, p),
+      contextify: (ctxt, p) => path.relative(ctxt, p).replace(/\\/g, "/"),
+      createHash: () => require("crypto").createHash("md4" in require("crypto").getHashes() ? "md4" : "sha256"),
+    },
+    fs,
+  };
+}
+
+module.exports = { loaderPlugin, flattenRules, ruleMatches, loadersFor };