JSC (Bun) and some other engines emit a frames-only `Error.stack` without
the leading "Name: message" line V8 adds, so ModuleBuildError rendered loader
errors as bare stack frames with no message. Lead with the message when the
stack does not already contain it, then un-skip configCases/loaders/options
under Bun.

Bun (JSC) phrases the magic-comment syntax error and the JSON manifest parse
error differently than V8. Normalize both to the V8 form in the stats harness
(no-op on V8, which never emits those strings) and un-skip the two cases.

…p webpack-ignore

Bun (JSC) quotes the bad token and appends "Expected …" in magic-comment parse
errors where V8 does neither. Normalize to the V8 form in checkArrayExpectation
(no-op on V8) and un-skip configCases/css/webpack-ignore, which was mislabeled
as a less case but actually hit this phrasing difference.

Replace the vague "worker chunk does not run to completion" notes with the
diagnosed cause: a message queued while webpack's import() worker chunk loading
(Promise.race) is in flight stalls Bun's event loop. Also record why the logging
stats trace is engine-inherent (V8 vs JSC Error.stack shape and line:col).

…kip Bun

moduleScope matched the css bundle with /bundle.+.css/, which also matches the
.css.map source map; with readdirSync order unspecified, Bun picked the map file
so the linked stylesheet had no rules and getComputedStyle returned undefined.
Anchor the regex to .css. Deno kept skipped (separate undefined-CSS-export issue).

afterExecute snapshotted raw readdirSync output, whose order is
filesystem-dependent; Node happened to return alphabetical order (matching the
recorded snapshot) but Bun does not. Sort before snapshotting. Deno kept skipped
(separate undefined-CSS-export issue).

…orker HMR

Two Bun-specific issues in test/helpers/createFakeWorker.js:
- Bun implements the web Worker API, so assigning self.onmessage registers a
  native handler; forwarding parentPort messages to it too delivered every
  message twice (breaking HMR check() with reentrancy). Skip the forward on Bun.
- Bun's eval-worker module context is a blob: URL, from which require() of the
  emitted chunks (entry and hot-update) fails to resolve. Root require at a real
  file via module.createRequire.
Un-skip the three worker HMR cases; Node/Deno behavior is unchanged.

The case passes reliably on Bun now (verified 3x); remove the Bun-only filter.

findBundle matched bundle names with an unanchored regex, so `^bundle1` also
matched `bundle10`..`bundle17` and the first readdir match (order-dependent)
could be the wrong bundle with a different hash length. Anchor with a trailing
dot. Deno kept skipped (separate output difference).

Fixed by the createFakeWorker eval-worker require fix; verified passing on Bun
across normal, minimized, and source-map variants, and on Node.

The out-of-bounds call_indirect trap message differs by engine; the test already
tolerated several V8 wordings, so add JSC's "Out of bounds call_indirect". Deno
kept skipped (separate hard-panic).

The `this` external throws because top-level `this` is undefined in ESM; JSC
phrases it "undefined is not an object" vs V8's "Cannot read property...". Accept
both in the assertion.

The case passes on Bun now across Node/Web/WebWorker hot suites and on Node;
remove the Bun-only filter.

The worker attached parentPort.on after `await import()`; Bun drops a message
posted before the listener is attached during async worker startup (Node buffers
it). This case tests global Worker resolution, not top-level await, so move the
import into the handler and attach the listener synchronously. Deno kept skipped.

Earlier comments claimed the chunk-load promise never resolves; investigation
shows it does resolve and the listener does attach. The real cause: Bun drops a
worker message posted before the listener is attached when attachment is deferred
past the worker's async-module startup (Node/browsers buffer it). Reproduces
running the emitted bundle outside jest, so it is not a jest issue.

The logging stats snapshot embedded raw engine stack traces: V8 emits one
"at fn (file:line:col)" frame, while JSC (Bun) emits extra internal frames
(its LOADER_EXECUTION frame is unnamed so cutOffLoaderExecution can't trim it),
omits the function name, and reports different line:col. Normalize trace frames
to the in-test-dir file path so the snapshot is engine-independent.

…sal/webworker cases

Browsers queue messages posted to a worker until onmessage is assigned; the
worker module often sets it only after async (module) startup. The fake Worker
delivered via parentPort.on directly, so under Bun a message posted before
self.onmessage was set was lost (module workers), and Bun's web-Worker API also
double-dispatched. Define self.onmessage as an accessor with a message buffer:
this emulates the browser queue and prevents Bun's native double-dispatch. Un-skip
worker/universal, css/universal, target/universal-all-module-types,
module/issue-17014-webworker, worker/self-import.

Two engine differences broke the blob-URL worker on Bun: (1) the publicPath is
derived from self.location by stripping "blob:" and the last path segment, but
Bun's URL.createObjectURL returns "blob:<id>" with no path separator (Node:
"blob:nodedata:<id>") so the bare id became the publicPath — build the blob
location from options.originalURL instead; (2) the worker uses parentPort as a
global, which Bun does not surface implicitly — expose self.parentPort. With the
earlier onmessage-buffer change this also removes the prior JSC SIGABRT.

webpack correctly externalizes every node builtin for module output here (the
verification loop — all builtins load and every import("…") is emitted — passes
on Bun). The sole failure was `expect(typeof repl.start).toBe("function")`: Bun's
repl module is a stub with no start. Guard that one interactive-builtin check so
it runs where implemented. Deno kept skipped (separate hard-panic).

These workers used a real worker_threads Worker and attached parentPort.on only
after `await import(chunk)`. Bun's real MessagePort does not buffer a message
that arrives during the worker's async-module startup (Node/browsers do), so the
posted message was dropped. Attach the listener synchronously before the await
while keeping a top-level await, so the async-module worker output is still
exercised. Deno kept skipped.

The ProfilingPlugin inspector concurrency error no longer reproduces on current
Bun: the case passes under both --runInBand and --workerThreads (isolated and in
the full watch suite). Remove the Bun-only filter.

Investigating the layer segfaults pinpointed the root cause: a vm-loaded ESM
module (jest SourceTextModule) that statically imports any node builtin crashes
Bun (SIGSEGV/SIGILL), and the less package is ESM importing module/fs/etc. So
every less-loader case crashes the whole Bun run, not just one test. These were
optimistically un-skipped earlier; restore the Bun skip with the accurate cause,
and correct the layer/context comments.

less-loader's default `import("less")` runs through jest's vm and crashes
Bun (SIGSEGV) because a vm-loaded ESM module that statically imports a node
builtin aborts the process. Passing `implementation: require("less")` makes
the loader use the CJS less and skip the dynamic import. The inline
cases/loaders/less-loader case uses a thin wrapper loader to inject it.

The crash is a RELEASE_ASSERT in Bun's NodeVMSourceTextModule::link()
(node:vm), hit only when less-loader runs `import("less")` through jest's vm.
Pass `implementation: require("less")` only under `process.versions.bun` so
Node keeps exercising the default ESM path exactly as before.

…acle

webpack's `require(esm)` "module.exports" unwrapping is runtime-agnostic; only
the native cross-check (Module._load) needs Node's require(esm), which Bun does
not implement. Assert webpack's output against literal values on every runtime
and gate the native comparison behind `crossCheckNative` instead of skipping
the whole case under Bun.

Bun ignores a runtime `NODE_TLS_REJECT_UNAUTHORIZED`, so the case's self-signed
HTTPS backend was never accepted under Bun's worker threads ("No update
available"). Point the backend at a test-local client that passes
`rejectUnauthorized: false` per request, scoping the bypass to this case, and
drop the Bun skip. Verified on Bun (worker threads, node + async-node) and Node.

…orker