[v3-2-test] UI: Rewrite modulepreload hrefs to the api-server static path (#67548) by github-actions[bot] · Pull Request #67556 · apache/airflow

github-actions · 2026-05-26T13:58:28Z

UI: Fix Monaco workers crashing in production mode

?url does not run the Vite worker pipeline. For editor.worker.js it
inlines the raw source as a base64 data URL (the source is below the
default assetsInlineLimit), and the inlined module still has bare
specifier imports it cannot resolve in a Worker context. For
json.worker.js it copies a partly-bundled file whose top-level
import '../../editor/editor.worker.js' resolves to a path that does
not exist in the build output. Both cases manifest at runtime as
"Could not create web worker(s). Falling back to loading web worker
code in main thread" followed by a stream of fallback fetch errors.

Switch to ?worker&url: Vite runs the file through the worker pipeline
(bundling all dependencies into a self-contained IIFE) and the URL
query suffix returns the resulting URL as a string instead of a Worker
constructor. The Blob shim from #67352 then imports a properly bundled
worker, restoring real worker-thread execution.

UI: Rewrite modulepreload hrefs to the api-server static path

Vite emits both <script src="./assets/..."> and
<link rel="modulepreload" href="./assets/..."> for chunks in the
built index.html. The transform-url-src plugin only rewrote
src="./assets/" to src="./static/assets/", leaving the
modulepreload hrefs untouched. Behind the api-server's /static/
mount those preload requests hit the SPA HTML fallback and the
browser fails them with Expected a JavaScript-or-Wasm module script but the server responded with a MIME type of "text/html". The chunks
themselves still load via <script src> so the app works, but every
page load wastes three round-trips on the failed preloads and floods
the console.

Apply the same static/ rewrite to href="./assets/" and switch all
three rewrites to replaceAll so multiple matches (one per chunk) are
handled — replace with a string only touches the first occurrence.

(cherry picked from commit eff567c)

Co-authored-by: Pierre Jeambrun pierrejbrun@gmail.com
Co-authored-by: Rahul Vats 43964496+vatsrahul1001@users.noreply.github.com

…path (#67548) * UI: Fix Monaco workers crashing in production mode `?url` does not run the Vite worker pipeline. For `editor.worker.js` it inlines the raw source as a base64 data URL (the source is below the default `assetsInlineLimit`), and the inlined module still has bare specifier imports it cannot resolve in a Worker context. For `json.worker.js` it copies a partly-bundled file whose top-level `import '../../editor/editor.worker.js'` resolves to a path that does not exist in the build output. Both cases manifest at runtime as "Could not create web worker(s). Falling back to loading web worker code in main thread" followed by a stream of fallback fetch errors. Switch to `?worker&url`: Vite runs the file through the worker pipeline (bundling all dependencies into a self-contained IIFE) and the URL query suffix returns the resulting URL as a string instead of a Worker constructor. The Blob shim from #67352 then imports a properly bundled worker, restoring real worker-thread execution. * UI: Rewrite modulepreload hrefs to the api-server static path Vite emits both `<script src="./assets/...">` and `<link rel="modulepreload" href="./assets/...">` for chunks in the built `index.html`. The `transform-url-src` plugin only rewrote `src="./assets/"` to `src="./static/assets/"`, leaving the modulepreload `href`s untouched. Behind the api-server's `/static/` mount those preload requests hit the SPA HTML fallback and the browser fails them with `Expected a JavaScript-or-Wasm module script but the server responded with a MIME type of "text/html"`. The chunks themselves still load via `<script src>` so the app works, but every page load wastes three round-trips on the failed preloads and floods the console. Apply the same `static/` rewrite to `href="./assets/"` and switch all three rewrites to `replaceAll` so multiple matches (one per chunk) are handled — `replace` with a string only touches the first occurrence. --------- (cherry picked from commit eff567c) Co-authored-by: Pierre Jeambrun <pierrejbrun@gmail.com> Co-authored-by: Rahul Vats <43964496+vatsrahul1001@users.noreply.github.com>

…path (#67548) (#67556) * UI: Fix Monaco workers crashing in production mode `?url` does not run the Vite worker pipeline. For `editor.worker.js` it inlines the raw source as a base64 data URL (the source is below the default `assetsInlineLimit`), and the inlined module still has bare specifier imports it cannot resolve in a Worker context. For `json.worker.js` it copies a partly-bundled file whose top-level `import '../../editor/editor.worker.js'` resolves to a path that does not exist in the build output. Both cases manifest at runtime as "Could not create web worker(s). Falling back to loading web worker code in main thread" followed by a stream of fallback fetch errors. Switch to `?worker&url`: Vite runs the file through the worker pipeline (bundling all dependencies into a self-contained IIFE) and the URL query suffix returns the resulting URL as a string instead of a Worker constructor. The Blob shim from #67352 then imports a properly bundled worker, restoring real worker-thread execution. * UI: Rewrite modulepreload hrefs to the api-server static path Vite emits both `<script src="./assets/...">` and `<link rel="modulepreload" href="./assets/...">` for chunks in the built `index.html`. The `transform-url-src` plugin only rewrote `src="./assets/"` to `src="./static/assets/"`, leaving the modulepreload `href`s untouched. Behind the api-server's `/static/` mount those preload requests hit the SPA HTML fallback and the browser fails them with `Expected a JavaScript-or-Wasm module script but the server responded with a MIME type of "text/html"`. The chunks themselves still load via `<script src>` so the app works, but every page load wastes three round-trips on the failed preloads and floods the console. Apply the same `static/` rewrite to `href="./assets/"` and switch all three rewrites to `replaceAll` so multiple matches (one per chunk) are handled — `replace` with a string only touches the first occurrence. --------- (cherry picked from commit eff567c) Co-authored-by: Pierre Jeambrun <pierrejbrun@gmail.com> Co-authored-by: Rahul Vats <43964496+vatsrahul1001@users.noreply.github.com>

github-actions · 2026-05-26T13:58:28Z

UI: Fix Monaco workers crashing in production mode

?url does not run the Vite worker pipeline. For editor.worker.js it
inlines the raw source as a base64 data URL (the source is below the
default assetsInlineLimit), and the inlined module still has bare
specifier imports it cannot resolve in a Worker context. For
json.worker.js it copies a partly-bundled file whose top-level
import '../../editor/editor.worker.js' resolves to a path that does
not exist in the build output. Both cases manifest at runtime as
"Could not create web worker(s). Falling back to loading web worker
code in main thread" followed by a stream of fallback fetch errors.

Switch to ?worker&url: Vite runs the file through the worker pipeline
(bundling all dependencies into a self-contained IIFE) and the URL
query suffix returns the resulting URL as a string instead of a Worker
constructor. The Blob shim from #67352 then imports a properly bundled
worker, restoring real worker-thread execution.

UI: Rewrite modulepreload hrefs to the api-server static path

Vite emits both <script src="./assets/..."> and
<link rel="modulepreload" href="./assets/..."> for chunks in the
built index.html. The transform-url-src plugin only rewrote
src="./assets/" to src="./static/assets/", leaving the
modulepreload hrefs untouched. Behind the api-server's /static/
mount those preload requests hit the SPA HTML fallback and the
browser fails them with Expected a JavaScript-or-Wasm module script but the server responded with a MIME type of "text/html". The chunks
themselves still load via <script src> so the app works, but every
page load wastes three round-trips on the failed preloads and floods
the console.

Apply the same static/ rewrite to href="./assets/" and switch all
three rewrites to replaceAll so multiple matches (one per chunk) are
handled — replace with a string only touches the first occurrence.

(cherry picked from commit eff567c)

Co-authored-by: Pierre Jeambrun pierrejbrun@gmail.com
Co-authored-by: Rahul Vats 43964496+vatsrahul1001@users.noreply.github.com

…path (#67548) * UI: Fix Monaco workers crashing in production mode `?url` does not run the Vite worker pipeline. For `editor.worker.js` it inlines the raw source as a base64 data URL (the source is below the default `assetsInlineLimit`), and the inlined module still has bare specifier imports it cannot resolve in a Worker context. For `json.worker.js` it copies a partly-bundled file whose top-level `import '../../editor/editor.worker.js'` resolves to a path that does not exist in the build output. Both cases manifest at runtime as "Could not create web worker(s). Falling back to loading web worker code in main thread" followed by a stream of fallback fetch errors. Switch to `?worker&url`: Vite runs the file through the worker pipeline (bundling all dependencies into a self-contained IIFE) and the URL query suffix returns the resulting URL as a string instead of a Worker constructor. The Blob shim from #67352 then imports a properly bundled worker, restoring real worker-thread execution. * UI: Rewrite modulepreload hrefs to the api-server static path Vite emits both `<script src="./assets/...">` and `<link rel="modulepreload" href="./assets/...">` for chunks in the built `index.html`. The `transform-url-src` plugin only rewrote `src="./assets/"` to `src="./static/assets/"`, leaving the modulepreload `href`s untouched. Behind the api-server's `/static/` mount those preload requests hit the SPA HTML fallback and the browser fails them with `Expected a JavaScript-or-Wasm module script but the server responded with a MIME type of "text/html"`. The chunks themselves still load via `<script src>` so the app works, but every page load wastes three round-trips on the failed preloads and floods the console. Apply the same `static/` rewrite to `href="./assets/"` and switch all three rewrites to `replaceAll` so multiple matches (one per chunk) are handled — `replace` with a string only touches the first occurrence. --------- (cherry picked from commit eff567c) Co-authored-by: Pierre Jeambrun <pierrejbrun@gmail.com> Co-authored-by: Rahul Vats <43964496+vatsrahul1001@users.noreply.github.com>

…path (#67548) (#67556) * UI: Fix Monaco workers crashing in production mode `?url` does not run the Vite worker pipeline. For `editor.worker.js` it inlines the raw source as a base64 data URL (the source is below the default `assetsInlineLimit`), and the inlined module still has bare specifier imports it cannot resolve in a Worker context. For `json.worker.js` it copies a partly-bundled file whose top-level `import '../../editor/editor.worker.js'` resolves to a path that does not exist in the build output. Both cases manifest at runtime as "Could not create web worker(s). Falling back to loading web worker code in main thread" followed by a stream of fallback fetch errors. Switch to `?worker&url`: Vite runs the file through the worker pipeline (bundling all dependencies into a self-contained IIFE) and the URL query suffix returns the resulting URL as a string instead of a Worker constructor. The Blob shim from #67352 then imports a properly bundled worker, restoring real worker-thread execution. * UI: Rewrite modulepreload hrefs to the api-server static path Vite emits both `<script src="./assets/...">` and `<link rel="modulepreload" href="./assets/...">` for chunks in the built `index.html`. The `transform-url-src` plugin only rewrote `src="./assets/"` to `src="./static/assets/"`, leaving the modulepreload `href`s untouched. Behind the api-server's `/static/` mount those preload requests hit the SPA HTML fallback and the browser fails them with `Expected a JavaScript-or-Wasm module script but the server responded with a MIME type of "text/html"`. The chunks themselves still load via `<script src>` so the app works, but every page load wastes three round-trips on the failed preloads and floods the console. Apply the same `static/` rewrite to `href="./assets/"` and switch all three rewrites to `replaceAll` so multiple matches (one per chunk) are handled — `replace` with a string only touches the first occurrence. --------- (cherry picked from commit eff567c) Co-authored-by: Pierre Jeambrun <pierrejbrun@gmail.com> Co-authored-by: Rahul Vats <43964496+vatsrahul1001@users.noreply.github.com>

github-actions · 2026-05-26T13:58:28Z

UI: Fix Monaco workers crashing in production mode

?url does not run the Vite worker pipeline. For editor.worker.js it
inlines the raw source as a base64 data URL (the source is below the
default assetsInlineLimit), and the inlined module still has bare
specifier imports it cannot resolve in a Worker context. For
json.worker.js it copies a partly-bundled file whose top-level
import '../../editor/editor.worker.js' resolves to a path that does
not exist in the build output. Both cases manifest at runtime as
"Could not create web worker(s). Falling back to loading web worker
code in main thread" followed by a stream of fallback fetch errors.

Switch to ?worker&url: Vite runs the file through the worker pipeline
(bundling all dependencies into a self-contained IIFE) and the URL
query suffix returns the resulting URL as a string instead of a Worker
constructor. The Blob shim from #67352 then imports a properly bundled
worker, restoring real worker-thread execution.

UI: Rewrite modulepreload hrefs to the api-server static path

Vite emits both <script src="./assets/..."> and
<link rel="modulepreload" href="./assets/..."> for chunks in the
built index.html. The transform-url-src plugin only rewrote
src="./assets/" to src="./static/assets/", leaving the
modulepreload hrefs untouched. Behind the api-server's /static/
mount those preload requests hit the SPA HTML fallback and the
browser fails them with Expected a JavaScript-or-Wasm module script but the server responded with a MIME type of "text/html". The chunks
themselves still load via <script src> so the app works, but every
page load wastes three round-trips on the failed preloads and floods
the console.

Apply the same static/ rewrite to href="./assets/" and switch all
three rewrites to replaceAll so multiple matches (one per chunk) are
handled — replace with a string only touches the first occurrence.

(cherry picked from commit eff567c)

Co-authored-by: Pierre Jeambrun pierrejbrun@gmail.com
Co-authored-by: Rahul Vats 43964496+vatsrahul1001@users.noreply.github.com

…path (#67548) * UI: Fix Monaco workers crashing in production mode `?url` does not run the Vite worker pipeline. For `editor.worker.js` it inlines the raw source as a base64 data URL (the source is below the default `assetsInlineLimit`), and the inlined module still has bare specifier imports it cannot resolve in a Worker context. For `json.worker.js` it copies a partly-bundled file whose top-level `import '../../editor/editor.worker.js'` resolves to a path that does not exist in the build output. Both cases manifest at runtime as "Could not create web worker(s). Falling back to loading web worker code in main thread" followed by a stream of fallback fetch errors. Switch to `?worker&url`: Vite runs the file through the worker pipeline (bundling all dependencies into a self-contained IIFE) and the URL query suffix returns the resulting URL as a string instead of a Worker constructor. The Blob shim from #67352 then imports a properly bundled worker, restoring real worker-thread execution. * UI: Rewrite modulepreload hrefs to the api-server static path Vite emits both `<script src="./assets/...">` and `<link rel="modulepreload" href="./assets/...">` for chunks in the built `index.html`. The `transform-url-src` plugin only rewrote `src="./assets/"` to `src="./static/assets/"`, leaving the modulepreload `href`s untouched. Behind the api-server's `/static/` mount those preload requests hit the SPA HTML fallback and the browser fails them with `Expected a JavaScript-or-Wasm module script but the server responded with a MIME type of "text/html"`. The chunks themselves still load via `<script src>` so the app works, but every page load wastes three round-trips on the failed preloads and floods the console. Apply the same `static/` rewrite to `href="./assets/"` and switch all three rewrites to `replaceAll` so multiple matches (one per chunk) are handled — `replace` with a string only touches the first occurrence. --------- (cherry picked from commit eff567c) Co-authored-by: Pierre Jeambrun <pierrejbrun@gmail.com> Co-authored-by: Rahul Vats <43964496+vatsrahul1001@users.noreply.github.com>

…path (#67548) (#67556) * UI: Fix Monaco workers crashing in production mode `?url` does not run the Vite worker pipeline. For `editor.worker.js` it inlines the raw source as a base64 data URL (the source is below the default `assetsInlineLimit`), and the inlined module still has bare specifier imports it cannot resolve in a Worker context. For `json.worker.js` it copies a partly-bundled file whose top-level `import '../../editor/editor.worker.js'` resolves to a path that does not exist in the build output. Both cases manifest at runtime as "Could not create web worker(s). Falling back to loading web worker code in main thread" followed by a stream of fallback fetch errors. Switch to `?worker&url`: Vite runs the file through the worker pipeline (bundling all dependencies into a self-contained IIFE) and the URL query suffix returns the resulting URL as a string instead of a Worker constructor. The Blob shim from #67352 then imports a properly bundled worker, restoring real worker-thread execution. * UI: Rewrite modulepreload hrefs to the api-server static path Vite emits both `<script src="./assets/...">` and `<link rel="modulepreload" href="./assets/...">` for chunks in the built `index.html`. The `transform-url-src` plugin only rewrote `src="./assets/"` to `src="./static/assets/"`, leaving the modulepreload `href`s untouched. Behind the api-server's `/static/` mount those preload requests hit the SPA HTML fallback and the browser fails them with `Expected a JavaScript-or-Wasm module script but the server responded with a MIME type of "text/html"`. The chunks themselves still load via `<script src>` so the app works, but every page load wastes three round-trips on the failed preloads and floods the console. Apply the same `static/` rewrite to `href="./assets/"` and switch all three rewrites to `replaceAll` so multiple matches (one per chunk) are handled — `replace` with a string only touches the first occurrence. --------- (cherry picked from commit eff567c) Co-authored-by: Pierre Jeambrun <pierrejbrun@gmail.com> Co-authored-by: Rahul Vats <43964496+vatsrahul1001@users.noreply.github.com>

github-actions · 2026-05-26T13:58:28Z

UI: Fix Monaco workers crashing in production mode

?url does not run the Vite worker pipeline. For editor.worker.js it
inlines the raw source as a base64 data URL (the source is below the
default assetsInlineLimit), and the inlined module still has bare
specifier imports it cannot resolve in a Worker context. For
json.worker.js it copies a partly-bundled file whose top-level
import '../../editor/editor.worker.js' resolves to a path that does
not exist in the build output. Both cases manifest at runtime as
"Could not create web worker(s). Falling back to loading web worker
code in main thread" followed by a stream of fallback fetch errors.

Switch to ?worker&url: Vite runs the file through the worker pipeline
(bundling all dependencies into a self-contained IIFE) and the URL
query suffix returns the resulting URL as a string instead of a Worker
constructor. The Blob shim from #67352 then imports a properly bundled
worker, restoring real worker-thread execution.

UI: Rewrite modulepreload hrefs to the api-server static path

Vite emits both <script src="./assets/..."> and
<link rel="modulepreload" href="./assets/..."> for chunks in the
built index.html. The transform-url-src plugin only rewrote
src="./assets/" to src="./static/assets/", leaving the
modulepreload hrefs untouched. Behind the api-server's /static/
mount those preload requests hit the SPA HTML fallback and the
browser fails them with Expected a JavaScript-or-Wasm module script but the server responded with a MIME type of "text/html". The chunks
themselves still load via <script src> so the app works, but every
page load wastes three round-trips on the failed preloads and floods
the console.

Apply the same static/ rewrite to href="./assets/" and switch all
three rewrites to replaceAll so multiple matches (one per chunk) are
handled — replace with a string only touches the first occurrence.

(cherry picked from commit eff567c)

Co-authored-by: Pierre Jeambrun pierrejbrun@gmail.com
Co-authored-by: Rahul Vats 43964496+vatsrahul1001@users.noreply.github.com

…path (#67548) * UI: Fix Monaco workers crashing in production mode `?url` does not run the Vite worker pipeline. For `editor.worker.js` it inlines the raw source as a base64 data URL (the source is below the default `assetsInlineLimit`), and the inlined module still has bare specifier imports it cannot resolve in a Worker context. For `json.worker.js` it copies a partly-bundled file whose top-level `import '../../editor/editor.worker.js'` resolves to a path that does not exist in the build output. Both cases manifest at runtime as "Could not create web worker(s). Falling back to loading web worker code in main thread" followed by a stream of fallback fetch errors. Switch to `?worker&url`: Vite runs the file through the worker pipeline (bundling all dependencies into a self-contained IIFE) and the URL query suffix returns the resulting URL as a string instead of a Worker constructor. The Blob shim from #67352 then imports a properly bundled worker, restoring real worker-thread execution. * UI: Rewrite modulepreload hrefs to the api-server static path Vite emits both `<script src="./assets/...">` and `<link rel="modulepreload" href="./assets/...">` for chunks in the built `index.html`. The `transform-url-src` plugin only rewrote `src="./assets/"` to `src="./static/assets/"`, leaving the modulepreload `href`s untouched. Behind the api-server's `/static/` mount those preload requests hit the SPA HTML fallback and the browser fails them with `Expected a JavaScript-or-Wasm module script but the server responded with a MIME type of "text/html"`. The chunks themselves still load via `<script src>` so the app works, but every page load wastes three round-trips on the failed preloads and floods the console. Apply the same `static/` rewrite to `href="./assets/"` and switch all three rewrites to `replaceAll` so multiple matches (one per chunk) are handled — `replace` with a string only touches the first occurrence. --------- (cherry picked from commit eff567c) Co-authored-by: Pierre Jeambrun <pierrejbrun@gmail.com> Co-authored-by: Rahul Vats <43964496+vatsrahul1001@users.noreply.github.com>

…path (#67548) (#67556) * UI: Fix Monaco workers crashing in production mode `?url` does not run the Vite worker pipeline. For `editor.worker.js` it inlines the raw source as a base64 data URL (the source is below the default `assetsInlineLimit`), and the inlined module still has bare specifier imports it cannot resolve in a Worker context. For `json.worker.js` it copies a partly-bundled file whose top-level `import '../../editor/editor.worker.js'` resolves to a path that does not exist in the build output. Both cases manifest at runtime as "Could not create web worker(s). Falling back to loading web worker code in main thread" followed by a stream of fallback fetch errors. Switch to `?worker&url`: Vite runs the file through the worker pipeline (bundling all dependencies into a self-contained IIFE) and the URL query suffix returns the resulting URL as a string instead of a Worker constructor. The Blob shim from #67352 then imports a properly bundled worker, restoring real worker-thread execution. * UI: Rewrite modulepreload hrefs to the api-server static path Vite emits both `<script src="./assets/...">` and `<link rel="modulepreload" href="./assets/...">` for chunks in the built `index.html`. The `transform-url-src` plugin only rewrote `src="./assets/"` to `src="./static/assets/"`, leaving the modulepreload `href`s untouched. Behind the api-server's `/static/` mount those preload requests hit the SPA HTML fallback and the browser fails them with `Expected a JavaScript-or-Wasm module script but the server responded with a MIME type of "text/html"`. The chunks themselves still load via `<script src>` so the app works, but every page load wastes three round-trips on the failed preloads and floods the console. Apply the same `static/` rewrite to `href="./assets/"` and switch all three rewrites to `replaceAll` so multiple matches (one per chunk) are handled — `replace` with a string only touches the first occurrence. --------- (cherry picked from commit eff567c) Co-authored-by: Pierre Jeambrun <pierrejbrun@gmail.com> Co-authored-by: Rahul Vats <43964496+vatsrahul1001@users.noreply.github.com>

github-actions · 2026-05-26T13:58:28Z

UI: Fix Monaco workers crashing in production mode

?url does not run the Vite worker pipeline. For editor.worker.js it
inlines the raw source as a base64 data URL (the source is below the
default assetsInlineLimit), and the inlined module still has bare
specifier imports it cannot resolve in a Worker context. For
json.worker.js it copies a partly-bundled file whose top-level
import '../../editor/editor.worker.js' resolves to a path that does
not exist in the build output. Both cases manifest at runtime as
"Could not create web worker(s). Falling back to loading web worker
code in main thread" followed by a stream of fallback fetch errors.

Switch to ?worker&url: Vite runs the file through the worker pipeline
(bundling all dependencies into a self-contained IIFE) and the URL
query suffix returns the resulting URL as a string instead of a Worker
constructor. The Blob shim from #67352 then imports a properly bundled
worker, restoring real worker-thread execution.

UI: Rewrite modulepreload hrefs to the api-server static path

Vite emits both <script src="./assets/..."> and
<link rel="modulepreload" href="./assets/..."> for chunks in the
built index.html. The transform-url-src plugin only rewrote
src="./assets/" to src="./static/assets/", leaving the
modulepreload hrefs untouched. Behind the api-server's /static/
mount those preload requests hit the SPA HTML fallback and the
browser fails them with Expected a JavaScript-or-Wasm module script but the server responded with a MIME type of "text/html". The chunks
themselves still load via <script src> so the app works, but every
page load wastes three round-trips on the failed preloads and floods
the console.

Apply the same static/ rewrite to href="./assets/" and switch all
three rewrites to replaceAll so multiple matches (one per chunk) are
handled — replace with a string only touches the first occurrence.

(cherry picked from commit eff567c)

Co-authored-by: Pierre Jeambrun pierrejbrun@gmail.com
Co-authored-by: Rahul Vats 43964496+vatsrahul1001@users.noreply.github.com

…path (#67548) * UI: Fix Monaco workers crashing in production mode `?url` does not run the Vite worker pipeline. For `editor.worker.js` it inlines the raw source as a base64 data URL (the source is below the default `assetsInlineLimit`), and the inlined module still has bare specifier imports it cannot resolve in a Worker context. For `json.worker.js` it copies a partly-bundled file whose top-level `import '../../editor/editor.worker.js'` resolves to a path that does not exist in the build output. Both cases manifest at runtime as "Could not create web worker(s). Falling back to loading web worker code in main thread" followed by a stream of fallback fetch errors. Switch to `?worker&url`: Vite runs the file through the worker pipeline (bundling all dependencies into a self-contained IIFE) and the URL query suffix returns the resulting URL as a string instead of a Worker constructor. The Blob shim from #67352 then imports a properly bundled worker, restoring real worker-thread execution. * UI: Rewrite modulepreload hrefs to the api-server static path Vite emits both `<script src="./assets/...">` and `<link rel="modulepreload" href="./assets/...">` for chunks in the built `index.html`. The `transform-url-src` plugin only rewrote `src="./assets/"` to `src="./static/assets/"`, leaving the modulepreload `href`s untouched. Behind the api-server's `/static/` mount those preload requests hit the SPA HTML fallback and the browser fails them with `Expected a JavaScript-or-Wasm module script but the server responded with a MIME type of "text/html"`. The chunks themselves still load via `<script src>` so the app works, but every page load wastes three round-trips on the failed preloads and floods the console. Apply the same `static/` rewrite to `href="./assets/"` and switch all three rewrites to `replaceAll` so multiple matches (one per chunk) are handled — `replace` with a string only touches the first occurrence. --------- (cherry picked from commit eff567c) Co-authored-by: Pierre Jeambrun <pierrejbrun@gmail.com> Co-authored-by: Rahul Vats <43964496+vatsrahul1001@users.noreply.github.com>

…path (#67548) (#67556) * UI: Fix Monaco workers crashing in production mode `?url` does not run the Vite worker pipeline. For `editor.worker.js` it inlines the raw source as a base64 data URL (the source is below the default `assetsInlineLimit`), and the inlined module still has bare specifier imports it cannot resolve in a Worker context. For `json.worker.js` it copies a partly-bundled file whose top-level `import '../../editor/editor.worker.js'` resolves to a path that does not exist in the build output. Both cases manifest at runtime as "Could not create web worker(s). Falling back to loading web worker code in main thread" followed by a stream of fallback fetch errors. Switch to `?worker&url`: Vite runs the file through the worker pipeline (bundling all dependencies into a self-contained IIFE) and the URL query suffix returns the resulting URL as a string instead of a Worker constructor. The Blob shim from #67352 then imports a properly bundled worker, restoring real worker-thread execution. * UI: Rewrite modulepreload hrefs to the api-server static path Vite emits both `<script src="./assets/...">` and `<link rel="modulepreload" href="./assets/...">` for chunks in the built `index.html`. The `transform-url-src` plugin only rewrote `src="./assets/"` to `src="./static/assets/"`, leaving the modulepreload `href`s untouched. Behind the api-server's `/static/` mount those preload requests hit the SPA HTML fallback and the browser fails them with `Expected a JavaScript-or-Wasm module script but the server responded with a MIME type of "text/html"`. The chunks themselves still load via `<script src>` so the app works, but every page load wastes three round-trips on the failed preloads and floods the console. Apply the same `static/` rewrite to `href="./assets/"` and switch all three rewrites to `replaceAll` so multiple matches (one per chunk) are handled — `replace` with a string only touches the first occurrence. --------- (cherry picked from commit eff567c) Co-authored-by: Pierre Jeambrun <pierrejbrun@gmail.com> Co-authored-by: Rahul Vats <43964496+vatsrahul1001@users.noreply.github.com>

github-actions · 2026-05-26T13:58:28Z

UI: Fix Monaco workers crashing in production mode

?url does not run the Vite worker pipeline. For editor.worker.js it
inlines the raw source as a base64 data URL (the source is below the
default assetsInlineLimit), and the inlined module still has bare
specifier imports it cannot resolve in a Worker context. For
json.worker.js it copies a partly-bundled file whose top-level
import '../../editor/editor.worker.js' resolves to a path that does
not exist in the build output. Both cases manifest at runtime as
"Could not create web worker(s). Falling back to loading web worker
code in main thread" followed by a stream of fallback fetch errors.

Switch to ?worker&url: Vite runs the file through the worker pipeline
(bundling all dependencies into a self-contained IIFE) and the URL
query suffix returns the resulting URL as a string instead of a Worker
constructor. The Blob shim from #67352 then imports a properly bundled
worker, restoring real worker-thread execution.

UI: Rewrite modulepreload hrefs to the api-server static path

Vite emits both <script src="./assets/..."> and
<link rel="modulepreload" href="./assets/..."> for chunks in the
built index.html. The transform-url-src plugin only rewrote
src="./assets/" to src="./static/assets/", leaving the
modulepreload hrefs untouched. Behind the api-server's /static/
mount those preload requests hit the SPA HTML fallback and the
browser fails them with Expected a JavaScript-or-Wasm module script but the server responded with a MIME type of "text/html". The chunks
themselves still load via <script src> so the app works, but every
page load wastes three round-trips on the failed preloads and floods
the console.

Apply the same static/ rewrite to href="./assets/" and switch all
three rewrites to replaceAll so multiple matches (one per chunk) are
handled — replace with a string only touches the first occurrence.

(cherry picked from commit eff567c)

Co-authored-by: Pierre Jeambrun pierrejbrun@gmail.com
Co-authored-by: Rahul Vats 43964496+vatsrahul1001@users.noreply.github.com

…path (#67548) * UI: Fix Monaco workers crashing in production mode `?url` does not run the Vite worker pipeline. For `editor.worker.js` it inlines the raw source as a base64 data URL (the source is below the default `assetsInlineLimit`), and the inlined module still has bare specifier imports it cannot resolve in a Worker context. For `json.worker.js` it copies a partly-bundled file whose top-level `import '../../editor/editor.worker.js'` resolves to a path that does not exist in the build output. Both cases manifest at runtime as "Could not create web worker(s). Falling back to loading web worker code in main thread" followed by a stream of fallback fetch errors. Switch to `?worker&url`: Vite runs the file through the worker pipeline (bundling all dependencies into a self-contained IIFE) and the URL query suffix returns the resulting URL as a string instead of a Worker constructor. The Blob shim from #67352 then imports a properly bundled worker, restoring real worker-thread execution. * UI: Rewrite modulepreload hrefs to the api-server static path Vite emits both `<script src="./assets/...">` and `<link rel="modulepreload" href="./assets/...">` for chunks in the built `index.html`. The `transform-url-src` plugin only rewrote `src="./assets/"` to `src="./static/assets/"`, leaving the modulepreload `href`s untouched. Behind the api-server's `/static/` mount those preload requests hit the SPA HTML fallback and the browser fails them with `Expected a JavaScript-or-Wasm module script but the server responded with a MIME type of "text/html"`. The chunks themselves still load via `<script src>` so the app works, but every page load wastes three round-trips on the failed preloads and floods the console. Apply the same `static/` rewrite to `href="./assets/"` and switch all three rewrites to `replaceAll` so multiple matches (one per chunk) are handled — `replace` with a string only touches the first occurrence. --------- (cherry picked from commit eff567c) Co-authored-by: Pierre Jeambrun <pierrejbrun@gmail.com> Co-authored-by: Rahul Vats <43964496+vatsrahul1001@users.noreply.github.com>

…path (#67548) (#67556) * UI: Fix Monaco workers crashing in production mode `?url` does not run the Vite worker pipeline. For `editor.worker.js` it inlines the raw source as a base64 data URL (the source is below the default `assetsInlineLimit`), and the inlined module still has bare specifier imports it cannot resolve in a Worker context. For `json.worker.js` it copies a partly-bundled file whose top-level `import '../../editor/editor.worker.js'` resolves to a path that does not exist in the build output. Both cases manifest at runtime as "Could not create web worker(s). Falling back to loading web worker code in main thread" followed by a stream of fallback fetch errors. Switch to `?worker&url`: Vite runs the file through the worker pipeline (bundling all dependencies into a self-contained IIFE) and the URL query suffix returns the resulting URL as a string instead of a Worker constructor. The Blob shim from #67352 then imports a properly bundled worker, restoring real worker-thread execution. * UI: Rewrite modulepreload hrefs to the api-server static path Vite emits both `<script src="./assets/...">` and `<link rel="modulepreload" href="./assets/...">` for chunks in the built `index.html`. The `transform-url-src` plugin only rewrote `src="./assets/"` to `src="./static/assets/"`, leaving the modulepreload `href`s untouched. Behind the api-server's `/static/` mount those preload requests hit the SPA HTML fallback and the browser fails them with `Expected a JavaScript-or-Wasm module script but the server responded with a MIME type of "text/html"`. The chunks themselves still load via `<script src>` so the app works, but every page load wastes three round-trips on the failed preloads and floods the console. Apply the same `static/` rewrite to `href="./assets/"` and switch all three rewrites to `replaceAll` so multiple matches (one per chunk) are handled — `replace` with a string only touches the first occurrence. --------- (cherry picked from commit eff567c) Co-authored-by: Pierre Jeambrun <pierrejbrun@gmail.com> Co-authored-by: Rahul Vats <43964496+vatsrahul1001@users.noreply.github.com>

github-actions · 2026-05-26T13:58:28Z

UI: Fix Monaco workers crashing in production mode

?url does not run the Vite worker pipeline. For editor.worker.js it
inlines the raw source as a base64 data URL (the source is below the
default assetsInlineLimit), and the inlined module still has bare
specifier imports it cannot resolve in a Worker context. For
json.worker.js it copies a partly-bundled file whose top-level
import '../../editor/editor.worker.js' resolves to a path that does
not exist in the build output. Both cases manifest at runtime as
"Could not create web worker(s). Falling back to loading web worker
code in main thread" followed by a stream of fallback fetch errors.

Switch to ?worker&url: Vite runs the file through the worker pipeline
(bundling all dependencies into a self-contained IIFE) and the URL
query suffix returns the resulting URL as a string instead of a Worker
constructor. The Blob shim from #67352 then imports a properly bundled
worker, restoring real worker-thread execution.

UI: Rewrite modulepreload hrefs to the api-server static path

Vite emits both <script src="./assets/..."> and
<link rel="modulepreload" href="./assets/..."> for chunks in the
built index.html. The transform-url-src plugin only rewrote
src="./assets/" to src="./static/assets/", leaving the
modulepreload hrefs untouched. Behind the api-server's /static/
mount those preload requests hit the SPA HTML fallback and the
browser fails them with Expected a JavaScript-or-Wasm module script but the server responded with a MIME type of "text/html". The chunks
themselves still load via <script src> so the app works, but every
page load wastes three round-trips on the failed preloads and floods
the console.

Apply the same static/ rewrite to href="./assets/" and switch all
three rewrites to replaceAll so multiple matches (one per chunk) are
handled — replace with a string only touches the first occurrence.

(cherry picked from commit eff567c)

Co-authored-by: Pierre Jeambrun pierrejbrun@gmail.com
Co-authored-by: Rahul Vats 43964496+vatsrahul1001@users.noreply.github.com

…path (#67548) * UI: Fix Monaco workers crashing in production mode `?url` does not run the Vite worker pipeline. For `editor.worker.js` it inlines the raw source as a base64 data URL (the source is below the default `assetsInlineLimit`), and the inlined module still has bare specifier imports it cannot resolve in a Worker context. For `json.worker.js` it copies a partly-bundled file whose top-level `import '../../editor/editor.worker.js'` resolves to a path that does not exist in the build output. Both cases manifest at runtime as "Could not create web worker(s). Falling back to loading web worker code in main thread" followed by a stream of fallback fetch errors. Switch to `?worker&url`: Vite runs the file through the worker pipeline (bundling all dependencies into a self-contained IIFE) and the URL query suffix returns the resulting URL as a string instead of a Worker constructor. The Blob shim from #67352 then imports a properly bundled worker, restoring real worker-thread execution. * UI: Rewrite modulepreload hrefs to the api-server static path Vite emits both `<script src="./assets/...">` and `<link rel="modulepreload" href="./assets/...">` for chunks in the built `index.html`. The `transform-url-src` plugin only rewrote `src="./assets/"` to `src="./static/assets/"`, leaving the modulepreload `href`s untouched. Behind the api-server's `/static/` mount those preload requests hit the SPA HTML fallback and the browser fails them with `Expected a JavaScript-or-Wasm module script but the server responded with a MIME type of "text/html"`. The chunks themselves still load via `<script src>` so the app works, but every page load wastes three round-trips on the failed preloads and floods the console. Apply the same `static/` rewrite to `href="./assets/"` and switch all three rewrites to `replaceAll` so multiple matches (one per chunk) are handled — `replace` with a string only touches the first occurrence. --------- (cherry picked from commit eff567c) Co-authored-by: Pierre Jeambrun <pierrejbrun@gmail.com> Co-authored-by: Rahul Vats <43964496+vatsrahul1001@users.noreply.github.com>

…path (#67548) (#67556) * UI: Fix Monaco workers crashing in production mode `?url` does not run the Vite worker pipeline. For `editor.worker.js` it inlines the raw source as a base64 data URL (the source is below the default `assetsInlineLimit`), and the inlined module still has bare specifier imports it cannot resolve in a Worker context. For `json.worker.js` it copies a partly-bundled file whose top-level `import '../../editor/editor.worker.js'` resolves to a path that does not exist in the build output. Both cases manifest at runtime as "Could not create web worker(s). Falling back to loading web worker code in main thread" followed by a stream of fallback fetch errors. Switch to `?worker&url`: Vite runs the file through the worker pipeline (bundling all dependencies into a self-contained IIFE) and the URL query suffix returns the resulting URL as a string instead of a Worker constructor. The Blob shim from #67352 then imports a properly bundled worker, restoring real worker-thread execution. * UI: Rewrite modulepreload hrefs to the api-server static path Vite emits both `<script src="./assets/...">` and `<link rel="modulepreload" href="./assets/...">` for chunks in the built `index.html`. The `transform-url-src` plugin only rewrote `src="./assets/"` to `src="./static/assets/"`, leaving the modulepreload `href`s untouched. Behind the api-server's `/static/` mount those preload requests hit the SPA HTML fallback and the browser fails them with `Expected a JavaScript-or-Wasm module script but the server responded with a MIME type of "text/html"`. The chunks themselves still load via `<script src>` so the app works, but every page load wastes three round-trips on the failed preloads and floods the console. Apply the same `static/` rewrite to `href="./assets/"` and switch all three rewrites to `replaceAll` so multiple matches (one per chunk) are handled — `replace` with a string only touches the first occurrence. --------- (cherry picked from commit eff567c) Co-authored-by: Pierre Jeambrun <pierrejbrun@gmail.com> Co-authored-by: Rahul Vats <43964496+vatsrahul1001@users.noreply.github.com>

github-actions · 2026-05-26T13:58:28Z

UI: Fix Monaco workers crashing in production mode

?url does not run the Vite worker pipeline. For editor.worker.js it
inlines the raw source as a base64 data URL (the source is below the
default assetsInlineLimit), and the inlined module still has bare
specifier imports it cannot resolve in a Worker context. For
json.worker.js it copies a partly-bundled file whose top-level
import '../../editor/editor.worker.js' resolves to a path that does
not exist in the build output. Both cases manifest at runtime as
"Could not create web worker(s). Falling back to loading web worker
code in main thread" followed by a stream of fallback fetch errors.

Switch to ?worker&url: Vite runs the file through the worker pipeline
(bundling all dependencies into a self-contained IIFE) and the URL
query suffix returns the resulting URL as a string instead of a Worker
constructor. The Blob shim from #67352 then imports a properly bundled
worker, restoring real worker-thread execution.

UI: Rewrite modulepreload hrefs to the api-server static path

Vite emits both <script src="./assets/..."> and
<link rel="modulepreload" href="./assets/..."> for chunks in the
built index.html. The transform-url-src plugin only rewrote
src="./assets/" to src="./static/assets/", leaving the
modulepreload hrefs untouched. Behind the api-server's /static/
mount those preload requests hit the SPA HTML fallback and the
browser fails them with Expected a JavaScript-or-Wasm module script but the server responded with a MIME type of "text/html". The chunks
themselves still load via <script src> so the app works, but every
page load wastes three round-trips on the failed preloads and floods
the console.

Apply the same static/ rewrite to href="./assets/" and switch all
three rewrites to replaceAll so multiple matches (one per chunk) are
handled — replace with a string only touches the first occurrence.

(cherry picked from commit eff567c)

Co-authored-by: Pierre Jeambrun pierrejbrun@gmail.com
Co-authored-by: Rahul Vats 43964496+vatsrahul1001@users.noreply.github.com

…path (#67548) * UI: Fix Monaco workers crashing in production mode `?url` does not run the Vite worker pipeline. For `editor.worker.js` it inlines the raw source as a base64 data URL (the source is below the default `assetsInlineLimit`), and the inlined module still has bare specifier imports it cannot resolve in a Worker context. For `json.worker.js` it copies a partly-bundled file whose top-level `import '../../editor/editor.worker.js'` resolves to a path that does not exist in the build output. Both cases manifest at runtime as "Could not create web worker(s). Falling back to loading web worker code in main thread" followed by a stream of fallback fetch errors. Switch to `?worker&url`: Vite runs the file through the worker pipeline (bundling all dependencies into a self-contained IIFE) and the URL query suffix returns the resulting URL as a string instead of a Worker constructor. The Blob shim from #67352 then imports a properly bundled worker, restoring real worker-thread execution. * UI: Rewrite modulepreload hrefs to the api-server static path Vite emits both `<script src="./assets/...">` and `<link rel="modulepreload" href="./assets/...">` for chunks in the built `index.html`. The `transform-url-src` plugin only rewrote `src="./assets/"` to `src="./static/assets/"`, leaving the modulepreload `href`s untouched. Behind the api-server's `/static/` mount those preload requests hit the SPA HTML fallback and the browser fails them with `Expected a JavaScript-or-Wasm module script but the server responded with a MIME type of "text/html"`. The chunks themselves still load via `<script src>` so the app works, but every page load wastes three round-trips on the failed preloads and floods the console. Apply the same `static/` rewrite to `href="./assets/"` and switch all three rewrites to `replaceAll` so multiple matches (one per chunk) are handled — `replace` with a string only touches the first occurrence. --------- (cherry picked from commit eff567c) Co-authored-by: Pierre Jeambrun <pierrejbrun@gmail.com> Co-authored-by: Rahul Vats <43964496+vatsrahul1001@users.noreply.github.com>

…path (#67548) (#67556) * UI: Fix Monaco workers crashing in production mode `?url` does not run the Vite worker pipeline. For `editor.worker.js` it inlines the raw source as a base64 data URL (the source is below the default `assetsInlineLimit`), and the inlined module still has bare specifier imports it cannot resolve in a Worker context. For `json.worker.js` it copies a partly-bundled file whose top-level `import '../../editor/editor.worker.js'` resolves to a path that does not exist in the build output. Both cases manifest at runtime as "Could not create web worker(s). Falling back to loading web worker code in main thread" followed by a stream of fallback fetch errors. Switch to `?worker&url`: Vite runs the file through the worker pipeline (bundling all dependencies into a self-contained IIFE) and the URL query suffix returns the resulting URL as a string instead of a Worker constructor. The Blob shim from #67352 then imports a properly bundled worker, restoring real worker-thread execution. * UI: Rewrite modulepreload hrefs to the api-server static path Vite emits both `<script src="./assets/...">` and `<link rel="modulepreload" href="./assets/...">` for chunks in the built `index.html`. The `transform-url-src` plugin only rewrote `src="./assets/"` to `src="./static/assets/"`, leaving the modulepreload `href`s untouched. Behind the api-server's `/static/` mount those preload requests hit the SPA HTML fallback and the browser fails them with `Expected a JavaScript-or-Wasm module script but the server responded with a MIME type of "text/html"`. The chunks themselves still load via `<script src>` so the app works, but every page load wastes three round-trips on the failed preloads and floods the console. Apply the same `static/` rewrite to `href="./assets/"` and switch all three rewrites to `replaceAll` so multiple matches (one per chunk) are handled — `replace` with a string only touches the first occurrence. --------- (cherry picked from commit eff567c) Co-authored-by: Pierre Jeambrun <pierrejbrun@gmail.com> Co-authored-by: Rahul Vats <43964496+vatsrahul1001@users.noreply.github.com>

github-actionsBot mentioned this pull request May 26, 2026
UI: Rewrite modulepreload hrefs to the api-server static path #67548
Merged
1 task

boring-cyborgBot added the area:UI Related to UI/UX. For Frontend Developers. label May 26, 2026

pierrejeambrun marked this pull request as ready for review May 26, 2026 14:01

pierrejeambrun requested review from bbovenzi, choo121600, guan404ming, pierrejeambrun, ryanahamilton, shubhamraj-git and vatsrahul1001 as code owners May 26, 2026 14:01

vatsrahul1001 added this to the Airflow 3.2.2 milestone May 26, 2026

vatsrahul1001 added the type:bug-fix Changelog: Bug Fixes label May 26, 2026

vatsrahul1001 approved these changes May 26, 2026
View reviewed changes

vatsrahul1001 merged commit c87d65d into v3-2-testMay 26, 2026
74 checks passed

vatsrahul1001 deleted the backport-eff567c-v3-2-test branch May 26, 2026 15:33