@@ -2,4 +2,4 @@
 "schema-utils": patch
 ---
 
-Bundle `schema-utils` without errors or warnings: `precompile` requires the `ajv` helpers it inlines by name and loads webpack's minifier without a request a bundler parses.
+Bundle `schema-utils` without errors or warnings: `precompile` requires the `ajv` helpers it inlines by name and loads webpack's minifier with Node.js's own `require`, so `minify` works from a webpack bundle too.
@@ -269,13 +269,20 @@ async function minify(code, esm) {
   let minifier;
 
   // webpack's own minifier, which writes what terser writes without loading it - the packages
-  // shipping a check already have webpack. Required through an alias of `module` so a bundler
-  // that bundles `schema-utils` neither bundles webpack nor warns about a request it cannot
-  // resolve, while Node.js resolves it like any `require` here.
+  // shipping a check already have webpack. A bundler that bundles `schema-utils` must neither
+  // bundle webpack nor warn about a request it cannot resolve, so webpack is loaded with Node.js's
+  // own `require`: the one webpack keeps as `__non_webpack_require__` inside a webpack bundle, and
+  // `module.require` through an alias of `module` outside one.
+  /* global __non_webpack_require__ */
+  // prettier-ignore
+  // @ts-expect-error a free variable only a webpack bundle defines
+  const nodeRequire = typeof __non_webpack_require__ === "function" ? __non_webpack_require__ : undefined;
   const self = module;
 
   try {
-    minifier = await self.require("webpack").javascript.syntax.printer.load();
+    minifier = await (nodeRequire || self.require.bind(self))(
+      "webpack",
+    ).javascript.syntax.printer.load();
   } catch (err) {
     throw new Error(
       "Install webpack 5.112.0 or later to minify a precompiled check",
 
@@ -0,0 +1,11 @@
+const { precompile } = require("../../src");
+
+precompile({ type: "string", minLength: 1 }, { minify: true }).then(
+  (code) => {
+    const check = { exports: {} };
+
+    // eslint-disable-next-line no-new-func
+    new Function("module", code)(check);
+    process.stdout.write(JSON.stringify([check.exports(""), check.exports("a")]));
+  },
+);
@@ -602,23 +602,27 @@ describe("precompile", () => {
 describe("bundled", () => {
   // `schema-utils` is bundled by tools that ship it inside their own code, which reaches
   // `precompile` through the `precompile` export even though it only runs at build time
-  it("should bundle without errors or warnings", (done) => {
+  it("should bundle without errors or warnings and minify from the bundle", (done) => {
     const webpack = require("webpack");
 
-    const outputPath = fs.mkdtempSync(path.join(os.tmpdir(), "schema-utils-"));
+    // Inside the package, so the bundle finds webpack the way any installed bundle does
+    const localPath = path.resolve(__dirname, "../local");
+
+    fs.mkdirSync(localPath, { recursive: true });
+
+    const outputPath = fs.mkdtempSync(path.join(localPath, "bundle-"));
 
     webpack(
       {
         mode: "none",
         target: "node",
-        context: path.resolve(__dirname, ".."),
-        entry: "./src/index.js",
+        context: __dirname,
+        entry: "./fixtures/bundled-precompile.js",
         output: { path: outputPath },
       },
       (err, stats) => {
-        remove(outputPath);
-
         if (err) {
+          remove(outputPath);
           done(err);
 
           return;
@@ -633,9 +637,18 @@ describe("bundled", () => {
 
           expect(errors.map(({ message }) => message)).toEqual([]);
           expect(warnings.map(({ message }) => message)).toEqual([]);
+          expect(
+            JSON.parse(
+              execFileSync(process.execPath, [
+                path.join(outputPath, "main.js"),
+              ]).toString(),
+            ),
+          ).toEqual([false, true]);
           done();
         } catch (error) {
           done(error);
+        } finally {
+          remove(outputPath);
         }
       },
     );