UI: Rewrite modulepreload hrefs to the api-server static path by pierrejeambrun · Pull Request #67548 · apache/airflow

pierrejeambrun · 2026-05-26T11:34:55Z

Vite emits both <script src="./assets/..."> and <link rel="modulepreload" href="./assets/..."> for chunks in the built index.html. The transform-url-src plugin in vite.config.ts only rewrites src="./assets/" to src="./static/assets/" — the modulepreload hrefs are left untouched.

Behind the api-server's /static/ mount those preload requests hit the SPA HTML fallback, and the browser fails them with:

Failed to load module script: 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> (whose path is rewritten), so the app keeps working. What's lost is the modulepreload optimization (those chunks aren't parallel-fetched ahead of import-graph discovery), plus each page load wastes three round-trips that return the full SPA HTML and floods the console.

Fix

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.

Verified the rebuilt dist/index.html now points all <link rel="modulepreload"> at ./static/assets/....

Note: this PR's branch is stacked on top of #67546 (the Monaco worker bundling fix); the modulepreload change is the second commit. Once #67546 merges, GitHub will collapse the diff to just the vite.config.ts change.

Was generative AI tooling used to co-author this PR?

Yes — Claude Code (Opus 4.7)

Generated-by: Claude Code (Opus 4.7) following the guidelines

`?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 apache#67352 then imports a properly bundled worker, restoring real worker-thread execution.

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.

pierrejeambrun · 2026-05-26T11:42:29Z

Only the last commit is relevant, merge #67546 first

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

Backport successfully created: v3-2-test

Note: As of Merging PRs targeted for Airflow 3.X
the committer who merges the PR is responsible for backporting the PRs that are bug fixes (generally speaking) to the maintenance branches.

In matter of doubt please ask in #release-management Slack channel.

Status	Branch	Result
✅	v3-2-test

…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>

pierrejeambrun · 2026-05-26T11:34:55Z

Vite emits both <script src="./assets/..."> and <link rel="modulepreload" href="./assets/..."> for chunks in the built index.html. The transform-url-src plugin in vite.config.ts only rewrites src="./assets/" to src="./static/assets/" — the modulepreload hrefs are left untouched.

Behind the api-server's /static/ mount those preload requests hit the SPA HTML fallback, and the browser fails them with:

Failed to load module script: 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> (whose path is rewritten), so the app keeps working. What's lost is the modulepreload optimization (those chunks aren't parallel-fetched ahead of import-graph discovery), plus each page load wastes three round-trips that return the full SPA HTML and floods the console.

Fix

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.

Verified the rebuilt dist/index.html now points all <link rel="modulepreload"> at ./static/assets/....

Note: this PR's branch is stacked on top of #67546 (the Monaco worker bundling fix); the modulepreload change is the second commit. Once #67546 merges, GitHub will collapse the diff to just the vite.config.ts change.

Was generative AI tooling used to co-author this PR?

Yes — Claude Code (Opus 4.7)

Generated-by: Claude Code (Opus 4.7) following the guidelines

`?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 apache#67352 then imports a properly bundled worker, restoring real worker-thread execution.

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.

pierrejeambrun · 2026-05-26T11:42:29Z

Only the last commit is relevant, merge #67546 first

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

Backport successfully created: v3-2-test

Note: As of Merging PRs targeted for Airflow 3.X
the committer who merges the PR is responsible for backporting the PRs that are bug fixes (generally speaking) to the maintenance branches.

In matter of doubt please ask in #release-management Slack channel.

Status	Branch	Result
✅	v3-2-test

…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>

pierrejeambrun · 2026-05-26T11:34:55Z

Vite emits both <script src="./assets/..."> and <link rel="modulepreload" href="./assets/..."> for chunks in the built index.html. The transform-url-src plugin in vite.config.ts only rewrites src="./assets/" to src="./static/assets/" — the modulepreload hrefs are left untouched.

Behind the api-server's /static/ mount those preload requests hit the SPA HTML fallback, and the browser fails them with:

Failed to load module script: 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> (whose path is rewritten), so the app keeps working. What's lost is the modulepreload optimization (those chunks aren't parallel-fetched ahead of import-graph discovery), plus each page load wastes three round-trips that return the full SPA HTML and floods the console.

Fix

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.

Verified the rebuilt dist/index.html now points all <link rel="modulepreload"> at ./static/assets/....

Note: this PR's branch is stacked on top of #67546 (the Monaco worker bundling fix); the modulepreload change is the second commit. Once #67546 merges, GitHub will collapse the diff to just the vite.config.ts change.

Was generative AI tooling used to co-author this PR?

Yes — Claude Code (Opus 4.7)

Generated-by: Claude Code (Opus 4.7) following the guidelines

`?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 apache#67352 then imports a properly bundled worker, restoring real worker-thread execution.

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.

pierrejeambrun · 2026-05-26T11:42:29Z

Only the last commit is relevant, merge #67546 first

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

Backport successfully created: v3-2-test

Note: As of Merging PRs targeted for Airflow 3.X
the committer who merges the PR is responsible for backporting the PRs that are bug fixes (generally speaking) to the maintenance branches.

In matter of doubt please ask in #release-management Slack channel.

Status	Branch	Result
✅	v3-2-test

…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>

pierrejeambrun · 2026-05-26T11:34:55Z

Vite emits both <script src="./assets/..."> and <link rel="modulepreload" href="./assets/..."> for chunks in the built index.html. The transform-url-src plugin in vite.config.ts only rewrites src="./assets/" to src="./static/assets/" — the modulepreload hrefs are left untouched.

Behind the api-server's /static/ mount those preload requests hit the SPA HTML fallback, and the browser fails them with:

Failed to load module script: 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> (whose path is rewritten), so the app keeps working. What's lost is the modulepreload optimization (those chunks aren't parallel-fetched ahead of import-graph discovery), plus each page load wastes three round-trips that return the full SPA HTML and floods the console.

Fix

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.

Verified the rebuilt dist/index.html now points all <link rel="modulepreload"> at ./static/assets/....

Note: this PR's branch is stacked on top of #67546 (the Monaco worker bundling fix); the modulepreload change is the second commit. Once #67546 merges, GitHub will collapse the diff to just the vite.config.ts change.

Was generative AI tooling used to co-author this PR?

Yes — Claude Code (Opus 4.7)

Generated-by: Claude Code (Opus 4.7) following the guidelines

`?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 apache#67352 then imports a properly bundled worker, restoring real worker-thread execution.

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.

pierrejeambrun · 2026-05-26T11:42:29Z

Only the last commit is relevant, merge #67546 first

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

Backport successfully created: v3-2-test

Note: As of Merging PRs targeted for Airflow 3.X
the committer who merges the PR is responsible for backporting the PRs that are bug fixes (generally speaking) to the maintenance branches.

In matter of doubt please ask in #release-management Slack channel.

Status	Branch	Result
✅	v3-2-test

…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>

pierrejeambrun · 2026-05-26T11:34:55Z

Vite emits both <script src="./assets/..."> and <link rel="modulepreload" href="./assets/..."> for chunks in the built index.html. The transform-url-src plugin in vite.config.ts only rewrites src="./assets/" to src="./static/assets/" — the modulepreload hrefs are left untouched.

Behind the api-server's /static/ mount those preload requests hit the SPA HTML fallback, and the browser fails them with:

Failed to load module script: 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> (whose path is rewritten), so the app keeps working. What's lost is the modulepreload optimization (those chunks aren't parallel-fetched ahead of import-graph discovery), plus each page load wastes three round-trips that return the full SPA HTML and floods the console.

Fix

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.

Verified the rebuilt dist/index.html now points all <link rel="modulepreload"> at ./static/assets/....

Note: this PR's branch is stacked on top of #67546 (the Monaco worker bundling fix); the modulepreload change is the second commit. Once #67546 merges, GitHub will collapse the diff to just the vite.config.ts change.

Was generative AI tooling used to co-author this PR?

Yes — Claude Code (Opus 4.7)

Generated-by: Claude Code (Opus 4.7) following the guidelines

`?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 apache#67352 then imports a properly bundled worker, restoring real worker-thread execution.

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.

pierrejeambrun · 2026-05-26T11:42:29Z

Only the last commit is relevant, merge #67546 first

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

Backport successfully created: v3-2-test

Note: As of Merging PRs targeted for Airflow 3.X
the committer who merges the PR is responsible for backporting the PRs that are bug fixes (generally speaking) to the maintenance branches.

In matter of doubt please ask in #release-management Slack channel.

Status	Branch	Result
✅	v3-2-test

…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>

pierrejeambrun · 2026-05-26T11:34:55Z

Vite emits both <script src="./assets/..."> and <link rel="modulepreload" href="./assets/..."> for chunks in the built index.html. The transform-url-src plugin in vite.config.ts only rewrites src="./assets/" to src="./static/assets/" — the modulepreload hrefs are left untouched.

Behind the api-server's /static/ mount those preload requests hit the SPA HTML fallback, and the browser fails them with:

Failed to load module script: 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> (whose path is rewritten), so the app keeps working. What's lost is the modulepreload optimization (those chunks aren't parallel-fetched ahead of import-graph discovery), plus each page load wastes three round-trips that return the full SPA HTML and floods the console.

Fix

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.

Verified the rebuilt dist/index.html now points all <link rel="modulepreload"> at ./static/assets/....

Note: this PR's branch is stacked on top of #67546 (the Monaco worker bundling fix); the modulepreload change is the second commit. Once #67546 merges, GitHub will collapse the diff to just the vite.config.ts change.

Was generative AI tooling used to co-author this PR?

Yes — Claude Code (Opus 4.7)

Generated-by: Claude Code (Opus 4.7) following the guidelines

`?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 apache#67352 then imports a properly bundled worker, restoring real worker-thread execution.

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.

pierrejeambrun · 2026-05-26T11:42:29Z

Only the last commit is relevant, merge #67546 first

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

Backport successfully created: v3-2-test

Note: As of Merging PRs targeted for Airflow 3.X
the committer who merges the PR is responsible for backporting the PRs that are bug fixes (generally speaking) to the maintenance branches.

In matter of doubt please ask in #release-management Slack channel.

Status	Branch	Result
✅	v3-2-test

…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>

pierrejeambrun · 2026-05-26T11:34:55Z

Vite emits both <script src="./assets/..."> and <link rel="modulepreload" href="./assets/..."> for chunks in the built index.html. The transform-url-src plugin in vite.config.ts only rewrites src="./assets/" to src="./static/assets/" — the modulepreload hrefs are left untouched.

Behind the api-server's /static/ mount those preload requests hit the SPA HTML fallback, and the browser fails them with:

Failed to load module script: 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> (whose path is rewritten), so the app keeps working. What's lost is the modulepreload optimization (those chunks aren't parallel-fetched ahead of import-graph discovery), plus each page load wastes three round-trips that return the full SPA HTML and floods the console.

Fix

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.

Verified the rebuilt dist/index.html now points all <link rel="modulepreload"> at ./static/assets/....

Note: this PR's branch is stacked on top of #67546 (the Monaco worker bundling fix); the modulepreload change is the second commit. Once #67546 merges, GitHub will collapse the diff to just the vite.config.ts change.

Was generative AI tooling used to co-author this PR?

Yes — Claude Code (Opus 4.7)

Generated-by: Claude Code (Opus 4.7) following the guidelines

`?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 apache#67352 then imports a properly bundled worker, restoring real worker-thread execution.

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.

pierrejeambrun · 2026-05-26T11:42:29Z

Only the last commit is relevant, merge #67546 first

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

Backport successfully created: v3-2-test

Note: As of Merging PRs targeted for Airflow 3.X
the committer who merges the PR is responsible for backporting the PRs that are bug fixes (generally speaking) to the maintenance branches.

In matter of doubt please ask in #release-management Slack channel.

Status	Branch	Result
✅	v3-2-test

…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>

pierrejeambrun · 2026-05-26T11:34:55Z

Vite emits both <script src="./assets/..."> and <link rel="modulepreload" href="./assets/..."> for chunks in the built index.html. The transform-url-src plugin in vite.config.ts only rewrites src="./assets/" to src="./static/assets/" — the modulepreload hrefs are left untouched.

Behind the api-server's /static/ mount those preload requests hit the SPA HTML fallback, and the browser fails them with:

Failed to load module script: 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> (whose path is rewritten), so the app keeps working. What's lost is the modulepreload optimization (those chunks aren't parallel-fetched ahead of import-graph discovery), plus each page load wastes three round-trips that return the full SPA HTML and floods the console.

Fix

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.

Verified the rebuilt dist/index.html now points all <link rel="modulepreload"> at ./static/assets/....

Note: this PR's branch is stacked on top of #67546 (the Monaco worker bundling fix); the modulepreload change is the second commit. Once #67546 merges, GitHub will collapse the diff to just the vite.config.ts change.

Was generative AI tooling used to co-author this PR?

Yes — Claude Code (Opus 4.7)

Generated-by: Claude Code (Opus 4.7) following the guidelines

`?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 apache#67352 then imports a properly bundled worker, restoring real worker-thread execution.

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.

pierrejeambrun · 2026-05-26T11:42:29Z

Only the last commit is relevant, merge #67546 first

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

Backport successfully created: v3-2-test

Note: As of Merging PRs targeted for Airflow 3.X
the committer who merges the PR is responsible for backporting the PRs that are bug fixes (generally speaking) to the maintenance branches.

In matter of doubt please ask in #release-management Slack channel.

Status	Branch	Result
✅	v3-2-test

…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>

pierrejeambrun added 2 commits May 26, 2026 13:13

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 11:41

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

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

pierrejeambrun added the backport-to-v3-2-test label May 26, 2026

vatsrahul1001 approved these changes May 26, 2026
View reviewed changes

eladkal approved these changes May 26, 2026
View reviewed changes

Merge branch 'main' into ui/fix-modulepreload-asset-paths
57e32ab

vatsrahul1001 merged commit eff567c into apache:mainMay 26, 2026
83 checks passed

vatsrahul1001 deleted the ui/fix-modulepreload-asset-paths branch May 26, 2026 13:56

bbovenzi mentioned this pull request Jun 4, 2026
Remove Monaco Editor #68032
Closed
2 tasks