From 9c1b9fc5da8fb19ad17fc78bf710627bbf5ae715 Mon Sep 17 00:00:00 2001
From: alexander-akait <4567934+alexander-akait@users.noreply.github.com>
Date: Sat, 5 Sep 2026 12:55:42 +0000
Subject: [PATCH 1/5] fix: read the parse goal an embedded JavaScript body is
 handed out with
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

`as` names which production of JavaScript a body is written in, the way it
already names which production of CSS a `style=""` holds. The four built-in
JavaScript minimizers now read it as their own `module` option, so a module
script is not read as a classic one — and none of their engines is handed a
word it would reject outright.
---
 .changeset/embedded-javascript-parse-goal.md |   5 +
 README.md                                    |   8 ++
 src/utils.js                                 |  35 +++++-
 test/embedded-protocol.test.js               | 112 ++++++++++++++++++-
 4 files changed, 150 insertions(+), 10 deletions(-)
 create mode 100644 .changeset/embedded-javascript-parse-goal.md

diff --git a/.changeset/embedded-javascript-parse-goal.md b/.changeset/embedded-javascript-parse-goal.md
new file mode 100644
index 00000000..e259beb7
--- /dev/null
+++ b/.changeset/embedded-javascript-parse-goal.md
@@ -0,0 +1,5 @@
+---
+"minimizer-webpack-plugin": patch
+---
+
+read `as` on an embedded JavaScript body as the built-in minimizers' own `module` option, so a module script is not read as a classic one and the engine is never handed the word
diff --git a/README.md b/README.md
index 4696f079..e19c5808 100644
--- a/README.md
+++ b/README.md
@@ -1020,6 +1020,14 @@ stylesheet, so a minifier claiming `css` is handed one either way and `as` says
 which it is. Ignore it at your peril: parsing a declaration list as a stylesheet
 finds no rule and returns nothing.
 
+A `<script type="module">` arrives the same way, as **`javascript` with
+`as: "module"`**: JavaScript has two productions too, and a module script is one
+wherever it sits. The built-in JavaScript minimizers read it as their own
+`module` option, so the engine is never handed the word itself; a minify
+function of your own claiming `javascript` is handed it and decides. Ignore it
+at your peril: a module script read as a classic one is a syntax error the
+moment it holds a top-level `await`.
+
 The nested case needs a minifier that can hand its nested bodies out, which it
 also states for itself — webpack's `cssMinify` and `htmlMinify` do:
 
diff --git a/src/utils.js b/src/utils.js
index ab4d66fa..680326fd 100644
--- a/src/utils.js
+++ b/src/utils.js
@@ -338,13 +338,16 @@ async function terserMinify(
   };
 
   /**
-   * @param {import("terser").MinifyOptions=} terserOptions terser options
+   * @param {(import("terser").MinifyOptions & { as?: string })=} terserOptions terser options
    * @returns {import("terser").MinifyOptions & { sourceMap: import("terser").SourceMapOptions | undefined } & { compress: import("terser").CompressOptions } & ({ output: import("terser").FormatOptions & { beautify: boolean } } | { format: import("terser").FormatOptions & { beautify: boolean } })} built terser options
    */
-  const buildTerserOptions = (terserOptions = {}) =>
+  const buildTerserOptions = ({ as, ...terserOptions } = {}) =>
     // Need deep copy objects to avoid https://github.com/terser/terser/issues/366
     ({
       ...terserOptions,
+      // `as` names which production of JavaScript the source is, and is the
+      // source's own rather than the configuration's, so it overrides `module`.
+      ...(typeof as === "undefined" ? undefined : { module: as === "module" }),
       compress:
         typeof terserOptions.compress === "boolean"
           ? terserOptions.compress
@@ -593,10 +596,14 @@ async function uglifyJsMinify(
   };
 
   /**
-   * @param {import("uglify-js").MinifyOptions & { ecma?: number | string }=} uglifyJsOptions uglify-js options
+   * @param {import("uglify-js").MinifyOptions & { ecma?: number | string, as?: string }=} uglifyJsOptions uglify-js options
    * @returns {import("uglify-js").MinifyOptions & { sourceMap: boolean | import("uglify-js").SourceMapOptions | undefined } & { output: import("uglify-js").OutputOptions & { beautify: boolean } }} uglify-js options
    */
   const buildUglifyJsOptions = (uglifyJsOptions = {}) => {
+    // `as` names which production of JavaScript the source is. An inherited
+    // `module` is the asset's rather than the source's, so it still goes.
+    const { as } = uglifyJsOptions;
+
     if (typeof uglifyJsOptions.ecma !== "undefined") {
       delete uglifyJsOptions.ecma;
     }
@@ -605,9 +612,14 @@ async function uglifyJsMinify(
       delete uglifyJsOptions.module;
     }
 
+    if (typeof as !== "undefined") {
+      delete uglifyJsOptions.as;
+    }
+
     // Need deep copy objects to avoid https://github.com/terser/terser/issues/366
     return {
       ...uglifyJsOptions,
+      ...(typeof as === "undefined" ? undefined : { module: as === "module" }),
       // warnings: uglifyJsOptions.warnings,
       parse: { ...uglifyJsOptions.parse },
       compress:
@@ -803,13 +815,16 @@ async function swcMinify(input, sourceMap, minimizerOptions, extractComments) {
   };
 
   /**
-   * @param {import("@swc/core").JsMinifyOptions=} swcOptions swc options
+   * @param {(import("@swc/core").JsMinifyOptions & { as?: string })=} swcOptions swc options
    * @returns {import("@swc/core").JsMinifyOptions & { extractComments?: false | true | "some" | "all" | { regex: string } } & { sourceMap: undefined | boolean } & { compress: import("@swc/core").TerserCompressOptions }} built swc options
    */
-  const buildSwcOptions = (swcOptions = {}) =>
+  const buildSwcOptions = ({ as, ...swcOptions } = {}) =>
     // Need deep copy objects to avoid https://github.com/terser/terser/issues/366
     ({
       ...swcOptions,
+      // `as` names which production of JavaScript the source is, and is the
+      // source's own rather than the configuration's, so it overrides `module`.
+      ...(typeof as === "undefined" ? undefined : { module: as === "module" }),
       compress:
         typeof swcOptions.compress === "boolean"
           ? swcOptions.compress
@@ -938,12 +953,20 @@ swcMinify.filter = (name) => JS_FILE_RE.test(name);
  */
 async function esbuildMinify(input, sourceMap, minimizerOptions) {
   /**
-   * @param {import("esbuild").TransformOptions & { ecma?: string | number, module?: boolean }=} esbuildOptions esbuild options
+   * @param {import("esbuild").TransformOptions & { ecma?: string | number, module?: boolean, as?: string }=} esbuildOptions esbuild options
    * @returns {import("esbuild").TransformOptions} built esbuild options
    */
   const buildEsbuildOptions = (esbuildOptions = {}) => {
     delete esbuildOptions.ecma;
 
+    // `as` names which production of JavaScript the source is, and is the
+    // source's own rather than the configuration's, so it overrides `module`.
+    if (typeof esbuildOptions.as !== "undefined") {
+      esbuildOptions.module = esbuildOptions.as === "module";
+
+      delete esbuildOptions.as;
+    }
+
     if (esbuildOptions.module) {
       esbuildOptions.format = "esm";
     }
diff --git a/test/embedded-protocol.test.js b/test/embedded-protocol.test.js
index e87c0c47..80b6bb17 100644
--- a/test/embedded-protocol.test.js
+++ b/test/embedded-protocol.test.js
@@ -24,9 +24,9 @@ const answerText = (answer) =>
 
 // Anything the renderer throws is reported rather than dropped, and the body is
 // spelled as an untapped run spells it — which is what webpack's minifiers do.
-const askRenderer = async (render, source, type) => {
+const askRenderer = async (render, source, type, as) => {
   try {
-    return await render(source, { type });
+    return await render(source, as === undefined ? { type } : { type, as });
   } catch (error) {
     return { errors: [error] };
   }
@@ -216,11 +216,48 @@ failingJsMinify.supportsWorker = () => false;
 failingJsMinify.supportsWorkerThreads = () => false;
 failingJsMinify.filter = () => false;
 
+/**
+ * A module script: `await` at the top level is a syntax error in a classic one,
+ * so which production a body is written in decides whether it can be read.
+ */
+const MODULE_BODY = "window.ran = true;\nawait Promise.resolve();\n";
+
+/**
+ * A document minifier handing out one inline `<script type=module>`: the
+ * language is JavaScript, and `as` names which of its two productions the body
+ * is written in.
+ * @param {{ [file: string]: string }} input a single `{ filename: code }` entry
+ * @param {undefined} sourceMap unused
+ * @param {{ as?: string, renderEmbeddedSource: (source: string, info: { type: string, as?: string }) => Promise<EXPECTED_ANY> }} minimizerOptions minimizer options
+ * @returns {Promise<EXPECTED_ANY>} the body as its minimizer wrote it
+ */
+async function moduleScriptMinify(input, sourceMap, minimizerOptions) {
+  const rendered = await askRenderer(
+    minimizerOptions.renderEmbeddedSource,
+    MODULE_BODY,
+    "javascript",
+    minimizerOptions.as,
+  );
+  const text = answerText(rendered);
+
+  return {
+    code: typeof text === "string" ? text : MODULE_BODY,
+    ...answerDiagnostics([rendered]),
+  };
+}
+
+moduleScriptMinify.getTypes = () => ["page"];
+moduleScriptMinify.getEmbeddedTypes = () => ["javascript"];
+moduleScriptMinify.supportsWorker = () => false;
+moduleScriptMinify.supportsWorkerThreads = () => false;
+moduleScriptMinify.filter = (name) => /\.page$/i.test(name);
+
 /**
  * @param {EXPECTED_ANY[]} minify minify functions
+ * @param {EXPECTED_ANY[]=} minimizerOptions one options object per minify function
  * @returns {import("webpack").Compiler} compiler with the document emitted as an asset
  */
-const getPageCompiler = (minify) => {
+const getPageCompiler = (minify, minimizerOptions) => {
   const compiler = getCompiler({
     entry: path.resolve(__dirname, "./fixtures/embedded/entry-page.js"),
     target: "node",
@@ -235,7 +272,7 @@ const getPageCompiler = (minify) => {
   new MinimizerPlugin({
     test: /\.page$/i,
     minify,
-    minimizerOptions: minify.map(() => ({})),
+    minimizerOptions: minimizerOptions || minify.map(() => ({})),
     parallel: false,
   }).apply(compiler);
 
@@ -492,3 +529,70 @@ describe("embedded dispatch shapes", () => {
     );
   });
 });
+
+describe("which production of JavaScript a body is written in", () => {
+  it.each([
+    [
+      "terserMinify",
+      MinimizerPlugin.terserMinify,
+      "window.ran=!0,await Promise.resolve();",
+    ],
+    [
+      "uglifyJsMinify",
+      MinimizerPlugin.uglifyJsMinify,
+      "window.ran=!0,await Promise.resolve();",
+    ],
+    [
+      "swcMinify",
+      MinimizerPlugin.swcMinify,
+      "window.ran=!0,await Promise.resolve();",
+    ],
+    [
+      "esbuildMinify",
+      MinimizerPlugin.esbuildMinify,
+      "window.ran=!0,await Promise.resolve();\n",
+    ],
+  ])(
+    "reads a body handed out as a module with `%s`",
+    async (name, minifier, expected) => {
+      const compiler = getPageCompiler(
+        [moduleScriptMinify, minifier],
+        [{ as: "module" }, {}],
+      );
+      const stats = await compile(compiler);
+
+      expect(getErrors(stats)).toEqual([]);
+      expect(getWarnings(stats)).toEqual([]);
+      expect(readAsset("host.page", compiler, stats)).toBe(expected);
+    },
+  );
+
+  it("reads one as a classic script when that is what it is handed out as", async () => {
+    const compiler = getPageCompiler(
+      [moduleScriptMinify, MinimizerPlugin.terserMinify],
+      [{ as: "classic" }, {}],
+    );
+    const stats = await compile(compiler);
+
+    // The word itself never reaches the engine, which would answer
+    // "`as` is not a supported option" rather than reading the source at all.
+    expect(getErrors(stats)).toHaveLength(1);
+    expect(getErrors(stats)[0]).toMatch(/Unexpected token: name \(Promise\)/);
+    expect(stats.compilation.getAsset("host.page").source.source()).toBe(
+      MODULE_BODY,
+    );
+  });
+
+  it("leaves the production to the minimizer when none is named", async () => {
+    const compiler = getPageCompiler([
+      moduleScriptMinify,
+      MinimizerPlugin.terserMinify,
+    ]);
+    const stats = await compile(compiler);
+
+    // Nothing says which production this is, so it is read as the classic
+    // script `terser` defaults to — which is what an inline script is.
+    expect(getErrors(stats)).toHaveLength(1);
+    expect(getErrors(stats)[0]).toMatch(/Unexpected token: name \(Promise\)/);
+  });
+});

From cd64865fb7570b90a1a5afc41dc18654295a8186 Mon Sep 17 00:00:00 2001
From: alexander-akait <4567934+alexander-akait@users.noreply.github.com>
Date: Sun, 6 Sep 2026 10:31:18 +0000
Subject: [PATCH 2/5] fix: minify an event handler body as the function it
 belongs to
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

`as: "event-handler"` names a function body — the production the `return`
cancelling an event is written in. No JavaScript engine here parses one on its
own, so each built-in minimizer minifies the function that body belongs to and
answers with the body back out of it, rather than a caller shaping the source
for an engine it cannot see.
---
 .changeset/embedded-javascript-parse-goal.md |   2 +-
 README.md                                    |   7 ++
 src/production.js                            |  52 +++++++++
 src/utils.js                                 | 112 +++++++++++++++++--
 test/embedded-protocol.test.js               |  58 +++++++++-
 test/production.test.js                      |  55 +++++++++
 6 files changed, 274 insertions(+), 12 deletions(-)
 create mode 100644 src/production.js
 create mode 100644 test/production.test.js

diff --git a/.changeset/embedded-javascript-parse-goal.md b/.changeset/embedded-javascript-parse-goal.md
index e259beb7..0d71a8e2 100644
--- a/.changeset/embedded-javascript-parse-goal.md
+++ b/.changeset/embedded-javascript-parse-goal.md
@@ -2,4 +2,4 @@
 "minimizer-webpack-plugin": patch
 ---
 
-read `as` on an embedded JavaScript body as the built-in minimizers' own `module` option, so a module script is not read as a classic one and the engine is never handed the word
+read `as` on an embedded JavaScript body: the built-in minimizers take `module` as their own option and minify an `event-handler` body as the function it belongs to, so neither production is read as a classic script and no engine is handed the word
diff --git a/README.md b/README.md
index e19c5808..9da943f2 100644
--- a/README.md
+++ b/README.md
@@ -1028,6 +1028,13 @@ function of your own claiming `javascript` is handed it and decides. Ignore it
 at your peril: a module script read as a classic one is a syntax error the
 moment it holds a top-level `await`.
 
+An event handler attribute — `onclick=""` — arrives as **`javascript` with
+`as: "event-handler"`**: its value is a function body, the production the
+`return` cancelling an event is written in. No JavaScript engine here parses one
+on its own, so each built-in minimizer minifies the function that body belongs
+to and answers with the body back out of it. A minify function of your own is
+handed the body as written and reads it however its engine can.
+
 The nested case needs a minifier that can hand its nested bodies out, which it
 also states for itself — webpack's `cssMinify` and `htmlMinify` do:
 
diff --git a/src/production.js b/src/production.js
new file mode 100644
index 00000000..c566e649
--- /dev/null
+++ b/src/production.js
@@ -0,0 +1,52 @@
+/**
+ * Which production of a language an embedded body is written in.
+ *
+ * `as` carries it — a `style=""` arrives as `css` with `as: "block-contents"`,
+ * a `<script type=module>` as `javascript` with `as: "module"`. A minimizer
+ * whose engine reads that production takes the body as written; the built-in
+ * JavaScript ones read `module` themselves, and translate the one production no
+ * JavaScript engine parses on its own: an event handler attribute's function
+ * body, which is minified as the function it belongs to.
+ */
+
+const EVENT_HANDLER = "event-handler";
+
+/**
+ * The function a body handed out as an event handler belongs to. Named past any
+ * run of `_` the body holds, so nothing in it resolves to the function instead
+ * of what it meant; the newline ends a line comment the body may close with.
+ * @param {string} body the handler's text
+ * @returns {string} the script it is the body of
+ */
+function asFunction(body) {
+  const runs = body.match(/_+/g);
+  const longest = runs
+    ? runs.reduce((widest, run) => Math.max(widest, run.length), 0)
+    : 0;
+
+  return `function ${"_".repeat(longest + 1)}(){${body}\n}`;
+}
+
+/**
+ * The handler body inside the function a minimizer answered with. `undefined`
+ * for an answer that is not that function — one holding anything else, or one
+ * that dropped it whole as the unused declaration it is.
+ * @param {string | undefined} answered what the minimizer answered
+ * @returns {string | undefined} the body, or undefined
+ */
+function functionBody(answered) {
+  if (typeof answered !== "string") return undefined;
+
+  // Trimmed first: an engine may end what it writes with a newline, and a
+  // trailing `;` is the declaration's own rather than the body's.
+  const written = answered.trim().replace(/;$/, "");
+  const opened = written.indexOf("{");
+
+  return opened !== -1 &&
+    written.endsWith("}") &&
+    /^function\s+[^\s(]+\s*\(\s*\)\s*$/.test(written.slice(0, opened))
+    ? written.slice(opened + 1, -1).trim()
+    : undefined;
+}
+
+module.exports = { EVENT_HANDLER, asFunction, functionBody };
diff --git a/src/utils.js b/src/utils.js
index 680326fd..f15cfb0f 100644
--- a/src/utils.js
+++ b/src/utils.js
@@ -378,6 +378,18 @@ async function terserMinify(
       // toplevel: terserOptions.toplevel
     });
 
+  const {
+    EVENT_HANDLER,
+    asFunction,
+    functionBody,
+  } = require("./production.js");
+
+  // The production is the body's own, and a function body is the one terser has
+  // no goal symbol for: it is minified as the function it belongs to.
+  const handler =
+    typeof minimizerOptions !== "undefined" &&
+    minimizerOptions.as === EVENT_HANDLER;
+
   let minify;
 
   try {
@@ -426,8 +438,19 @@ async function terserMinify(
   }
 
   const [[filename, source]] = Object.entries(input);
-  const code = Buffer.isBuffer(source) ? source.toString() : source;
-  const result = await minify({ [filename]: code }, terserOptions);
+  const text = Buffer.isBuffer(source) ? source.toString() : source;
+  const result = await minify(
+    { [filename]: handler ? asFunction(text) : text },
+    terserOptions,
+  );
+
+  if (handler) {
+    const body = functionBody(result.code);
+
+    // A wrap moves every position, so the map terser wrote describes a script
+    // that is not what comes back.
+    return { code: body === undefined ? text : body, extractedComments };
+  }
 
   return {
     code: /** @type {string} * */ (result.code),
@@ -644,6 +667,18 @@ async function uglifyJsMinify(
     };
   };
 
+  const {
+    EVENT_HANDLER,
+    asFunction,
+    functionBody,
+  } = require("./production.js");
+
+  // A function body is the production uglify-js has no goal symbol for, so the
+  // function it belongs to is what is minified.
+  const handler =
+    typeof minimizerOptions !== "undefined" &&
+    minimizerOptions.as === EVENT_HANDLER;
+
   let minify;
 
   try {
@@ -671,8 +706,24 @@ async function uglifyJsMinify(
   );
 
   const [[filename, source]] = Object.entries(input);
-  const code = Buffer.isBuffer(source) ? source.toString() : source;
-  const result = await minify({ [filename]: code }, uglifyJsOptions);
+  const text = Buffer.isBuffer(source) ? source.toString() : source;
+  const result = await minify(
+    { [filename]: handler ? asFunction(text) : text },
+    uglifyJsOptions,
+  );
+
+  if (handler) {
+    const body = functionBody(result.code);
+
+    // A wrap moves every position, so the map uglify-js wrote describes a
+    // script that is not what comes back.
+    return {
+      code: body === undefined ? text : body,
+      errors: result.error ? [result.error] : [],
+      warnings: result.warnings || [],
+      extractedComments,
+    };
+  }
 
   return {
     code: result.code,
@@ -849,6 +900,18 @@ async function swcMinify(input, sourceMap, minimizerOptions, extractComments) {
       sourceMap: undefined,
     });
 
+  const {
+    EVENT_HANDLER,
+    asFunction,
+    functionBody,
+  } = require("./production.js");
+
+  // A function body is the production swc has no goal symbol for, so the
+  // function it belongs to is what is minified.
+  const handler =
+    typeof minimizerOptions !== "undefined" &&
+    minimizerOptions.as === EVENT_HANDLER;
+
   let swc;
 
   try {
@@ -898,10 +961,21 @@ async function swcMinify(input, sourceMap, minimizerOptions, extractComments) {
   }
 
   const [[filename, source]] = Object.entries(input);
-  const code = Buffer.isBuffer(source) ? source.toString() : source;
+  const text = Buffer.isBuffer(source) ? source.toString() : source;
   const result =
     /** @type {import("@swc/core").Output & { extractedComments?: string[] }} */
-    (await swc.minify(code, swcOptions));
+    (await swc.minify(handler ? asFunction(text) : text, swcOptions));
+
+  if (handler) {
+    const body = functionBody(result.code);
+
+    // A wrap moves every position, so the map swc wrote describes a script that
+    // is not what comes back.
+    return {
+      code: body === undefined ? text : body,
+      extractedComments: result.extractedComments || [],
+    };
+  }
 
   let map;
 
@@ -982,6 +1056,18 @@ async function esbuildMinify(input, sourceMap, minimizerOptions) {
     };
   };
 
+  const {
+    EVENT_HANDLER,
+    asFunction,
+    functionBody,
+  } = require("./production.js");
+
+  // A function body is the production esbuild has no goal symbol for, so the
+  // function it belongs to is what is minified.
+  const handler =
+    typeof minimizerOptions !== "undefined" &&
+    minimizerOptions.as === EVENT_HANDLER;
+
   let esbuild;
 
   try {
@@ -1000,15 +1086,21 @@ async function esbuildMinify(input, sourceMap, minimizerOptions) {
   }
 
   const [[filename, source]] = Object.entries(input);
-  const code = Buffer.isBuffer(source) ? source.toString() : source;
+  const text = Buffer.isBuffer(source) ? source.toString() : source;
 
   esbuildOptions.sourcefile = filename;
 
-  const result = await esbuild.transform(code, esbuildOptions);
+  const result = await esbuild.transform(
+    handler ? asFunction(text) : text,
+    esbuildOptions,
+  );
+  const body = handler ? functionBody(result.code) : undefined;
 
   return {
-    code: result.code,
-    map: result.map ? JSON.parse(result.map) : undefined,
+    code: handler ? (body === undefined ? text : body) : result.code,
+    // A wrap moves every position, so the map esbuild wrote describes a script
+    // that is not what comes back.
+    map: handler || !result.map ? undefined : JSON.parse(result.map),
     warnings:
       result.warnings.length > 0
         ? result.warnings.map((item) => {
diff --git a/test/embedded-protocol.test.js b/test/embedded-protocol.test.js
index 80b6bb17..3cea7ca6 100644
--- a/test/embedded-protocol.test.js
+++ b/test/embedded-protocol.test.js
@@ -246,6 +246,41 @@ async function moduleScriptMinify(input, sourceMap, minimizerOptions) {
   };
 }
 
+/**
+ * An event handler attribute's value: a function body, where the `return`
+ * cancelling an event lives. No JavaScript engine parses one on its own.
+ */
+const HANDLER_BODY = "  return  false  ";
+
+/**
+ * A document minifier handing out one `onsubmit=""`: JavaScript again, with
+ * `as` naming the production its value is written in.
+ * @param {{ [file: string]: string }} input a single `{ filename: code }` entry
+ * @param {undefined} sourceMap unused
+ * @param {{ renderEmbeddedSource: (source: string, info: { type: string, as?: string }) => Promise<EXPECTED_ANY> }} minimizerOptions minimizer options
+ * @returns {Promise<EXPECTED_ANY>} the body as its minimizer wrote it
+ */
+async function eventHandlerMinify(input, sourceMap, minimizerOptions) {
+  const rendered = await askRenderer(
+    minimizerOptions.renderEmbeddedSource,
+    HANDLER_BODY,
+    "javascript",
+    "event-handler",
+  );
+  const text = answerText(rendered);
+
+  return {
+    code: typeof text === "string" ? text : HANDLER_BODY,
+    ...answerDiagnostics([rendered]),
+  };
+}
+
+eventHandlerMinify.getTypes = () => ["page"];
+eventHandlerMinify.getEmbeddedTypes = () => ["javascript"];
+eventHandlerMinify.supportsWorker = () => false;
+eventHandlerMinify.supportsWorkerThreads = () => false;
+eventHandlerMinify.filter = (name) => /\.page$/i.test(name);
+
 moduleScriptMinify.getTypes = () => ["page"];
 moduleScriptMinify.getEmbeddedTypes = () => ["javascript"];
 moduleScriptMinify.supportsWorker = () => false;
@@ -570,7 +605,7 @@ describe("which production of JavaScript a body is written in", () => {
   it("reads one as a classic script when that is what it is handed out as", async () => {
     const compiler = getPageCompiler(
       [moduleScriptMinify, MinimizerPlugin.terserMinify],
-      [{ as: "classic" }, {}],
+      [{ as: "script" }, {}],
     );
     const stats = await compile(compiler);
 
@@ -596,3 +631,24 @@ describe("which production of JavaScript a body is written in", () => {
     expect(getErrors(stats)[0]).toMatch(/Unexpected token: name \(Promise\)/);
   });
 });
+
+describe("a body handed out as an event handler", () => {
+  it.each([
+    ["terserMinify", MinimizerPlugin.terserMinify],
+    ["uglifyJsMinify", MinimizerPlugin.uglifyJsMinify],
+    ["swcMinify", MinimizerPlugin.swcMinify],
+    ["esbuildMinify", MinimizerPlugin.esbuildMinify],
+  ])(
+    "is minified as the function it belongs to by `%s`",
+    async (name, minifier) => {
+      const compiler = getPageCompiler([eventHandlerMinify, minifier]);
+      const stats = await compile(compiler);
+
+      // A `return` at the top level is a syntax error in either script
+      // production, so reaching one at all is the wrap; what comes back is the
+      // body rather than the function around it.
+      expect(getErrors(stats)).toEqual([]);
+      expect(readAsset("host.page", compiler, stats)).toBe("return!1");
+    },
+  );
+});
diff --git a/test/production.test.js b/test/production.test.js
new file mode 100644
index 00000000..7560e8e1
--- /dev/null
+++ b/test/production.test.js
@@ -0,0 +1,55 @@
+import { EVENT_HANDLER, asFunction, functionBody } from "../src/production";
+
+describe("EVENT_HANDLER", () => {
+  it("is the word the caller hands a function body over with", () => {
+    expect(EVENT_HANDLER).toBe("event-handler");
+  });
+});
+
+describe("asFunction", () => {
+  it("makes the body a whole script an engine can read", () => {
+    expect(asFunction("return  false")).toBe("function _(){return  false\n}");
+  });
+
+  it("names the function past any run of `_` the body holds", () => {
+    // A body naming the same binding would resolve to the function around it
+    // rather than to what it meant.
+    expect(asFunction("_( __ )")).toBe("function ___(){_( __ )\n}");
+    expect(asFunction("f(_____)")).toBe("function ______(){f(_____)\n}");
+  });
+
+  it("ends a line comment the body closes with", () => {
+    // Without the newline the brace closing the function would be inside the
+    // comment, and nothing could parse what it was handed.
+    expect(asFunction("f( 1 ) // done")).toBe("function _(){f( 1 ) // done\n}");
+  });
+});
+
+describe("functionBody", () => {
+  it("reads the body back out of the function", () => {
+    expect(functionBody("function _(){f(1)}")).toBe("f(1)");
+    expect(functionBody("function ___ ( ) { f(1) }")).toBe("f(1)");
+  });
+
+  it("reads one an engine ended with a newline or a `;`", () => {
+    // `esbuild` writes the newline, and a declaration may be printed with the
+    // semicolon that never belonged to the body.
+    expect(functionBody("function _(){return!1}\n")).toBe("return!1");
+    expect(functionBody("function _(){return!1};")).toBe("return!1");
+  });
+
+  it("declines an answer that is not that one function", () => {
+    // Text around it, a second statement, and the empty answer a minimizer
+    // dropping an unused declaration gives.
+    expect(functionBody("f(1)")).toBeUndefined();
+    expect(functionBody("function _(){f(1)}g()")).toBeUndefined();
+    expect(functionBody("g();function _(){f(1)}")).toBeUndefined();
+    expect(functionBody("")).toBeUndefined();
+    expect(functionBody("function (){f(1)}")).toBeUndefined();
+    expect(functionBody("function _(a){f(a)}")).toBeUndefined();
+  });
+
+  it("declines an answer that is not text at all", () => {
+    expect(functionBody(undefined)).toBeUndefined();
+  });
+});

From 31aaca78f6d535a0d06af8258eccc9b0e34a0313 Mon Sep 17 00:00:00 2001
From: alexander-akait <4567934+alexander-akait@users.noreply.github.com>
Date: Sun, 6 Sep 2026 10:32:55 +0000
Subject: [PATCH 3/5] chore: add the declarations for the new module

---
 types/production.d.ts | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 types/production.d.ts

diff --git a/types/production.d.ts b/types/production.d.ts
new file mode 100644
index 00000000..0e5718ea
--- /dev/null
+++ b/types/production.d.ts
@@ -0,0 +1,27 @@
+/**
+ * Which production of a language an embedded body is written in.
+ *
+ * `as` carries it — a `style=""` arrives as `css` with `as: "block-contents"`,
+ * a `<script type=module>` as `javascript` with `as: "module"`. A minimizer
+ * whose engine reads that production takes the body as written; the built-in
+ * JavaScript ones read `module` themselves, and translate the one production no
+ * JavaScript engine parses on its own: an event handler attribute's function
+ * body, which is minified as the function it belongs to.
+ */
+export const EVENT_HANDLER: "event-handler";
+/**
+ * The function a body handed out as an event handler belongs to. Named past any
+ * run of `_` the body holds, so nothing in it resolves to the function instead
+ * of what it meant; the newline ends a line comment the body may close with.
+ * @param {string} body the handler's text
+ * @returns {string} the script it is the body of
+ */
+export function asFunction(body: string): string;
+/**
+ * The handler body inside the function a minimizer answered with. `undefined`
+ * for an answer that is not that function — one holding anything else, or one
+ * that dropped it whole as the unused declaration it is.
+ * @param {string | undefined} answered what the minimizer answered
+ * @returns {string | undefined} the body, or undefined
+ */
+export function functionBody(answered: string | undefined): string | undefined;

From 61d7f8d658064ca05450b7e5cb399105201d99fa Mon Sep 17 00:00:00 2001
From: alexander-akait <4567934+alexander-akait@users.noreply.github.com>
Date: Sun, 6 Sep 2026 11:18:18 +0000
Subject: [PATCH 4/5] refactor: keep the productions with the minimizers that
 read them

The wrap and the read-back move into `utils.js` beside the four minimizers, and
the three productions JavaScript is handed out in are named there: a classic
script, a module, and the function body an event handler holds. A minify
function reaches a worker as its source, so each still requires them rather
than reading this module's scope.
---
 src/production.js                             |  52 --------
 src/utils.js                                  | 114 +++++++++++++-----
 .../embedded-protocol.test.js.snap            |  12 ++
 test/embedded-protocol.test.js                |  91 ++++++++++++++
 test/production.test.js                       |  55 ---------
 types/production.d.ts                         |  27 -----
 types/utils.d.ts                              |  24 ++++
 7 files changed, 213 insertions(+), 162 deletions(-)
 delete mode 100644 src/production.js
 create mode 100644 test/__snapshots__/embedded-protocol.test.js.snap
 delete mode 100644 test/production.test.js
 delete mode 100644 types/production.d.ts

diff --git a/src/production.js b/src/production.js
deleted file mode 100644
index c566e649..00000000
--- a/src/production.js
+++ /dev/null
@@ -1,52 +0,0 @@
-/**
- * Which production of a language an embedded body is written in.
- *
- * `as` carries it — a `style=""` arrives as `css` with `as: "block-contents"`,
- * a `<script type=module>` as `javascript` with `as: "module"`. A minimizer
- * whose engine reads that production takes the body as written; the built-in
- * JavaScript ones read `module` themselves, and translate the one production no
- * JavaScript engine parses on its own: an event handler attribute's function
- * body, which is minified as the function it belongs to.
- */
-
-const EVENT_HANDLER = "event-handler";
-
-/**
- * The function a body handed out as an event handler belongs to. Named past any
- * run of `_` the body holds, so nothing in it resolves to the function instead
- * of what it meant; the newline ends a line comment the body may close with.
- * @param {string} body the handler's text
- * @returns {string} the script it is the body of
- */
-function asFunction(body) {
-  const runs = body.match(/_+/g);
-  const longest = runs
-    ? runs.reduce((widest, run) => Math.max(widest, run.length), 0)
-    : 0;
-
-  return `function ${"_".repeat(longest + 1)}(){${body}\n}`;
-}
-
-/**
- * The handler body inside the function a minimizer answered with. `undefined`
- * for an answer that is not that function — one holding anything else, or one
- * that dropped it whole as the unused declaration it is.
- * @param {string | undefined} answered what the minimizer answered
- * @returns {string | undefined} the body, or undefined
- */
-function functionBody(answered) {
-  if (typeof answered !== "string") return undefined;
-
-  // Trimmed first: an engine may end what it writes with a newline, and a
-  // trailing `;` is the declaration's own rather than the body's.
-  const written = answered.trim().replace(/;$/, "");
-  const opened = written.indexOf("{");
-
-  return opened !== -1 &&
-    written.endsWith("}") &&
-    /^function\s+[^\s(]+\s*\(\s*\)\s*$/.test(written.slice(0, opened))
-    ? written.slice(opened + 1, -1).trim()
-    : undefined;
-}
-
-module.exports = { EVENT_HANDLER, asFunction, functionBody };
diff --git a/src/utils.js b/src/utils.js
index f15cfb0f..c15dc402 100644
--- a/src/utils.js
+++ b/src/utils.js
@@ -14,6 +14,53 @@
 
 const path = require("path");
 
+/**
+ * Which production of a language an embedded body is written in, as `as` names
+ * it. A `style=""` is `css` with `as: "block-contents"`; JavaScript's are these
+ * three, and only the last is one no engine here parses on its own.
+ */
+const CLASSIC_SCRIPT = "script";
+const MODULE_SCRIPT = "module";
+const EVENT_HANDLER = "event-handler";
+
+/**
+ * The function a body handed out as an event handler belongs to. Named past any
+ * run of `_` the body holds, so nothing in it resolves to the function instead
+ * of what it meant; the newline ends a line comment the body may close with.
+ * @param {string} body the handler's text
+ * @returns {string} the script it is the body of
+ */
+function asFunction(body) {
+  const runs = body.match(/_+/g);
+  const longest = runs
+    ? runs.reduce((widest, run) => Math.max(widest, run.length), 0)
+    : 0;
+
+  return `function ${"_".repeat(longest + 1)}(){${body}\n}`;
+}
+
+/**
+ * The handler body inside the function a minimizer answered with. `undefined`
+ * for an answer that is not that function — one holding anything else, or one
+ * that dropped it whole as the unused declaration it is.
+ * @param {string | undefined} answered what the minimizer answered
+ * @returns {string | undefined} the body, or undefined
+ */
+function functionBody(answered) {
+  if (typeof answered !== "string") return undefined;
+
+  // Trimmed first: an engine may end what it writes with a newline, and a
+  // trailing `;` is the declaration's own rather than the body's.
+  const written = answered.trim().replace(/;$/, "");
+  const opened = written.indexOf("{");
+
+  return opened !== -1 &&
+    written.endsWith("}") &&
+    /^function\s+[^\s(]+\s*\(\s*\)\s*$/.test(written.slice(0, opened))
+    ? written.slice(opened + 1, -1).trim()
+    : undefined;
+}
+
 /**
  * The version a package reports. Read by walking up from its resolved entry
  * point rather than by requiring `<name>/package.json`, which a package whose
@@ -207,6 +254,12 @@ async function terserMinify(
   minimizerOptions,
   extractComments,
 ) {
+  // Self-require rather than the bindings above: a minify function reaches a
+  // worker as its source, where this module's own scope is gone.
+  const { EVENT_HANDLER, MODULE_SCRIPT, asFunction, functionBody } =
+    // eslint-disable-next-line import/no-self-import
+    require("./utils.js");
+
   /**
    * @param {unknown} value value
    * @returns {value is EXPECTED_OBJECT} true when value is object or function
@@ -347,7 +400,9 @@ async function terserMinify(
       ...terserOptions,
       // `as` names which production of JavaScript the source is, and is the
       // source's own rather than the configuration's, so it overrides `module`.
-      ...(typeof as === "undefined" ? undefined : { module: as === "module" }),
+      ...(typeof as === "undefined"
+        ? undefined
+        : { module: as === MODULE_SCRIPT }),
       compress:
         typeof terserOptions.compress === "boolean"
           ? terserOptions.compress
@@ -378,12 +433,6 @@ async function terserMinify(
       // toplevel: terserOptions.toplevel
     });
 
-  const {
-    EVENT_HANDLER,
-    asFunction,
-    functionBody,
-  } = require("./production.js");
-
   // The production is the body's own, and a function body is the one terser has
   // no goal symbol for: it is minified as the function it belongs to.
   const handler =
@@ -496,6 +545,12 @@ async function uglifyJsMinify(
   minimizerOptions,
   extractComments,
 ) {
+  // Self-require rather than the bindings above: a minify function reaches a
+  // worker as its source, where this module's own scope is gone.
+  const { EVENT_HANDLER, MODULE_SCRIPT, asFunction, functionBody } =
+    // eslint-disable-next-line import/no-self-import
+    require("./utils.js");
+
   /**
    * @param {unknown} value value
    * @returns {boolean} true when value is object or function
@@ -642,7 +697,9 @@ async function uglifyJsMinify(
     // Need deep copy objects to avoid https://github.com/terser/terser/issues/366
     return {
       ...uglifyJsOptions,
-      ...(typeof as === "undefined" ? undefined : { module: as === "module" }),
+      ...(typeof as === "undefined"
+        ? undefined
+        : { module: as === MODULE_SCRIPT }),
       // warnings: uglifyJsOptions.warnings,
       parse: { ...uglifyJsOptions.parse },
       compress:
@@ -667,12 +724,6 @@ async function uglifyJsMinify(
     };
   };
 
-  const {
-    EVENT_HANDLER,
-    asFunction,
-    functionBody,
-  } = require("./production.js");
-
   // A function body is the production uglify-js has no goal symbol for, so the
   // function it belongs to is what is minified.
   const handler =
@@ -766,6 +817,12 @@ uglifyJsMinify.filter = (name) => JS_FILE_RE.test(name);
  * @returns {Promise<MinimizedResult>} minimized result
  */
 async function swcMinify(input, sourceMap, minimizerOptions, extractComments) {
+  // Self-require rather than the bindings above: a minify function reaches a
+  // worker as its source, where this module's own scope is gone.
+  const { EVENT_HANDLER, MODULE_SCRIPT, asFunction, functionBody } =
+    // eslint-disable-next-line import/no-self-import
+    require("./utils.js");
+
   /**
    * @param {unknown} value value
    * @returns {boolean} true when value is object or function
@@ -875,7 +932,9 @@ async function swcMinify(input, sourceMap, minimizerOptions, extractComments) {
       ...swcOptions,
       // `as` names which production of JavaScript the source is, and is the
       // source's own rather than the configuration's, so it overrides `module`.
-      ...(typeof as === "undefined" ? undefined : { module: as === "module" }),
+      ...(typeof as === "undefined"
+        ? undefined
+        : { module: as === MODULE_SCRIPT }),
       compress:
         typeof swcOptions.compress === "boolean"
           ? swcOptions.compress
@@ -900,12 +959,6 @@ async function swcMinify(input, sourceMap, minimizerOptions, extractComments) {
       sourceMap: undefined,
     });
 
-  const {
-    EVENT_HANDLER,
-    asFunction,
-    functionBody,
-  } = require("./production.js");
-
   // A function body is the production swc has no goal symbol for, so the
   // function it belongs to is what is minified.
   const handler =
@@ -1026,6 +1079,12 @@ swcMinify.filter = (name) => JS_FILE_RE.test(name);
  * @returns {Promise<MinimizedResult>} minimized result
  */
 async function esbuildMinify(input, sourceMap, minimizerOptions) {
+  // Self-require rather than the bindings above: a minify function reaches a
+  // worker as its source, where this module's own scope is gone.
+  const { EVENT_HANDLER, MODULE_SCRIPT, asFunction, functionBody } =
+    // eslint-disable-next-line import/no-self-import
+    require("./utils.js");
+
   /**
    * @param {import("esbuild").TransformOptions & { ecma?: string | number, module?: boolean, as?: string }=} esbuildOptions esbuild options
    * @returns {import("esbuild").TransformOptions} built esbuild options
@@ -1036,7 +1095,7 @@ async function esbuildMinify(input, sourceMap, minimizerOptions) {
     // `as` names which production of JavaScript the source is, and is the
     // source's own rather than the configuration's, so it overrides `module`.
     if (typeof esbuildOptions.as !== "undefined") {
-      esbuildOptions.module = esbuildOptions.as === "module";
+      esbuildOptions.module = esbuildOptions.as === MODULE_SCRIPT;
 
       delete esbuildOptions.as;
     }
@@ -1056,12 +1115,6 @@ async function esbuildMinify(input, sourceMap, minimizerOptions) {
     };
   };
 
-  const {
-    EVENT_HANDLER,
-    asFunction,
-    functionBody,
-  } = require("./production.js");
-
   // A function body is the production esbuild has no goal symbol for, so the
   // function it belongs to is what is minified.
   const handler =
@@ -3503,11 +3556,16 @@ function memoize(fn) {
 }
 
 module.exports = {
+  CLASSIC_SCRIPT,
+  EVENT_HANDLER,
+  MODULE_SCRIPT,
+  asFunction,
   cleanCssMinify,
   cssnanoMinify,
   cssoMinify,
   esbuildMinify,
   esbuildMinifyCss,
+  functionBody,
   getEcmaVersion,
   getMinimizerOptionsAt,
   htmlMinifierTerser,
diff --git a/test/__snapshots__/embedded-protocol.test.js.snap b/test/__snapshots__/embedded-protocol.test.js.snap
new file mode 100644
index 00000000..532c1843
--- /dev/null
+++ b/test/__snapshots__/embedded-protocol.test.js.snap
@@ -0,0 +1,12 @@
+// Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing
+
+exports[`a body handed out as a classic script is read as one by \`esbuildMinify\` 1`] = `
+"var o={a:1};with(o)window.ran=a;
+"
+`;
+
+exports[`a body handed out as a classic script is read as one by \`swcMinify\` 1`] = `"var o={a:1};with(o)window.ran=a;"`;
+
+exports[`a body handed out as a classic script is read as one by \`terserMinify\` 1`] = `"var o={a:1};with(o)window.ran=a;"`;
+
+exports[`a body handed out as a classic script is read as one by \`uglifyJsMinify\` 1`] = `"var o={a:1};with(o)window.ran=a;"`;
diff --git a/test/embedded-protocol.test.js b/test/embedded-protocol.test.js
index 3cea7ca6..47cb6bd2 100644
--- a/test/embedded-protocol.test.js
+++ b/test/embedded-protocol.test.js
@@ -1,6 +1,7 @@
 import path from "path";
 
 import MinimizerPlugin from "../src";
+import { asFunction, functionBody } from "../src/utils";
 
 import {
   compile,
@@ -275,6 +276,41 @@ async function eventHandlerMinify(input, sourceMap, minimizerOptions) {
   };
 }
 
+/**
+ * A classic script: `with` is a syntax error in a module and in strict mode,
+ * so a body holding one says which production it was read as.
+ */
+const CLASSIC_BODY =
+  "var  o  =  { a : 1 } ;  with ( o ) { window.ran  =  a }\n";
+
+/**
+ * A document minifier handing out one bare `<script>`, the classic production.
+ * @param {{ [file: string]: string }} input a single `{ filename: code }` entry
+ * @param {undefined} sourceMap unused
+ * @param {{ renderEmbeddedSource: (source: string, info: { type: string, as?: string }) => Promise<EXPECTED_ANY> }} minimizerOptions minimizer options
+ * @returns {Promise<EXPECTED_ANY>} the body as its minimizer wrote it
+ */
+async function classicScriptMinify(input, sourceMap, minimizerOptions) {
+  const rendered = await askRenderer(
+    minimizerOptions.renderEmbeddedSource,
+    CLASSIC_BODY,
+    "javascript",
+    "script",
+  );
+  const text = answerText(rendered);
+
+  return {
+    code: typeof text === "string" ? text : CLASSIC_BODY,
+    ...answerDiagnostics([rendered]),
+  };
+}
+
+classicScriptMinify.getTypes = () => ["page"];
+classicScriptMinify.getEmbeddedTypes = () => ["javascript"];
+classicScriptMinify.supportsWorker = () => false;
+classicScriptMinify.supportsWorkerThreads = () => false;
+classicScriptMinify.filter = (name) => /\.page$/i.test(name);
+
 eventHandlerMinify.getTypes = () => ["page"];
 eventHandlerMinify.getEmbeddedTypes = () => ["javascript"];
 eventHandlerMinify.supportsWorker = () => false;
@@ -652,3 +688,58 @@ describe("a body handed out as an event handler", () => {
     },
   );
 });
+
+describe("a body handed out as a classic script", () => {
+  it.each([
+    ["terserMinify", MinimizerPlugin.terserMinify],
+    ["uglifyJsMinify", MinimizerPlugin.uglifyJsMinify],
+    ["swcMinify", MinimizerPlugin.swcMinify],
+    ["esbuildMinify", MinimizerPlugin.esbuildMinify],
+  ])("is read as one by `%s`", async (name, minifier) => {
+    const compiler = getPageCompiler([classicScriptMinify, minifier]);
+    const stats = await compile(compiler);
+
+    expect(getErrors(stats)).toEqual([]);
+    expect(readAsset("host.page", compiler, stats)).toMatchSnapshot();
+  });
+});
+
+describe("the function an event handler body is minified inside", () => {
+  it("makes the body a whole script an engine can read", () => {
+    expect(asFunction("return  false")).toBe("function _(){return  false\n}");
+  });
+
+  it("names the function past any run of `_` the body holds", () => {
+    // A body naming the same binding would resolve to the function around it
+    // rather than to what it meant.
+    expect(asFunction("_( __ )")).toBe("function ___(){_( __ )\n}");
+    expect(asFunction("f(_____)")).toBe("function ______(){f(_____)\n}");
+  });
+
+  it("ends a line comment the body closes with", () => {
+    // Without the newline the brace closing the function would be inside the
+    // comment, and nothing could parse what it was handed.
+    expect(asFunction("f( 1 ) // done")).toBe("function _(){f( 1 ) // done\n}");
+  });
+
+  it("reads the body back out of what a minimizer answered", () => {
+    expect(functionBody("function _(){f(1)}")).toBe("f(1)");
+    expect(functionBody("function ___ ( ) { f(1) }")).toBe("f(1)");
+    // `esbuild` writes the newline, and a declaration may be printed with the
+    // semicolon that never belonged to the body.
+    expect(functionBody("function _(){return!1}\n")).toBe("return!1");
+    expect(functionBody("function _(){return!1};")).toBe("return!1");
+  });
+
+  it("declines an answer that is not that one function", () => {
+    // Text around it, a second statement, and the empty answer a minimizer
+    // dropping an unused declaration gives.
+    expect(functionBody("f(1)")).toBeUndefined();
+    expect(functionBody("function _(){f(1)}g()")).toBeUndefined();
+    expect(functionBody("g();function _(){f(1)}")).toBeUndefined();
+    expect(functionBody("")).toBeUndefined();
+    expect(functionBody("function (){f(1)}")).toBeUndefined();
+    expect(functionBody("function _(a){f(a)}")).toBeUndefined();
+    expect(functionBody(undefined)).toBeUndefined();
+  });
+});
diff --git a/test/production.test.js b/test/production.test.js
deleted file mode 100644
index 7560e8e1..00000000
--- a/test/production.test.js
+++ /dev/null
@@ -1,55 +0,0 @@
-import { EVENT_HANDLER, asFunction, functionBody } from "../src/production";
-
-describe("EVENT_HANDLER", () => {
-  it("is the word the caller hands a function body over with", () => {
-    expect(EVENT_HANDLER).toBe("event-handler");
-  });
-});
-
-describe("asFunction", () => {
-  it("makes the body a whole script an engine can read", () => {
-    expect(asFunction("return  false")).toBe("function _(){return  false\n}");
-  });
-
-  it("names the function past any run of `_` the body holds", () => {
-    // A body naming the same binding would resolve to the function around it
-    // rather than to what it meant.
-    expect(asFunction("_( __ )")).toBe("function ___(){_( __ )\n}");
-    expect(asFunction("f(_____)")).toBe("function ______(){f(_____)\n}");
-  });
-
-  it("ends a line comment the body closes with", () => {
-    // Without the newline the brace closing the function would be inside the
-    // comment, and nothing could parse what it was handed.
-    expect(asFunction("f( 1 ) // done")).toBe("function _(){f( 1 ) // done\n}");
-  });
-});
-
-describe("functionBody", () => {
-  it("reads the body back out of the function", () => {
-    expect(functionBody("function _(){f(1)}")).toBe("f(1)");
-    expect(functionBody("function ___ ( ) { f(1) }")).toBe("f(1)");
-  });
-
-  it("reads one an engine ended with a newline or a `;`", () => {
-    // `esbuild` writes the newline, and a declaration may be printed with the
-    // semicolon that never belonged to the body.
-    expect(functionBody("function _(){return!1}\n")).toBe("return!1");
-    expect(functionBody("function _(){return!1};")).toBe("return!1");
-  });
-
-  it("declines an answer that is not that one function", () => {
-    // Text around it, a second statement, and the empty answer a minimizer
-    // dropping an unused declaration gives.
-    expect(functionBody("f(1)")).toBeUndefined();
-    expect(functionBody("function _(){f(1)}g()")).toBeUndefined();
-    expect(functionBody("g();function _(){f(1)}")).toBeUndefined();
-    expect(functionBody("")).toBeUndefined();
-    expect(functionBody("function (){f(1)}")).toBeUndefined();
-    expect(functionBody("function _(a){f(a)}")).toBeUndefined();
-  });
-
-  it("declines an answer that is not text at all", () => {
-    expect(functionBody(undefined)).toBeUndefined();
-  });
-});
diff --git a/types/production.d.ts b/types/production.d.ts
deleted file mode 100644
index 0e5718ea..00000000
--- a/types/production.d.ts
+++ /dev/null
@@ -1,27 +0,0 @@
-/**
- * Which production of a language an embedded body is written in.
- *
- * `as` carries it — a `style=""` arrives as `css` with `as: "block-contents"`,
- * a `<script type=module>` as `javascript` with `as: "module"`. A minimizer
- * whose engine reads that production takes the body as written; the built-in
- * JavaScript ones read `module` themselves, and translate the one production no
- * JavaScript engine parses on its own: an event handler attribute's function
- * body, which is minified as the function it belongs to.
- */
-export const EVENT_HANDLER: "event-handler";
-/**
- * The function a body handed out as an event handler belongs to. Named past any
- * run of `_` the body holds, so nothing in it resolves to the function instead
- * of what it meant; the newline ends a line comment the body may close with.
- * @param {string} body the handler's text
- * @returns {string} the script it is the body of
- */
-export function asFunction(body: string): string;
-/**
- * The handler body inside the function a minimizer answered with. `undefined`
- * for an answer that is not that function — one holding anything else, or one
- * that dropped it whole as the unused declaration it is.
- * @param {string | undefined} answered what the minimizer answered
- * @returns {string | undefined} the body, or undefined
- */
-export function functionBody(answered: string | undefined): string | undefined;
diff --git a/types/utils.d.ts b/types/utils.d.ts
index 025ee95e..512241e0 100644
--- a/types/utils.d.ts
+++ b/types/utils.d.ts
@@ -26,6 +26,22 @@ export type ExtractedComments = string[];
 export type QueryValues = {
   [name: string]: EXPECTED_ANY;
 };
+/**
+ * Which production of a language an embedded body is written in, as `as` names
+ * it. A `style=""` is `css` with `as: "block-contents"`; JavaScript's are these
+ * three, and only the last is one no engine here parses on its own.
+ */
+export const CLASSIC_SCRIPT: "script";
+export const EVENT_HANDLER: "event-handler";
+export const MODULE_SCRIPT: "module";
+/**
+ * The function a body handed out as an event handler belongs to. Named past any
+ * run of `_` the body holds, so nothing in it resolves to the function instead
+ * of what it meant; the newline ends a line comment the body may close with.
+ * @param {string} body the handler's text
+ * @returns {string} the script it is the body of
+ */
+export function asFunction(body: string): string;
 /**
  * Minify CSS using `clean-css`.
  * @param {Input} input input
@@ -190,6 +206,14 @@ export namespace esbuildMinifyCss {
    */
   function filter(name: string): boolean;
 }
+/**
+ * The handler body inside the function a minimizer answered with. `undefined`
+ * for an answer that is not that function — one holding anything else, or one
+ * that dropped it whole as the unused declaration it is.
+ * @param {string | undefined} answered what the minimizer answered
+ * @returns {string | undefined} the body, or undefined
+ */
+export function functionBody(answered: string | undefined): string | undefined;
 /**
  * Map a webpack `output.environment` configuration to the highest
  * ECMAScript version that the target is known to support. Returns `5`

From 7a49c5dcfc1148c1964e72bb8218640256bcfa9b Mon Sep 17 00:00:00 2001
From: alexander-akait <4567934+alexander-akait@users.noreply.github.com>
Date: Sun, 6 Sep 2026 11:22:38 +0000
Subject: [PATCH 5/5] test: drive each production through every built-in
 minimizer

Each of the four now gets a classic body only a script may hold, a module body,
a handler body, one no engine can read back, and a check that none of the three
words reaches an engine as an option of its own.
---
 test/embedded-protocol.test.js | 80 ++++++++++++++++++++++++++++++++++
 1 file changed, 80 insertions(+)

diff --git a/test/embedded-protocol.test.js b/test/embedded-protocol.test.js
index 47cb6bd2..2bf53b09 100644
--- a/test/embedded-protocol.test.js
+++ b/test/embedded-protocol.test.js
@@ -305,6 +305,41 @@ async function classicScriptMinify(input, sourceMap, minimizerOptions) {
   };
 }
 
+/**
+ * A handler body that is a syntax error inside the function too, so no
+ * minimizer can answer with the function it was handed.
+ */
+const BROKEN_HANDLER_BODY = "var = broken(";
+
+/**
+ * A document minifier handing out one `onclick=""` no JavaScript production
+ * holds. What parses is the minimizer's business, as it is for a `<script>`.
+ * @param {{ [file: string]: string }} input a single `{ filename: code }` entry
+ * @param {undefined} sourceMap unused
+ * @param {{ renderEmbeddedSource: (source: string, info: { type: string, as?: string }) => Promise<EXPECTED_ANY> }} minimizerOptions minimizer options
+ * @returns {Promise<EXPECTED_ANY>} the body as its minimizer wrote it
+ */
+async function brokenHandlerMinify(input, sourceMap, minimizerOptions) {
+  const rendered = await askRenderer(
+    minimizerOptions.renderEmbeddedSource,
+    BROKEN_HANDLER_BODY,
+    "javascript",
+    "event-handler",
+  );
+  const text = answerText(rendered);
+
+  return {
+    code: typeof text === "string" ? text : BROKEN_HANDLER_BODY,
+    ...answerDiagnostics([rendered]),
+  };
+}
+
+brokenHandlerMinify.getTypes = () => ["page"];
+brokenHandlerMinify.getEmbeddedTypes = () => ["javascript"];
+brokenHandlerMinify.supportsWorker = () => false;
+brokenHandlerMinify.supportsWorkerThreads = () => false;
+brokenHandlerMinify.filter = (name) => /\.page$/i.test(name);
+
 classicScriptMinify.getTypes = () => ["page"];
 classicScriptMinify.getEmbeddedTypes = () => ["javascript"];
 classicScriptMinify.supportsWorker = () => false;
@@ -654,6 +689,32 @@ describe("which production of JavaScript a body is written in", () => {
     );
   });
 
+  it.each([
+    ["terserMinify", MinimizerPlugin.terserMinify],
+    ["uglifyJsMinify", MinimizerPlugin.uglifyJsMinify],
+    ["swcMinify", MinimizerPlugin.swcMinify],
+    ["esbuildMinify", MinimizerPlugin.esbuildMinify],
+  ])("never hands the word itself to `%s`", async (name, minifier) => {
+    // Each engine rejects an unknown option outright — terser and uglify-js
+    // with "`as` is not a supported option", swc and esbuild in their own words.
+    for (const handOut of [
+      [moduleScriptMinify, "script"],
+      [moduleScriptMinify, "module"],
+      [eventHandlerMinify, undefined],
+    ]) {
+      const [document, as] = handOut;
+      const compiler = getPageCompiler(
+        [document, minifier],
+        [as === undefined ? {} : { as }, {}],
+      );
+      const stats = await compile(compiler);
+
+      expect(getErrors(stats).join("\n")).not.toMatch(
+        /supported option|unknown field|Invalid option/,
+      );
+    }
+  });
+
   it("leaves the production to the minimizer when none is named", async () => {
     const compiler = getPageCompiler([
       moduleScriptMinify,
@@ -743,3 +804,22 @@ describe("the function an event handler body is minified inside", () => {
     expect(functionBody(undefined)).toBeUndefined();
   });
 });
+
+describe("a handler body a minimizer does not answer with the function", () => {
+  it.each([
+    ["terserMinify", MinimizerPlugin.terserMinify],
+    ["uglifyJsMinify", MinimizerPlugin.uglifyJsMinify],
+    ["swcMinify", MinimizerPlugin.swcMinify],
+    ["esbuildMinify", MinimizerPlugin.esbuildMinify],
+  ])("keeps what it was written with under `%s`", async (name, minifier) => {
+    const compiler = getPageCompiler([brokenHandlerMinify, minifier]);
+    const stats = await compile(compiler);
+
+    // The body is a syntax error inside the function too, so nothing comes
+    // back to write and the attribute keeps the text it had.
+    expect(getErrors(stats)).toHaveLength(1);
+    expect(stats.compilation.getAsset("host.page").source.source()).toBe(
+      BROKEN_HANDLER_BODY,
+    );
+  });
+});